repo_name
stringlengths 6
130
| hexsha
sequence | file_path
sequence | code
sequence | apis
sequence | possible_versions
list |
|---|---|---|---|---|---|
itsraina/keras | [
"5e9376b5b94b6fb445dd52dbfafbc4e95bff5e35",
"5e9376b5b94b6fb445dd52dbfafbc4e95bff5e35",
"5e9376b5b94b6fb445dd52dbfafbc4e95bff5e35",
"5e9376b5b94b6fb445dd52dbfafbc4e95bff5e35",
"5e9376b5b94b6fb445dd52dbfafbc4e95bff5e35",
"5e9376b5b94b6fb445dd52dbfafbc4e95bff5e35",
"5e9376b5b94b6fb445dd52dbfafbc4e95bff5e35",
"5e9376b5b94b6fb445dd52dbfafbc4e95bff5e35",
"5e9376b5b94b6fb445dd52dbfafbc4e95bff5e35",
"5e9376b5b94b6fb445dd52dbfafbc4e95bff5e35",
"5e9376b5b94b6fb445dd52dbfafbc4e95bff5e35",
"5e9376b5b94b6fb445dd52dbfafbc4e95bff5e35",
"5e9376b5b94b6fb445dd52dbfafbc4e95bff5e35"
] | [
"keras/feature_column/dense_features_v2.py",
"keras/applications/vgg16.py",
"keras/layers/activation/thresholded_relu_test.py",
"keras/models/sharpness_aware_minimization_test.py",
"keras/utils/dataset_utils.py",
"keras/utils/losses_utils_test.py",
"keras/benchmarks/saved_model_benchmarks/saved_model_benchmark_util.py",
"keras/layers/preprocessing/discretization_distribution_test.py",
"keras/engine/input_layer_test.py",
"keras/layers/convolutional/depthwise_conv2d.py",
"keras/layers/pooling/global_max_pooling3d.py",
"keras/integration_test/preprocessing_applied_in_dataset_creator_test.py",
"keras/layers/preprocessing/preprocessing_test_utils.py"
] | [
"# 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\"\"\"A layer that produces a dense `Tensor` based on given `feature_columns`.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport tensorflow.compat.v2 as tf\n\nfrom keras.feature_column import base_feature_layer as kfc\nfrom keras.feature_column import dense_features\nfrom keras.utils import tf_contextlib\n\n# isort: off\nfrom tensorflow.python.util.tf_export import keras_export\n\n\n@keras_export(\"keras.layers.DenseFeatures\", v1=[])\nclass DenseFeatures(dense_features.DenseFeatures):\n \"\"\"A layer that produces a dense `Tensor` based on given `feature_columns`.\n\n Generally a single example in training data is described with\n FeatureColumns. At the first layer of the model, this column oriented data\n should be converted to a single `Tensor`.\n\n This layer can be called multiple times with different features.\n\n This is the V2 version of this layer that uses name_scopes to create\n variables instead of variable_scopes. But this approach currently lacks\n support for partitioned variables. In that case, use the V1 version instead.\n\n Example:\n\n ```python\n price = tf.feature_column.numeric_column('price')\n keywords_embedded = tf.feature_column.embedding_column(\n tf.feature_column.categorical_column_with_hash_bucket(\"keywords\",\n 10000),\n dimensions=16)\n columns = [price, keywords_embedded, ...]\n feature_layer = tf.keras.layers.DenseFeatures(columns)\n\n features = tf.io.parse_example(\n ..., features=tf.feature_column.make_parse_example_spec(columns))\n dense_tensor = feature_layer(features)\n for units in [128, 64, 32]:\n dense_tensor = tf.keras.layers.Dense(units, activation='relu')(\n dense_tensor)\n prediction = tf.keras.layers.Dense(1)(dense_tensor)\n ```\n \"\"\"\n\n def __init__(self, feature_columns, trainable=True, name=None, **kwargs):\n \"\"\"Creates a DenseFeatures object.\n\n Args:\n feature_columns: An iterable containing the FeatureColumns to use as\n inputs to your model. All items should be instances of classes\n derived from `DenseColumn` such as `numeric_column`,\n `embedding_column`, `bucketized_column`, `indicator_column`. If you\n have categorical features, you can wrap them with an\n `embedding_column` or `indicator_column`.\n trainable: Boolean, whether the layer's variables will be updated via\n gradient descent during training.\n name: Name to give to the DenseFeatures.\n **kwargs: Keyword arguments to construct a layer.\n\n Raises:\n ValueError: if an item in `feature_columns` is not a `DenseColumn`.\n \"\"\"\n super().__init__(\n feature_columns=feature_columns,\n trainable=trainable,\n name=name,\n **kwargs\n )\n self._state_manager = _StateManagerImplV2(self, self.trainable)\n\n def build(self, _):\n for column in self._feature_columns:\n with tf.name_scope(column.name):\n column.create_state(self._state_manager)\n # We would like to call Layer.build and not _DenseFeaturesHelper.build.\n\n super(kfc._BaseFeaturesLayer, self).build(None)\n\n\nclass _StateManagerImplV2(tf.__internal__.feature_column.StateManager):\n \"\"\"Manages the state of DenseFeatures.\"\"\"\n\n def create_variable(\n self,\n feature_column,\n name,\n shape,\n dtype=None,\n trainable=True,\n use_resource=True,\n initializer=None,\n ):\n if name in self._cols_to_vars_map[feature_column]:\n raise ValueError(\"Variable already exists.\")\n\n # We explicitly track these variables since `name` is not guaranteed to\n # be unique and disable manual tracking that the add_weight call does.\n with no_manual_dependency_tracking_scope(self._layer):\n var = self._layer.add_weight(\n name=name,\n shape=shape,\n dtype=dtype,\n initializer=initializer,\n trainable=self._trainable and trainable,\n use_resource=use_resource,\n )\n if isinstance(var, tf.__internal__.tracking.Trackable):\n self._layer._track_trackable(var, feature_column.name + \"/\" + name)\n self._cols_to_vars_map[feature_column][name] = var\n return var\n\n\n@tf_contextlib.contextmanager\ndef no_manual_dependency_tracking_scope(obj):\n \"\"\"A context that disables manual dependency tracking for the given `obj`.\n\n Sometimes library methods might track objects on their own and we might want\n to disable that and do the tracking on our own. One can then use this\n context manager to disable the tracking the library method does and do your\n own tracking.\n\n For example:\n\n class TestLayer(tf.keras.Layer):\n def build():\n with no_manual_dependency_tracking_scope(self):\n var = self.add_weight(\"name1\") # Creates a var and doesn't track it\n # We track variable with name `name2`\n self._track_trackable(\"name2\", var)\n\n Args:\n obj: A trackable object.\n\n Yields:\n a scope in which the object doesn't track dependencies manually.\n \"\"\"\n\n previous_value = getattr(obj, \"_manual_tracking\", True)\n obj._manual_tracking = False\n try:\n yield\n finally:\n obj._manual_tracking = previous_value\n",
"# 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\n\"\"\"VGG16 model for Keras.\n\nReference:\n - [Very Deep Convolutional Networks for Large-Scale Image Recognition]\n (https://arxiv.org/abs/1409.1556) (ICLR 2015)\n\"\"\"\n\nimport tensorflow.compat.v2 as tf\n\nfrom keras import backend\nfrom keras.applications import imagenet_utils\nfrom keras.engine import training\nfrom keras.layers import VersionAwareLayers\nfrom keras.utils import data_utils\nfrom keras.utils import layer_utils\n\n# isort: off\nfrom tensorflow.python.util.tf_export import keras_export\n\nWEIGHTS_PATH = (\n \"https://storage.googleapis.com/tensorflow/keras-applications/\"\n \"vgg16/vgg16_weights_tf_dim_ordering_tf_kernels.h5\"\n)\nWEIGHTS_PATH_NO_TOP = (\n \"https://storage.googleapis.com/tensorflow/\"\n \"keras-applications/vgg16/\"\n \"vgg16_weights_tf_dim_ordering_tf_kernels_notop.h5\"\n)\n\nlayers = VersionAwareLayers()\n\n\n@keras_export(\"keras.applications.vgg16.VGG16\", \"keras.applications.VGG16\")\ndef VGG16(\n include_top=True,\n weights=\"imagenet\",\n input_tensor=None,\n input_shape=None,\n pooling=None,\n classes=1000,\n classifier_activation=\"softmax\",\n):\n \"\"\"Instantiates the VGG16 model.\n\n Reference:\n - [Very Deep Convolutional Networks for Large-Scale Image Recognition](\n https://arxiv.org/abs/1409.1556) (ICLR 2015)\n\n For image classification use cases, see\n [this page for detailed examples](\n https://keras.io/api/applications/#usage-examples-for-image-classification-models).\n\n For transfer learning use cases, make sure to read the\n [guide to transfer learning & fine-tuning](\n https://keras.io/guides/transfer_learning/).\n\n The default input size for this model is 224x224.\n\n Note: each Keras Application expects a specific kind of input preprocessing.\n For VGG16, call `tf.keras.applications.vgg16.preprocess_input` on your\n inputs before passing them to the model.\n `vgg16.preprocess_input` will convert the input images from RGB to BGR,\n then will zero-center each color channel with respect to the ImageNet\n dataset, without scaling.\n\n Args:\n include_top: whether to include the 3 fully-connected\n layers at the top of the network.\n weights: one of `None` (random initialization),\n 'imagenet' (pre-training on ImageNet),\n or the path to the weights file to be loaded.\n input_tensor: optional Keras tensor\n (i.e. output of `layers.Input()`)\n to use as image input for the model.\n input_shape: optional shape tuple, only to be specified\n if `include_top` is False (otherwise the input shape\n has to be `(224, 224, 3)`\n (with `channels_last` data format)\n or `(3, 224, 224)` (with `channels_first` data format).\n It should have exactly 3 input channels,\n and width and height should be no smaller than 32.\n E.g. `(200, 200, 3)` would be one valid value.\n pooling: Optional pooling mode for feature extraction\n when `include_top` is `False`.\n - `None` means that the output of the model will be\n the 4D tensor output of the\n last convolutional block.\n - `avg` means that global average pooling\n will be applied to the output of the\n last convolutional block, and thus\n the output of the model will be a 2D tensor.\n - `max` means that global max pooling will\n be applied.\n classes: optional number of classes to classify images\n into, only to be specified if `include_top` is True, and\n if no `weights` argument is specified.\n classifier_activation: A `str` or callable. The activation function to\n use on the \"top\" layer. Ignored unless `include_top=True`. Set\n `classifier_activation=None` to return the logits of the \"top\"\n layer. When loading pretrained weights, `classifier_activation` can\n only be `None` or `\"softmax\"`.\n\n Returns:\n A `keras.Model` instance.\n \"\"\"\n if not (weights in {\"imagenet\", None} or tf.io.gfile.exists(weights)):\n raise ValueError(\n \"The `weights` argument should be either \"\n \"`None` (random initialization), `imagenet` \"\n \"(pre-training on ImageNet), \"\n \"or the path to the weights file to be loaded. Received: \"\n f\"weights={weights}\"\n )\n\n if weights == \"imagenet\" and include_top and classes != 1000:\n raise ValueError(\n 'If using `weights` as `\"imagenet\"` with `include_top` '\n \"as true, `classes` should be 1000. \"\n f\"Received `classes={classes}`\"\n )\n # Determine proper input shape\n input_shape = imagenet_utils.obtain_input_shape(\n input_shape,\n default_size=224,\n min_size=32,\n data_format=backend.image_data_format(),\n require_flatten=include_top,\n weights=weights,\n )\n\n if input_tensor is None:\n img_input = layers.Input(shape=input_shape)\n else:\n if not backend.is_keras_tensor(input_tensor):\n img_input = layers.Input(tensor=input_tensor, shape=input_shape)\n else:\n img_input = input_tensor\n # Block 1\n x = layers.Conv2D(\n 64, (3, 3), activation=\"relu\", padding=\"same\", name=\"block1_conv1\"\n )(img_input)\n x = layers.Conv2D(\n 64, (3, 3), activation=\"relu\", padding=\"same\", name=\"block1_conv2\"\n )(x)\n x = layers.MaxPooling2D((2, 2), strides=(2, 2), name=\"block1_pool\")(x)\n\n # Block 2\n x = layers.Conv2D(\n 128, (3, 3), activation=\"relu\", padding=\"same\", name=\"block2_conv1\"\n )(x)\n x = layers.Conv2D(\n 128, (3, 3), activation=\"relu\", padding=\"same\", name=\"block2_conv2\"\n )(x)\n x = layers.MaxPooling2D((2, 2), strides=(2, 2), name=\"block2_pool\")(x)\n\n # Block 3\n x = layers.Conv2D(\n 256, (3, 3), activation=\"relu\", padding=\"same\", name=\"block3_conv1\"\n )(x)\n x = layers.Conv2D(\n 256, (3, 3), activation=\"relu\", padding=\"same\", name=\"block3_conv2\"\n )(x)\n x = layers.Conv2D(\n 256, (3, 3), activation=\"relu\", padding=\"same\", name=\"block3_conv3\"\n )(x)\n x = layers.MaxPooling2D((2, 2), strides=(2, 2), name=\"block3_pool\")(x)\n\n # Block 4\n x = layers.Conv2D(\n 512, (3, 3), activation=\"relu\", padding=\"same\", name=\"block4_conv1\"\n )(x)\n x = layers.Conv2D(\n 512, (3, 3), activation=\"relu\", padding=\"same\", name=\"block4_conv2\"\n )(x)\n x = layers.Conv2D(\n 512, (3, 3), activation=\"relu\", padding=\"same\", name=\"block4_conv3\"\n )(x)\n x = layers.MaxPooling2D((2, 2), strides=(2, 2), name=\"block4_pool\")(x)\n\n # Block 5\n x = layers.Conv2D(\n 512, (3, 3), activation=\"relu\", padding=\"same\", name=\"block5_conv1\"\n )(x)\n x = layers.Conv2D(\n 512, (3, 3), activation=\"relu\", padding=\"same\", name=\"block5_conv2\"\n )(x)\n x = layers.Conv2D(\n 512, (3, 3), activation=\"relu\", padding=\"same\", name=\"block5_conv3\"\n )(x)\n x = layers.MaxPooling2D((2, 2), strides=(2, 2), name=\"block5_pool\")(x)\n\n if include_top:\n # Classification block\n x = layers.Flatten(name=\"flatten\")(x)\n x = layers.Dense(4096, activation=\"relu\", name=\"fc1\")(x)\n x = layers.Dense(4096, activation=\"relu\", name=\"fc2\")(x)\n\n imagenet_utils.validate_activation(classifier_activation, weights)\n x = layers.Dense(\n classes, activation=classifier_activation, name=\"predictions\"\n )(x)\n else:\n if pooling == \"avg\":\n x = layers.GlobalAveragePooling2D()(x)\n elif pooling == \"max\":\n x = layers.GlobalMaxPooling2D()(x)\n\n # Ensure that the model takes into account\n # any potential predecessors of `input_tensor`.\n if input_tensor is not None:\n inputs = layer_utils.get_source_inputs(input_tensor)\n else:\n inputs = img_input\n # Create model.\n model = training.Model(inputs, x, name=\"vgg16\")\n\n # Load weights.\n if weights == \"imagenet\":\n if include_top:\n weights_path = data_utils.get_file(\n \"vgg16_weights_tf_dim_ordering_tf_kernels.h5\",\n WEIGHTS_PATH,\n cache_subdir=\"models\",\n file_hash=\"64373286793e3c8b2b4e3219cbf3544b\",\n )\n else:\n weights_path = data_utils.get_file(\n \"vgg16_weights_tf_dim_ordering_tf_kernels_notop.h5\",\n WEIGHTS_PATH_NO_TOP,\n cache_subdir=\"models\",\n file_hash=\"6d6bbae143d832006294945121d1f1fc\",\n )\n model.load_weights(weights_path)\n elif weights is not None:\n model.load_weights(weights)\n\n return model\n\n\n@keras_export(\"keras.applications.vgg16.preprocess_input\")\ndef preprocess_input(x, data_format=None):\n return imagenet_utils.preprocess_input(\n x, data_format=data_format, mode=\"caffe\"\n )\n\n\n@keras_export(\"keras.applications.vgg16.decode_predictions\")\ndef decode_predictions(preds, top=5):\n return imagenet_utils.decode_predictions(preds, top=top)\n\n\npreprocess_input.__doc__ = imagenet_utils.PREPROCESS_INPUT_DOC.format(\n mode=\"\",\n ret=imagenet_utils.PREPROCESS_INPUT_RET_DOC_CAFFE,\n error=imagenet_utils.PREPROCESS_INPUT_ERROR_DOC,\n)\ndecode_predictions.__doc__ = imagenet_utils.decode_predictions.__doc__\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\"\"\"Tests for ThresholdedReLU layer.\"\"\"\n\nimport tensorflow.compat.v2 as tf\n\nimport keras\nfrom keras.testing_infra import test_combinations\nfrom keras.testing_infra import test_utils\n\n\n@test_combinations.run_all_keras_modes\nclass ThresholdedReLUTest(test_combinations.TestCase):\n def test_thresholded_relu(self):\n test_utils.layer_test(\n keras.layers.ThresholdedReLU,\n kwargs={\"theta\": 0.5},\n input_shape=(2, 3, 4),\n supports_masking=True,\n )\n\n def test_threshold_relu_with_invalid_theta(self):\n with self.assertRaisesRegex(\n ValueError,\n \"Theta of a Thresholded ReLU layer cannot \"\n \"be None, expecting a float. Received: None\",\n ):\n test_utils.layer_test(\n keras.layers.ThresholdedReLU,\n kwargs={\"theta\": None},\n input_shape=(2, 3, 4),\n supports_masking=True,\n )\n\n with self.assertRaisesRegex(\n ValueError,\n \"The theta value of a Thresholded ReLU \"\n \"layer should be >=0. Received: -10\",\n ):\n test_utils.layer_test(\n keras.layers.ThresholdedReLU,\n kwargs={\"theta\": -10},\n input_shape=(2, 3, 4),\n supports_masking=True,\n )\n\n\nif __name__ == \"__main__\":\n tf.test.main()\n",
"\"\"\"Tests for sharpness_aware_minimization.\"\"\"\n\nimport os\n\nimport tensorflow.compat.v2 as tf\nfrom absl.testing import parameterized\n\nimport keras\nfrom keras.models import sharpness_aware_minimization\nfrom keras.optimizers.optimizer_experimental import adam\nfrom keras.testing_infra import test_utils\n\nds_combinations = tf.__internal__.distribute.combinations\n\nSTRATEGIES = [\n ds_combinations.one_device_strategy,\n ds_combinations.mirrored_strategy_with_two_gpus,\n ds_combinations.tpu_strategy,\n ds_combinations.parameter_server_strategy_3worker_2ps_1gpu,\n ds_combinations.multi_worker_mirrored_2x1_cpu,\n ds_combinations.multi_worker_mirrored_2x2_gpu,\n ds_combinations.central_storage_strategy_with_two_gpus,\n]\n\n\n@test_utils.run_v2_only\nclass SharpnessAwareMinimizationTest(tf.test.TestCase, parameterized.TestCase):\n def test_sam_model_call(self):\n model = keras.Sequential(\n [\n keras.Input([2, 2]),\n keras.layers.Dense(4),\n ]\n )\n sam_model = sharpness_aware_minimization.SharpnessAwareMinimization(\n model\n )\n data = tf.random.uniform([2, 2])\n self.assertAllClose(model(data), sam_model(data))\n\n @ds_combinations.generate(\n tf.__internal__.test.combinations.combine(strategy=STRATEGIES)\n )\n def test_sam_model_fit(self, strategy):\n with strategy.scope():\n model = keras.Sequential(\n [\n keras.Input([2, 2]),\n keras.layers.Dense(4),\n keras.layers.Dense(1),\n ]\n )\n sam_model = sharpness_aware_minimization.SharpnessAwareMinimization(\n model\n )\n data = tf.random.uniform([2, 2])\n label = data[:, 0] > 0.5\n\n sam_model.compile(\n optimizer=adam.Adam(),\n loss=keras.losses.BinaryCrossentropy(from_logits=True),\n )\n\n sam_model.fit(data, label, steps_per_epoch=1)\n\n @ds_combinations.generate(\n tf.__internal__.test.combinations.combine(strategy=STRATEGIES)\n )\n def test_sam_model_fit_with_sub_batch(self, strategy):\n with strategy.scope():\n model = keras.Sequential(\n [\n keras.Input([2, 2]),\n keras.layers.Dense(4),\n keras.layers.Dense(1),\n ]\n )\n sam_model = sharpness_aware_minimization.SharpnessAwareMinimization(\n model, num_batch_splits=4\n )\n data = tf.random.uniform([48, 2])\n label = data[:, 0] > 0.5\n\n sam_model.compile(\n optimizer=adam.Adam(),\n loss=keras.losses.BinaryCrossentropy(from_logits=True),\n )\n\n sam_model.fit(data, label, steps_per_epoch=1)\n\n def test_save_sam(self):\n model = keras.Sequential(\n [\n keras.Input([2, 2]),\n keras.layers.Dense(4),\n keras.layers.Dense(1),\n ]\n )\n sam_model = sharpness_aware_minimization.SharpnessAwareMinimization(\n model\n )\n data = tf.random.uniform([1, 2, 2])\n label = data[:, 0] > 0.5\n\n sam_model.compile(\n optimizer=adam.Adam(),\n loss=keras.losses.BinaryCrossentropy(from_logits=True),\n )\n\n sam_model.fit(data, label)\n\n path = os.path.join(self.get_temp_dir(), \"model\")\n sam_model.save(path)\n loaded_sam_model = keras.models.load_model(path)\n loaded_sam_model.load_weights(path)\n\n self.assertAllClose(sam_model(data), loaded_sam_model(data))\n\n def test_checkpoint_sam(self):\n model = keras.Sequential(\n [\n keras.Input([2, 2]),\n keras.layers.Dense(4),\n keras.layers.Dense(1),\n ]\n )\n sam_model_1 = sharpness_aware_minimization.SharpnessAwareMinimization(\n model\n )\n sam_model_2 = sharpness_aware_minimization.SharpnessAwareMinimization(\n model\n )\n data = tf.random.uniform([1, 2, 2])\n label = data[:, 0] > 0.5\n\n sam_model_1.compile(\n optimizer=adam.Adam(),\n loss=keras.losses.BinaryCrossentropy(from_logits=True),\n )\n\n sam_model_1.fit(data, label)\n\n checkpoint = tf.train.Checkpoint(sam_model_1)\n checkpoint2 = tf.train.Checkpoint(sam_model_2)\n temp_dir = self.get_temp_dir()\n save_path = checkpoint.save(temp_dir)\n checkpoint2.restore(save_path)\n\n self.assertAllClose(sam_model_1(data), sam_model_2(data))\n\n\nif __name__ == \"__main__\":\n tf.__internal__.distribute.multi_process_runner.test_main()\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\"\"\"Keras image dataset loading utilities.\"\"\"\n\nimport multiprocessing\nimport os\nimport random\nimport time\nimport warnings\n\nimport numpy as np\nimport tensorflow.compat.v2 as tf\n\n# isort: off\nfrom tensorflow.python.util.tf_export import keras_export\n\n\n@keras_export(\"keras.utils.split_dataset\", v1=[])\ndef split_dataset(\n dataset, left_size=None, right_size=None, shuffle=False, seed=None\n):\n \"\"\"Split a dataset into a left half and a right half (e.g. train / test).\n\n Args:\n dataset: A `tf.data.Dataset` object or a list/tuple of arrays with the\n same length.\n left_size: If float, it should be in range `[0, 1]` range and signifies\n the fraction of the data to pack in the left dataset. If integer, it\n signifies the number of samples to pack in the left dataset. If\n `None`, it defaults to the complement to `right_size`.\n right_size: If float, it should be in range `[0, 1]` range and signifies\n the fraction of the data to pack in the right dataset. If integer, it\n signifies the number of samples to pack in the right dataset. If\n `None`, it defaults to the complement to `left_size`.\n shuffle: Boolean, whether to shuffle the data before splitting it.\n seed: A random seed for shuffling.\n\n Returns:\n A tuple of two `tf.data.Dataset` objects: the left and right splits.\n \"\"\"\n dataset_type_spec = _get_type_spec(dataset)\n\n if dataset_type_spec not in [tf.data.Dataset, list, tuple, np.ndarray]:\n raise TypeError(\n \"The `dataset` argument must be either a `tf.data.Dataset` \"\n \"object or a list/tuple of arrays. \"\n f\"Received: dataset={dataset} of type {type(dataset)}\"\n )\n\n if right_size is None and left_size is None:\n raise ValueError(\n \"At least one of the `left_size` or `right_size` \"\n \"must be specified. Received: left_size=None and \"\n \"right_size=None\"\n )\n\n dataset_as_list = _convert_dataset_to_list(dataset, dataset_type_spec)\n\n if shuffle:\n if seed is None:\n seed = random.randint(0, int(1e6))\n random.seed(seed)\n random.shuffle(dataset_as_list)\n\n total_length = len(dataset_as_list)\n\n left_size, right_size = _rescale_dataset_split_sizes(\n left_size, right_size, total_length\n )\n left_split = list(dataset_as_list[:left_size])\n right_split = list(dataset_as_list[-right_size:])\n\n left_split = _restore_dataset_from_list(\n left_split, dataset_type_spec, dataset\n )\n right_split = _restore_dataset_from_list(\n right_split, dataset_type_spec, dataset\n )\n\n left_split = tf.data.Dataset.from_tensor_slices(left_split)\n right_split = tf.data.Dataset.from_tensor_slices(right_split)\n\n # apply batching to the splits if the dataset is batched\n if dataset_type_spec is tf.data.Dataset and is_batched(dataset):\n batch_size = get_batch_size(dataset)\n if batch_size is not None:\n left_split = left_split.batch(batch_size)\n right_split = right_split.batch(batch_size)\n\n left_split = left_split.prefetch(tf.data.AUTOTUNE)\n right_split = right_split.prefetch(tf.data.AUTOTUNE)\n\n return left_split, right_split\n\n\ndef _convert_dataset_to_list(\n dataset,\n dataset_type_spec,\n data_size_warning_flag=True,\n ensure_shape_similarity=True,\n):\n \"\"\"Convert `tf.data.Dataset` object or list/tuple of NumPy arrays to a list.\n\n Args:\n dataset : A `tf.data.Dataset` object or a list/tuple of arrays.\n dataset_type_spec : the type of the dataset\n data_size_warning_flag (bool, optional): If set to True, a warning will\n be issued if the dataset takes longer than 10 seconds to iterate.\n Defaults to True.\n ensure_shape_similarity (bool, optional): If set to True, the shape of\n the first sample will be used to validate the shape of rest of the\n samples. Defaults to True.\n\n Returns:\n List: A list of tuples/NumPy arrays.\n \"\"\"\n dataset_iterator = _get_data_iterator_from_dataset(\n dataset, dataset_type_spec\n )\n dataset_as_list = []\n\n start_time = time.time()\n for sample in _get_next_sample(\n dataset_iterator,\n ensure_shape_similarity,\n data_size_warning_flag,\n start_time,\n ):\n if dataset_type_spec in [tuple, list]:\n dataset_as_list.append(np.array(sample))\n else:\n dataset_as_list.append(sample)\n\n return dataset_as_list\n\n\ndef _get_data_iterator_from_dataset(dataset, dataset_type_spec):\n \"\"\"Get the iterator from a dataset.\n\n Args:\n dataset : A `tf.data.Dataset` object or a list/tuple of arrays.\n dataset_type_spec : the type of the dataset\n\n Raises:\n ValueError:\n - If the dataset is empty.\n - If the dataset is not a `tf.data.Dataset` object\n or a list/tuple of arrays.\n - If the dataset is a list/tuple of arrays and the\n length of the list/tuple is not equal to the number\n\n Returns:\n iterator: An `iterator` object.\n \"\"\"\n if dataset_type_spec == list:\n if len(dataset) == 0:\n raise ValueError(\n \"Received an empty list dataset. \"\n \"Please provide a non-empty list of arrays.\"\n )\n\n if _get_type_spec(dataset[0]) is np.ndarray:\n expected_shape = dataset[0].shape\n for i, element in enumerate(dataset):\n if np.array(element).shape[0] != expected_shape[0]:\n raise ValueError(\n \"Received a list of NumPy arrays with different \"\n f\"lengths. Mismatch found at index {i}, \"\n f\"Expected shape={expected_shape} \"\n f\"Received shape={np.array(element).shape}.\"\n f\"Please provide a list of NumPy arrays with \"\n f\"the same length.\"\n )\n else:\n raise ValueError(\n \"Expected a list of `numpy.ndarray` objects,\"\n f\"Received: {type(dataset[0])}\"\n )\n\n return iter(zip(*dataset))\n elif dataset_type_spec == tuple:\n if len(dataset) == 0:\n raise ValueError(\n \"Received an empty list dataset.\"\n \"Please provide a non-empty tuple of arrays.\"\n )\n\n if _get_type_spec(dataset[0]) is np.ndarray:\n expected_shape = dataset[0].shape\n for i, element in enumerate(dataset):\n if np.array(element).shape[0] != expected_shape[0]:\n raise ValueError(\n \"Received a tuple of NumPy arrays with different \"\n f\"lengths. Mismatch found at index {i}, \"\n f\"Expected shape={expected_shape} \"\n f\"Received shape={np.array(element).shape}.\"\n f\"Please provide a tuple of NumPy arrays with \"\n \"the same length.\"\n )\n else:\n raise ValueError(\n \"Expected a tuple of `numpy.ndarray` objects, \"\n f\"Received: {type(dataset[0])}\"\n )\n\n return iter(zip(*dataset))\n elif dataset_type_spec == tf.data.Dataset:\n if is_batched(dataset):\n dataset = dataset.unbatch()\n return iter(dataset)\n elif dataset_type_spec == np.ndarray:\n return iter(dataset)\n\n\ndef _get_next_sample(\n dataset_iterator,\n ensure_shape_similarity,\n data_size_warning_flag,\n start_time,\n):\n \"\"\" \"Yield data samples from the `dataset_iterator`.\n\n Args:\n dataset_iterator : An `iterator` object.\n ensure_shape_similarity (bool, optional): If set to True, the shape of\n the first sample will be used to validate the shape of rest of the\n samples. Defaults to True.\n data_size_warning_flag (bool, optional): If set to True, a warning will\n be issued if the dataset takes longer than 10 seconds to iterate.\n Defaults to True.\n start_time (float): the start time of the dataset iteration. this is\n used only if `data_size_warning_flag` is set to true.\n\n Raises:\n ValueError: - If the dataset is empty.\n - If `ensure_shape_similarity` is set to True and the\n shape of the first sample is not equal to the shape of\n atleast one of the rest of the samples.\n\n Yields:\n data_sample: A tuple/list of numpy arrays.\n \"\"\"\n try:\n dataset_iterator = iter(dataset_iterator)\n first_sample = next(dataset_iterator)\n if isinstance(first_sample, (tf.Tensor, np.ndarray)):\n first_sample_shape = np.array(first_sample).shape\n else:\n first_sample_shape = None\n ensure_shape_similarity = False\n yield first_sample\n except StopIteration:\n raise ValueError(\n \"Received an empty Dataset. `dataset` must \"\n \"be a non-empty list/tuple of `numpy.ndarray` objects \"\n \"or `tf.data.Dataset` objects.\"\n )\n\n for i, sample in enumerate(dataset_iterator):\n if ensure_shape_similarity:\n if first_sample_shape != np.array(sample).shape:\n raise ValueError(\n \"All `dataset` samples must have same shape, \"\n f\"Expected shape: {np.array(first_sample).shape} \"\n f\"Received shape: {np.array(sample).shape} at index \"\n f\"{i}.\"\n )\n if data_size_warning_flag:\n if i % 10 == 0:\n cur_time = time.time()\n # warns user if the dataset is too large to iterate within 10s\n if int(cur_time - start_time) > 10 and data_size_warning_flag:\n warnings.warn(\n \"The dataset is taking longer than 10 seconds to \"\n \"iterate over. This may be due to the size of the \"\n \"dataset. Keep in mind that the `split_dataset` \"\n \"utility is only for small in-memory dataset \"\n \"(e.g. < 10,000 samples).\",\n category=ResourceWarning,\n source=\"split_dataset\",\n )\n data_size_warning_flag = False\n yield sample\n\n\ndef _restore_dataset_from_list(\n dataset_as_list, dataset_type_spec, original_dataset\n):\n \"\"\"Restore the dataset from the list of arrays.\"\"\"\n if dataset_type_spec in [tuple, list]:\n return tuple(np.array(sample) for sample in zip(*dataset_as_list))\n elif dataset_type_spec == tf.data.Dataset:\n if isinstance(original_dataset.element_spec, dict):\n restored_dataset = {}\n for d in dataset_as_list:\n for k, v in d.items():\n if k not in restored_dataset:\n restored_dataset[k] = [v]\n else:\n restored_dataset[k].append(v)\n return restored_dataset\n else:\n return tuple(np.array(sample) for sample in zip(*dataset_as_list))\n return dataset_as_list\n\n\ndef _rescale_dataset_split_sizes(left_size, right_size, total_length):\n \"\"\"Rescale the dataset split sizes.\n\n We want to ensure that the sum of\n the split sizes is equal to the total length of the dataset.\n\n Args:\n left_size : The size of the left dataset split.\n right_size : The size of the right dataset split.\n total_length : The total length of the dataset.\n\n Raises:\n TypeError: - If `left_size` or `right_size` is not an integer or float.\n ValueError: - If `left_size` or `right_size` is negative or greater\n than 1 or greater than `total_length`.\n\n Returns:\n tuple: A tuple of rescaled left_size and right_size\n \"\"\"\n left_size_type = type(left_size)\n right_size_type = type(right_size)\n\n # check both left_size and right_size are integers or floats\n if (left_size is not None and left_size_type not in [int, float]) and (\n right_size is not None and right_size_type not in [int, float]\n ):\n raise TypeError(\n \"Invalid `left_size` and `right_size` Types. Expected: \"\n \"integer or float or None, Received: type(left_size)=\"\n f\"{left_size_type} and type(right_size)={right_size_type}\"\n )\n\n # check left_size is a integer or float\n if left_size is not None and left_size_type not in [int, float]:\n raise TypeError(\n \"Invalid `left_size` Type. Expected: int or float or None, \"\n f\"Received: type(left_size)={left_size_type}. \"\n )\n\n # check right_size is a integer or float\n if right_size is not None and right_size_type not in [int, float]:\n raise TypeError(\n f\"Invalid `right_size` Type. \"\n \"Expected: int or float or None,\"\n f\"Received: type(right_size)={right_size_type}.\"\n )\n\n # check left_size and right_size are non-zero\n if left_size == 0 and right_size == 0:\n raise ValueError(\n \"Both `left_size` and `right_size` are zero. \"\n \"At least one of the split sizes must be non-zero.\"\n )\n\n # check left_size is non-negative and less than 1 and less than total_length\n if (\n left_size_type == int\n and (left_size <= 0 or left_size >= total_length)\n or left_size_type == float\n and (left_size <= 0 or left_size >= 1)\n ):\n raise ValueError(\n \"`left_size` should be either a positive integer \"\n f\"smaller than {total_length}, or a float \"\n \"within the range `[0, 1]`. Received: left_size=\"\n f\"{left_size}\"\n )\n\n # check right_size is non-negative and less than 1 and less than\n # total_length\n if (\n right_size_type == int\n and (right_size <= 0 or right_size >= total_length)\n or right_size_type == float\n and (right_size <= 0 or right_size >= 1)\n ):\n raise ValueError(\n \"`right_size` should be either a positive integer \"\n f\"and smaller than {total_length} or a float \"\n \"within the range `[0, 1]`. Received: right_size=\"\n f\"{right_size}\"\n )\n\n # check sum of left_size and right_size is less than or equal to\n # total_length\n if (\n right_size_type == left_size_type == float\n and right_size + left_size > 1\n ):\n raise ValueError(\n \"The sum of `left_size` and `right_size` is greater \"\n \"than 1. It must be less than or equal to 1.\"\n )\n\n if left_size_type == float:\n left_size = round(left_size * total_length)\n elif left_size_type == int:\n left_size = float(left_size)\n\n if right_size_type == float:\n right_size = round(right_size * total_length)\n elif right_size_type == int:\n right_size = float(right_size)\n\n if left_size is None:\n left_size = total_length - right_size\n elif right_size is None:\n right_size = total_length - left_size\n\n if left_size + right_size > total_length:\n raise ValueError(\n \"The sum of `left_size` and `right_size` should \"\n \"be smaller than the {total_length}. \"\n f\"Received: left_size + right_size = {left_size+right_size}\"\n f\"and total_length = {total_length}\"\n )\n\n for split, side in [(left_size, \"left\"), (right_size, \"right\")]:\n if split == 0:\n raise ValueError(\n f\"With `dataset` of length={total_length}, `left_size`=\"\n f\"{left_size} and `right_size`={right_size}.\"\n f\"Resulting {side} side dataset split will be empty. \"\n \"Adjust any of the aforementioned parameters\"\n )\n\n left_size, right_size = int(left_size), int(right_size)\n return left_size, right_size\n\n\ndef _get_type_spec(dataset):\n \"\"\"Get the type spec of the dataset.\"\"\"\n if isinstance(dataset, tuple):\n return tuple\n elif isinstance(dataset, list):\n return list\n elif isinstance(dataset, np.ndarray):\n return np.ndarray\n elif isinstance(dataset, dict):\n return dict\n elif isinstance(dataset, tf.data.Dataset):\n return tf.data.Dataset\n else:\n return None\n\n\ndef is_batched(tf_dataset):\n \"\"\" \"Check if the `tf.data.Dataset` is batched.\"\"\"\n try:\n return tf_dataset.__class__.__name__ == \"BatchDataset\"\n except AttributeError:\n return False\n\n\ndef get_batch_size(tf_dataset):\n \"\"\"Get the batch size of the dataset.\"\"\"\n if is_batched(tf_dataset):\n return tf_dataset._batch_size\n else:\n return None\n\n\ndef index_directory(\n directory,\n labels,\n formats,\n class_names=None,\n shuffle=True,\n seed=None,\n follow_links=False,\n):\n \"\"\"Make list of all files in the subdirs of `directory`, with their labels.\n\n Args:\n directory: The target directory (string).\n labels: Either \"inferred\"\n (labels are generated from the directory structure),\n None (no labels),\n or a list/tuple of integer labels of the same size as the number of\n valid files found in the directory. Labels should be sorted according\n to the alphanumeric order of the image file paths\n (obtained via `os.walk(directory)` in Python).\n formats: Allowlist of file extensions to index (e.g. \".jpg\", \".txt\").\n class_names: Only valid if \"labels\" is \"inferred\". This is the explicit\n list of class names (must match names of subdirectories). Used\n to control the order of the classes\n (otherwise alphanumerical order is used).\n shuffle: Whether to shuffle the data. Default: True.\n If set to False, sorts the data in alphanumeric order.\n seed: Optional random seed for shuffling.\n follow_links: Whether to visits subdirectories pointed to by symlinks.\n\n Returns:\n tuple (file_paths, labels, class_names).\n file_paths: list of file paths (strings).\n labels: list of matching integer labels (same length as file_paths)\n class_names: names of the classes corresponding to these labels, in\n order.\n \"\"\"\n if labels is None:\n # in the no-label case, index from the parent directory down.\n subdirs = [\"\"]\n class_names = subdirs\n else:\n subdirs = []\n for subdir in sorted(tf.io.gfile.listdir(directory)):\n if tf.io.gfile.isdir(tf.io.gfile.join(directory, subdir)):\n if subdir.endswith(\"/\"):\n subdir = subdir[:-1]\n subdirs.append(subdir)\n if not class_names:\n class_names = subdirs\n else:\n if set(class_names) != set(subdirs):\n raise ValueError(\n \"The `class_names` passed did not match the \"\n \"names of the subdirectories of the target directory. \"\n f\"Expected: {subdirs}, but received: {class_names}\"\n )\n class_indices = dict(zip(class_names, range(len(class_names))))\n\n # Build an index of the files\n # in the different class subfolders.\n pool = multiprocessing.pool.ThreadPool()\n results = []\n filenames = []\n\n for dirpath in (tf.io.gfile.join(directory, subdir) for subdir in subdirs):\n results.append(\n pool.apply_async(\n index_subdirectory,\n (dirpath, class_indices, follow_links, formats),\n )\n )\n labels_list = []\n for res in results:\n partial_filenames, partial_labels = res.get()\n labels_list.append(partial_labels)\n filenames += partial_filenames\n if labels not in (\"inferred\", None):\n if len(labels) != len(filenames):\n raise ValueError(\n \"Expected the lengths of `labels` to match the number \"\n \"of files in the target directory. len(labels) is \"\n f\"{len(labels)} while we found {len(filenames)} files \"\n f\"in directory {directory}.\"\n )\n else:\n i = 0\n labels = np.zeros((len(filenames),), dtype=\"int32\")\n for partial_labels in labels_list:\n labels[i : i + len(partial_labels)] = partial_labels\n i += len(partial_labels)\n\n if labels is None:\n print(f\"Found {len(filenames)} files.\")\n else:\n print(\n f\"Found {len(filenames)} files belonging \"\n f\"to {len(class_names)} classes.\"\n )\n pool.close()\n pool.join()\n file_paths = [tf.io.gfile.join(directory, fname) for fname in filenames]\n\n if shuffle:\n # Shuffle globally to erase macro-structure\n if seed is None:\n seed = np.random.randint(1e6)\n rng = np.random.RandomState(seed)\n rng.shuffle(file_paths)\n rng = np.random.RandomState(seed)\n rng.shuffle(labels)\n return file_paths, labels, class_names\n\n\ndef iter_valid_files(directory, follow_links, formats):\n if not follow_links:\n walk = tf.io.gfile.walk(directory)\n else:\n walk = os.walk(directory, followlinks=follow_links)\n for root, _, files in sorted(walk, key=lambda x: x[0]):\n for fname in sorted(files):\n if fname.lower().endswith(formats):\n yield root, fname\n\n\ndef index_subdirectory(directory, class_indices, follow_links, formats):\n \"\"\"Recursively walks directory and list image paths and their class index.\n\n Args:\n directory: string, target directory.\n class_indices: dict mapping class names to their index.\n follow_links: boolean, whether to recursively follow subdirectories\n (if False, we only list top-level images in `directory`).\n formats: Allowlist of file extensions to index (e.g. \".jpg\", \".txt\").\n\n Returns:\n tuple `(filenames, labels)`. `filenames` is a list of relative file\n paths, and `labels` is a list of integer labels corresponding to these\n files.\n \"\"\"\n dirname = os.path.basename(directory)\n valid_files = iter_valid_files(directory, follow_links, formats)\n labels = []\n filenames = []\n for root, fname in valid_files:\n labels.append(class_indices[dirname])\n absolute_path = tf.io.gfile.join(root, fname)\n relative_path = tf.io.gfile.join(\n dirname, os.path.relpath(absolute_path, directory)\n )\n filenames.append(relative_path)\n return filenames, labels\n\n\ndef get_training_or_validation_split(samples, labels, validation_split, subset):\n \"\"\"Potentially restict samples & labels to a training or validation split.\n\n Args:\n samples: List of elements.\n labels: List of corresponding labels.\n validation_split: Float, fraction of data to reserve for validation.\n subset: Subset of the data to return.\n Either \"training\", \"validation\", or None. If None, we return all of the\n data.\n\n Returns:\n tuple (samples, labels), potentially restricted to the specified subset.\n \"\"\"\n if not validation_split:\n return samples, labels\n\n num_val_samples = int(validation_split * len(samples))\n if subset == \"training\":\n print(f\"Using {len(samples) - num_val_samples} files for training.\")\n samples = samples[:-num_val_samples]\n labels = labels[:-num_val_samples]\n elif subset == \"validation\":\n print(f\"Using {num_val_samples} files for validation.\")\n samples = samples[-num_val_samples:]\n labels = labels[-num_val_samples:]\n else:\n raise ValueError(\n '`subset` must be either \"training\" '\n f'or \"validation\", received: {subset}'\n )\n return samples, labels\n\n\ndef labels_to_dataset(labels, label_mode, num_classes):\n \"\"\"Create a tf.data.Dataset from the list/tuple of labels.\n\n Args:\n labels: list/tuple of labels to be converted into a tf.data.Dataset.\n label_mode: String describing the encoding of `labels`. Options are:\n - 'binary' indicates that the labels (there can be only 2) are encoded as\n `float32` scalars with values 0 or 1 (e.g. for `binary_crossentropy`).\n - 'categorical' means that the labels are mapped into a categorical\n vector. (e.g. for `categorical_crossentropy` loss).\n num_classes: number of classes of labels.\n\n Returns:\n A `Dataset` instance.\n \"\"\"\n label_ds = tf.data.Dataset.from_tensor_slices(labels)\n if label_mode == \"binary\":\n label_ds = label_ds.map(\n lambda x: tf.expand_dims(tf.cast(x, \"float32\"), axis=-1),\n num_parallel_calls=tf.data.AUTOTUNE,\n )\n elif label_mode == \"categorical\":\n label_ds = label_ds.map(\n lambda x: tf.one_hot(x, num_classes),\n num_parallel_calls=tf.data.AUTOTUNE,\n )\n return label_ds\n\n\ndef check_validation_split_arg(validation_split, subset, shuffle, seed):\n \"\"\"Raise errors in case of invalid argument values.\n\n Args:\n validation_split: float between 0 and 1, fraction of data to reserve for\n validation.\n subset: One of \"training\", \"validation\" or \"both\". Only used if\n `validation_split` is set.\n shuffle: Whether to shuffle the data. Either True or False.\n seed: random seed for shuffling and transformations.\n \"\"\"\n if validation_split and not 0 < validation_split < 1:\n raise ValueError(\n \"`validation_split` must be between 0 and 1, \"\n f\"received: {validation_split}\"\n )\n if (validation_split or subset) and not (validation_split and subset):\n raise ValueError(\n \"If `subset` is set, `validation_split` must be set, and inversely.\"\n )\n if subset not in (\"training\", \"validation\", \"both\", None):\n raise ValueError(\n '`subset` must be either \"training\", '\n f'\"validation\" or \"both\", received: {subset}'\n )\n if validation_split and shuffle and seed is None:\n raise ValueError(\n \"If using `validation_split` and shuffling the data, you must \"\n \"provide a `seed` argument, to make sure that there is no \"\n \"overlap between the training and validation subset.\"\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\"\"\"Tests for losses_utils.\"\"\"\n\nimport tensorflow.compat.v2 as tf\n\nfrom keras.testing_infra import test_combinations\nfrom keras.utils import losses_utils\n\n\n@test_combinations.generate(test_combinations.combine(mode=[\"graph\", \"eager\"]))\nclass RemoveSqueezableTest(tf.test.TestCase):\n \"\"\"Test remove_squeezable_dimensions\"\"\"\n\n def test_ragged_3d_same_shape(self):\n \"\"\"shape (2, (sequence={1, 2}), 3)\"\"\"\n x = tf.ragged.constant([[[1, 2, 3]], [[4, 5, 6], [7, 8, 9]]])\n rank = x.shape.ndims\n x_p, _ = losses_utils.remove_squeezable_dimensions(x, x)\n self.assertEqual(x_p.shape.ndims, rank)\n\n def test_ragged_3d_4d_squeezable(self):\n \"\"\"shapes:\n\n x: (2, (sequence={1, 2}), 3)\n y: (2, (sequence={1, 2}), 3, 1)\n \"\"\"\n x = tf.ragged.constant([[[1, 2, 3]], [[4, 5, 6], [7, 8, 9]]])\n y = tf.expand_dims(x, axis=-1)\n self.assertEqual(x.shape.ndims, 3)\n self.assertEqual(y.shape.ndims, 4)\n _, y_p = losses_utils.remove_squeezable_dimensions(x, y)\n y_p.shape.assert_is_compatible_with(x.shape)\n self.assertEqual(y_p.shape.ndims, 3)\n\n x_p, _ = losses_utils.remove_squeezable_dimensions(y, x)\n x_p.shape.assert_is_compatible_with(x.shape)\n self.assertEqual(x_p.shape.ndims, 3)\n\n def test_dense_2d_3d_squeezable(self):\n x = tf.constant([[1, 2], [3, 4]])\n y = tf.constant([[[1], [2]], [[3], [4]]])\n _, y_p = losses_utils.remove_squeezable_dimensions(x, y)\n y_p.shape.assert_is_compatible_with(x.shape)\n self.assertEqual(y_p.shape.ndims, x.shape.ndims)\n x_p, _ = losses_utils.remove_squeezable_dimensions(y, x)\n x_p.shape.assert_is_compatible_with(x.shape)\n\n\nclass RemoveSqueezableTestGraphOnly(tf.test.TestCase):\n \"\"\"Test remove_squeezable_dimensions (graph-mode only).\"\"\"\n\n def test_placeholder(self):\n \"\"\"Test dynamic rank tensors.\"\"\"\n with tf.Graph().as_default():\n x = tf.compat.v1.placeholder_with_default(\n [1.0, 2.0, 3.0], shape=None\n )\n y = tf.compat.v1.placeholder_with_default(\n [[1.0], [2.0], [3.0]], shape=None\n )\n _, y_p = losses_utils.remove_squeezable_dimensions(x, y)\n y_p.shape.assert_is_compatible_with(x.shape)\n self.assertAllEqual(tf.shape(x), tf.shape(y_p))\n x_p, _ = losses_utils.remove_squeezable_dimensions(y, x)\n x_p.shape.assert_is_compatible_with(x.shape)\n\n\nif __name__ == \"__main__\":\n tf.test.main()\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\"\"\"Utils for saved model benchmarks.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport tempfile\nimport time\n\nimport tensorflow.compat.v2 as tf\n\n\ndef save_and_load_benchmark(app):\n \"\"\"Util for saved model benchmarks.\"\"\"\n trials = 3\n\n model = app(weights=None)\n model_name = app.__name__\n\n tmp_dir = tf.compat.v1.test.get_temp_dir()\n tf.io.gfile.makedirs(tmp_dir)\n save_dir = tempfile.mkdtemp(dir=tmp_dir)\n\n total_save_time = 0\n total_load_time = 0\n\n # Run one untimed iteration of saving/loading.\n model.save(save_dir, save_format=\"tf\")\n tf.keras.models.load_model(save_dir)\n\n for _ in range(trials):\n start_time = time.time()\n model.save(save_dir, save_format=\"tf\")\n total_save_time += time.time() - start_time\n\n start_time = time.time()\n tf.keras.models.load_model(save_dir)\n total_load_time += time.time() - start_time\n\n save_result = {\n \"iters\": trials,\n \"wall_time\": total_save_time / trials,\n \"name\": \"{}.save\".format(model_name),\n }\n\n load_result = {\n \"iters\": trials,\n \"wall_time\": total_load_time / trials,\n \"name\": \"{}.load\".format(model_name),\n }\n tf.compat.v1.gfile.DeleteRecursively(save_dir)\n return save_result, load_result\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\"\"\"Distribution tests for keras.layers.preprocessing.discretization.\"\"\"\n\n\nimport numpy as np\nimport tensorflow.compat.v2 as tf\n\nimport keras\nfrom keras.distribute import strategy_combinations\nfrom keras.layers.preprocessing import discretization\nfrom keras.layers.preprocessing import preprocessing_test_utils\nfrom keras.testing_infra import test_combinations\nfrom keras.testing_infra import test_utils\n\n\n@test_utils.run_v2_only\n@tf.__internal__.distribute.combinations.generate(\n tf.__internal__.test.combinations.combine(\n strategy=strategy_combinations.all_strategies\n + strategy_combinations.multi_worker_mirrored_strategies\n + strategy_combinations.parameter_server_strategies_single_worker\n + strategy_combinations.parameter_server_strategies_multi_worker,\n mode=[\"eager\"],\n )\n)\nclass DiscretizationDistributionTest(\n test_combinations.TestCase, preprocessing_test_utils.PreprocessingLayerTest\n):\n def test_strategy(self, strategy):\n input_array = np.array([[-1.5, 1.0, 3.4, 0.5], [0.0, 3.0, 1.3, 0.0]])\n\n expected_output = [[0, 2, 3, 1], [1, 3, 2, 1]]\n expected_output_shape = [None, 4]\n\n tf.config.set_soft_device_placement(True)\n\n with strategy.scope():\n input_data = keras.Input(shape=(4,))\n layer = discretization.Discretization(\n bin_boundaries=[0.0, 1.0, 2.0]\n )\n bucket_data = layer(input_data)\n self.assertAllEqual(\n expected_output_shape, bucket_data.shape.as_list()\n )\n\n model = keras.Model(inputs=input_data, outputs=bucket_data)\n output_dataset = model.predict(input_array)\n self.assertAllEqual(expected_output, output_dataset)\n\n\nif __name__ == \"__main__\":\n tf.__internal__.distribute.multi_process_runner.test_main()\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 InputLayer construction.\"\"\"\n\nimport tensorflow.compat.v2 as tf\n\nfrom keras import backend\nfrom keras.engine import functional\nfrom keras.engine import input_layer as input_layer_lib\nfrom keras.layers import core\nfrom keras.saving import model_config\nfrom keras.testing_infra import test_combinations\n\n# isort: off\nfrom tensorflow.python.framework import type_spec\n\n\nclass TwoTensors(tf.__internal__.CompositeTensor):\n \"\"\"A simple value type to test TypeSpec.\n\n Contains two tensors (x, y) and a string (color). The color value is a\n stand-in for any extra type metadata we might need to store.\n\n This value type contains no single dtype.\n \"\"\"\n\n def __init__(self, x, y, color=\"red\", assign_variant_dtype=False):\n assert isinstance(color, str)\n self.x = tf.convert_to_tensor(x)\n self.y = tf.convert_to_tensor(y)\n self.color = color\n self.shape = tf.TensorShape(None)\n self._shape = tf.TensorShape(None)\n if assign_variant_dtype:\n self.dtype = tf.variant\n self._assign_variant_dtype = assign_variant_dtype\n\n def _type_spec(self):\n return TwoTensorsSpecNoOneDtype(\n self.x.shape,\n self.x.dtype,\n self.y.shape,\n self.y.dtype,\n color=self.color,\n assign_variant_dtype=self._assign_variant_dtype,\n )\n\n\ndef as_shape(shape):\n \"\"\"Converts the given object to a TensorShape.\"\"\"\n if isinstance(shape, tf.TensorShape):\n return shape\n else:\n return tf.TensorShape(shape)\n\n\n@type_spec.register(\"tf.TwoTensorsSpec\")\nclass TwoTensorsSpecNoOneDtype(tf.TypeSpec):\n \"\"\"A TypeSpec for the TwoTensors value type.\"\"\"\n\n def __init__(\n self,\n x_shape,\n x_dtype,\n y_shape,\n y_dtype,\n color=\"red\",\n assign_variant_dtype=False,\n ):\n self.x_shape = as_shape(x_shape)\n self.x_dtype = tf.as_dtype(x_dtype)\n self.y_shape = as_shape(y_shape)\n self.y_dtype = tf.as_dtype(y_dtype)\n self.color = color\n self.shape = tf.TensorShape(None)\n self._shape = tf.TensorShape(None)\n if assign_variant_dtype:\n self.dtype = tf.variant\n self._assign_variant_dtype = assign_variant_dtype\n\n value_type = property(lambda self: TwoTensors)\n\n @property\n def _component_specs(self):\n return (\n tf.TensorSpec(self.x_shape, self.x_dtype),\n tf.TensorSpec(self.y_shape, self.y_dtype),\n )\n\n def _to_components(self, value):\n return (value.x, value.y)\n\n def _from_components(self, components):\n x, y = components\n return TwoTensors(x, y, self.color)\n\n def _serialize(self):\n return (\n self.x_shape,\n self.x_dtype,\n self.y_shape,\n self.y_dtype,\n self.color,\n )\n\n @classmethod\n def from_value(cls, value):\n return cls(\n value.x.shape,\n value.x.dtype,\n value.y.shape,\n value.y.dtype,\n value.color,\n )\n\n\ntype_spec.register_type_spec_from_value_converter(\n TwoTensors, TwoTensorsSpecNoOneDtype.from_value\n)\n\n\nclass InputLayerTest(test_combinations.TestCase):\n @test_combinations.generate(\n test_combinations.combine(mode=[\"graph\", \"eager\"])\n )\n def testBasicOutputShapeNoBatchSize(self):\n # Create a Keras Input\n x = input_layer_lib.Input(shape=(32,), name=\"input_a\")\n self.assertAllEqual(x.shape.as_list(), [None, 32])\n\n # Verify you can construct and use a model w/ this input\n model = functional.Functional(x, x * 2.0)\n self.assertAllEqual(model(tf.ones((3, 32))), tf.ones((3, 32)) * 2.0)\n\n @test_combinations.generate(\n test_combinations.combine(mode=[\"graph\", \"eager\"])\n )\n def testBasicOutputShapeWithBatchSize(self):\n # Create a Keras Input\n x = input_layer_lib.Input(batch_size=6, shape=(32,), name=\"input_b\")\n self.assertAllEqual(x.shape.as_list(), [6, 32])\n\n # Verify you can construct and use a model w/ this input\n model = functional.Functional(x, x * 2.0)\n self.assertAllEqual(model(tf.ones(x.shape)), tf.ones(x.shape) * 2.0)\n\n @test_combinations.generate(test_combinations.combine(mode=[\"eager\"]))\n def testBasicOutputShapeNoBatchSizeInTFFunction(self):\n model = None\n\n @tf.function\n def run_model(inp):\n nonlocal model\n if not model:\n # Create a Keras Input\n x = input_layer_lib.Input(shape=(8,), name=\"input_a\")\n self.assertAllEqual(x.shape.as_list(), [None, 8])\n\n # Verify you can construct and use a model w/ this input\n model = functional.Functional(x, x * 2.0)\n return model(inp)\n\n self.assertAllEqual(run_model(tf.ones((10, 8))), tf.ones((10, 8)) * 2.0)\n\n @test_combinations.generate(\n test_combinations.combine(mode=[\"graph\", \"eager\"])\n )\n def testInputTensorArg(self):\n # Create a Keras Input\n x = input_layer_lib.Input(tensor=tf.zeros((7, 32)))\n self.assertAllEqual(x.shape.as_list(), [7, 32])\n\n # Verify you can construct and use a model w/ this input\n model = functional.Functional(x, x * 2.0)\n self.assertAllEqual(model(tf.ones(x.shape)), tf.ones(x.shape) * 2.0)\n\n @test_combinations.generate(test_combinations.combine(mode=[\"eager\"]))\n def testInputTensorArgInTFFunction(self):\n # We use a mutable model container instead of a model python variable,\n # because python 2.7 does not have `nonlocal`\n model_container = {}\n\n @tf.function\n def run_model(inp):\n if not model_container:\n # Create a Keras Input\n x = input_layer_lib.Input(tensor=tf.zeros((10, 16)))\n self.assertAllEqual(x.shape.as_list(), [10, 16])\n\n # Verify you can construct and use a model w/ this input\n model_container[\"model\"] = functional.Functional(x, x * 3.0)\n return model_container[\"model\"](inp)\n\n self.assertAllEqual(\n run_model(tf.ones((10, 16))), tf.ones((10, 16)) * 3.0\n )\n\n @test_combinations.generate(test_combinations.combine(mode=[\"eager\"]))\n def testCompositeInputTensorArg(self):\n # Create a Keras Input\n rt = tf.RaggedTensor.from_row_splits(\n values=[3, 1, 4, 1, 5, 9, 2, 6], row_splits=[0, 4, 4, 7, 8, 8]\n )\n x = input_layer_lib.Input(tensor=rt)\n\n # Verify you can construct and use a model w/ this input\n model = functional.Functional(x, x * 2)\n\n # And that the model works\n rt = tf.RaggedTensor.from_row_splits(\n values=[3, 21, 4, 1, 53, 9, 2, 6], row_splits=[0, 4, 4, 7, 8, 8]\n )\n self.assertAllEqual(model(rt), rt * 2)\n\n @test_combinations.generate(test_combinations.combine(mode=[\"eager\"]))\n def testCompositeInputTensorArgInTFFunction(self):\n # We use a mutable model container instead of a model python variable,\n # because python 2.7 does not have `nonlocal`\n model_container = {}\n\n @tf.function\n def run_model(inp):\n if not model_container:\n # Create a Keras Input\n rt = tf.RaggedTensor.from_row_splits(\n values=[3, 1, 4, 1, 5, 9, 2, 6],\n row_splits=[0, 4, 4, 7, 8, 8],\n )\n x = input_layer_lib.Input(tensor=rt)\n\n # Verify you can construct and use a model w/ this input\n model_container[\"model\"] = functional.Functional(x, x * 3)\n return model_container[\"model\"](inp)\n\n # And verify the model works\n rt = tf.RaggedTensor.from_row_splits(\n values=[3, 21, 4, 1, 53, 9, 2, 6], row_splits=[0, 4, 4, 7, 8, 8]\n )\n self.assertAllEqual(run_model(rt), rt * 3)\n\n @test_combinations.generate(test_combinations.combine(mode=[\"eager\"]))\n def testNoMixingArgsWithTypeSpecArg(self):\n with self.assertRaisesRegexp(\n ValueError, \"all other args except `name` must be None\"\n ):\n input_layer_lib.Input(\n shape=(4, 7), type_spec=tf.TensorSpec((2, 7, 32), tf.float32)\n )\n with self.assertRaisesRegexp(\n ValueError, \"all other args except `name` must be None\"\n ):\n input_layer_lib.Input(\n batch_size=4, type_spec=tf.TensorSpec((7, 32), tf.float32)\n )\n with self.assertRaisesRegexp(\n ValueError, \"all other args except `name` must be None\"\n ):\n input_layer_lib.Input(\n dtype=tf.int64, type_spec=tf.TensorSpec((7, 32), tf.float32)\n )\n with self.assertRaisesRegexp(\n ValueError, \"all other args except `name` must be None\"\n ):\n input_layer_lib.Input(\n sparse=True, type_spec=tf.TensorSpec((7, 32), tf.float32)\n )\n with self.assertRaisesRegexp(\n ValueError, \"all other args except `name` must be None\"\n ):\n input_layer_lib.Input(\n ragged=True, type_spec=tf.TensorSpec((7, 32), tf.float32)\n )\n\n @test_combinations.generate(test_combinations.combine(mode=[\"eager\"]))\n def testTypeSpecArg(self):\n # Create a Keras Input\n x = input_layer_lib.Input(type_spec=tf.TensorSpec((7, 32), tf.float32))\n self.assertAllEqual(x.shape.as_list(), [7, 32])\n\n # Verify you can construct and use a model w/ this input\n model = functional.Functional(x, x * 2.0)\n self.assertAllEqual(model(tf.ones(x.shape)), tf.ones(x.shape) * 2.0)\n\n # Test serialization / deserialization\n model = functional.Functional.from_config(model.get_config())\n self.assertAllEqual(model(tf.ones(x.shape)), tf.ones(x.shape) * 2.0)\n\n model = model_config.model_from_json(model.to_json())\n self.assertAllEqual(model(tf.ones(x.shape)), tf.ones(x.shape) * 2.0)\n\n @test_combinations.generate(test_combinations.combine(mode=[\"eager\"]))\n def testTypeSpecArgInTFFunction(self):\n # We use a mutable model container instead of a model python variable,\n # because python 2.7 does not have `nonlocal`\n model_container = {}\n\n @tf.function\n def run_model(inp):\n if not model_container:\n # Create a Keras Input\n x = input_layer_lib.Input(\n type_spec=tf.TensorSpec((10, 16), tf.float32)\n )\n self.assertAllEqual(x.shape.as_list(), [10, 16])\n\n # Verify you can construct and use a model w/ this input\n model_container[\"model\"] = functional.Functional(x, x * 3.0)\n return model_container[\"model\"](inp)\n\n self.assertAllEqual(\n run_model(tf.ones((10, 16))), tf.ones((10, 16)) * 3.0\n )\n\n @test_combinations.generate(test_combinations.combine(mode=[\"eager\"]))\n def testCompositeTypeSpecArg(self):\n # Create a Keras Input\n rt = tf.RaggedTensor.from_row_splits(\n values=[3, 1, 4, 1, 5, 9, 2, 6], row_splits=[0, 4, 4, 7, 8, 8]\n )\n x = input_layer_lib.Input(type_spec=rt._type_spec)\n\n # Verify you can construct and use a model w/ this input\n model = functional.Functional(x, x * 2)\n\n # And that the model works\n rt = tf.RaggedTensor.from_row_splits(\n values=[3, 21, 4, 1, 53, 9, 2, 6], row_splits=[0, 4, 4, 7, 8, 8]\n )\n self.assertAllEqual(model(rt), rt * 2)\n\n # Test serialization / deserialization\n model = functional.Functional.from_config(model.get_config())\n self.assertAllEqual(model(rt), rt * 2)\n model = model_config.model_from_json(model.to_json())\n self.assertAllEqual(model(rt), rt * 2)\n\n @test_combinations.generate(test_combinations.combine(mode=[\"eager\"]))\n def testCompositeTypeSpecArgInTFFunction(self):\n # We use a mutable model container instead of a model pysthon variable,\n # because python 2.7 does not have `nonlocal`\n model_container = {}\n\n @tf.function\n def run_model(inp):\n if not model_container:\n # Create a Keras Input\n rt = tf.RaggedTensor.from_row_splits(\n values=[3, 1, 4, 1, 5, 9, 2, 6],\n row_splits=[0, 4, 4, 7, 8, 8],\n )\n x = input_layer_lib.Input(type_spec=rt._type_spec)\n\n # Verify you can construct and use a model w/ this input\n model_container[\"model\"] = functional.Functional(x, x * 3)\n return model_container[\"model\"](inp)\n\n # And verify the model works\n rt = tf.RaggedTensor.from_row_splits(\n values=[3, 21, 4, 1, 53, 9, 2, 6], row_splits=[0, 4, 4, 7, 8, 8]\n )\n self.assertAllEqual(run_model(rt), rt * 3)\n\n @test_combinations.generate(test_combinations.combine(mode=[\"eager\"]))\n def testCompositeTypeSpecArgWithoutDtype(self):\n for assign_variant_dtype in [False, True]:\n # Create a Keras Input\n spec = TwoTensorsSpecNoOneDtype(\n (1, 2, 3),\n tf.float32,\n (1, 2, 3),\n tf.int64,\n assign_variant_dtype=assign_variant_dtype,\n )\n x = input_layer_lib.Input(type_spec=spec)\n\n def lambda_fn(tensors):\n return tf.cast(tensors.x, tf.float64) + tf.cast(\n tensors.y, tf.float64\n )\n\n # Verify you can construct and use a model w/ this input\n model = functional.Functional(x, core.Lambda(lambda_fn)(x))\n\n # And that the model works\n two_tensors = TwoTensors(tf.ones((1, 2, 3)) * 2.0, tf.ones(1, 2, 3))\n self.assertAllEqual(model(two_tensors), lambda_fn(two_tensors))\n\n # Test serialization / deserialization\n model = functional.Functional.from_config(model.get_config())\n self.assertAllEqual(model(two_tensors), lambda_fn(two_tensors))\n model = model_config.model_from_json(model.to_json())\n self.assertAllEqual(model(two_tensors), lambda_fn(two_tensors))\n\n def test_serialize_with_unknown_rank(self):\n inp = backend.placeholder(shape=None, dtype=tf.string)\n x = input_layer_lib.InputLayer(input_tensor=inp, dtype=tf.string)\n loaded = input_layer_lib.InputLayer.from_config(x.get_config())\n self.assertIsNone(loaded._batch_input_shape)\n\n\nif __name__ == \"__main__\":\n tf.test.main()\n",
"# 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\"\"\"Keras depthwise 2D convolution.\"\"\"\n\n\nfrom keras import backend\nfrom keras.layers.convolutional.base_depthwise_conv import DepthwiseConv\nfrom keras.utils import conv_utils\nfrom keras.utils import tf_utils\n\n# isort: off\nfrom tensorflow.python.util.tf_export import keras_export\n\n\n@keras_export(\"keras.layers.DepthwiseConv2D\")\nclass DepthwiseConv2D(DepthwiseConv):\n \"\"\"Depthwise 2D convolution.\n\n Depthwise convolution is a type of convolution in which each input channel\n is convolved with a different kernel (called a depthwise kernel). You can\n understand depthwise convolution as the first step in a depthwise separable\n convolution.\n\n It is implemented via the following steps:\n\n - Split the input into individual channels.\n - Convolve each channel with an individual depthwise kernel with\n `depth_multiplier` output channels.\n - Concatenate the convolved outputs along the channels axis.\n\n Unlike a regular 2D convolution, depthwise convolution does not mix\n information across different input channels.\n\n The `depth_multiplier` argument determines how many filter are applied to\n one input channel. As such, it controls the amount of output channels that\n are generated per input channel in the depthwise step.\n\n Args:\n kernel_size: An integer or tuple/list of 2 integers, specifying the height\n and width of the 2D convolution window. Can be a single integer to\n specify the same value for all spatial dimensions.\n strides: An integer or tuple/list of 2 integers, specifying the strides of\n the convolution along the height and width. Can be a single integer to\n specify the same value for all spatial dimensions. Specifying any stride\n value != 1 is incompatible with specifying any `dilation_rate` value !=\n 1.\n padding: one of `'valid'` or `'same'` (case-insensitive). `\"valid\"` means\n no padding. `\"same\"` results in padding with zeros evenly to the\n left/right or up/down of the input such that output has the same\n height/width dimension as the input.\n depth_multiplier: The number of depthwise convolution output channels for\n each input channel. The total number of depthwise convolution output\n channels will be equal to `filters_in * depth_multiplier`.\n data_format: A string, one of `channels_last` (default) or\n `channels_first`. The ordering of the dimensions in the inputs.\n `channels_last` corresponds to inputs with shape `(batch_size, height,\n width, channels)` while `channels_first` corresponds to inputs with\n shape `(batch_size, channels, height, width)`. It defaults to the\n `image_data_format` value found in your Keras config file at\n `~/.keras/keras.json`. If you never set it, then it will be\n 'channels_last'.\n dilation_rate: An integer or tuple/list of 2 integers, specifying the\n dilation rate to use for dilated convolution. Currently, specifying any\n `dilation_rate` value != 1 is incompatible with specifying any `strides`\n value != 1.\n activation: Activation function to use. If you don't specify anything, no\n activation is applied (see `keras.activations`).\n use_bias: Boolean, whether the layer uses a bias vector.\n depthwise_initializer: Initializer for the depthwise kernel matrix (see\n `keras.initializers`). If None, the default initializer\n ('glorot_uniform') will be used.\n bias_initializer: Initializer for the bias vector (see\n `keras.initializers`). If None, the default initializer ('zeros') will\n be used.\n depthwise_regularizer: Regularizer function applied to the depthwise\n kernel matrix (see `keras.regularizers`).\n bias_regularizer: Regularizer function applied to the bias vector (see\n `keras.regularizers`).\n activity_regularizer: Regularizer function applied to the output of the\n layer (its 'activation') (see `keras.regularizers`).\n depthwise_constraint: Constraint function applied to the depthwise kernel\n matrix (see `keras.constraints`).\n bias_constraint: Constraint function applied to the bias vector (see\n `keras.constraints`).\n\n Input shape:\n 4D tensor with shape: `[batch_size, channels, rows, cols]` if\n data_format='channels_first'\n or 4D tensor with shape: `[batch_size, rows, cols, channels]` if\n data_format='channels_last'.\n\n Output shape:\n 4D tensor with shape: `[batch_size, channels * depth_multiplier, new_rows,\n new_cols]` if `data_format='channels_first'`\n or 4D tensor with shape: `[batch_size,\n new_rows, new_cols, channels * depth_multiplier]` if\n `data_format='channels_last'`. `rows` and `cols` values might have\n changed due to padding.\n\n Returns:\n A tensor of rank 4 representing\n `activation(depthwiseconv2d(inputs, kernel) + bias)`.\n\n Raises:\n ValueError: if `padding` is \"causal\".\n ValueError: when both `strides` > 1 and `dilation_rate` > 1.\n \"\"\"\n\n def __init__(\n self,\n kernel_size,\n strides=(1, 1),\n padding=\"valid\",\n depth_multiplier=1,\n data_format=None,\n dilation_rate=(1, 1),\n activation=None,\n use_bias=True,\n depthwise_initializer=\"glorot_uniform\",\n bias_initializer=\"zeros\",\n depthwise_regularizer=None,\n bias_regularizer=None,\n activity_regularizer=None,\n depthwise_constraint=None,\n bias_constraint=None,\n **kwargs\n ):\n super().__init__(\n 2,\n kernel_size=kernel_size,\n strides=strides,\n padding=padding,\n depth_multiplier=depth_multiplier,\n data_format=data_format,\n dilation_rate=dilation_rate,\n activation=activation,\n use_bias=use_bias,\n depthwise_initializer=depthwise_initializer,\n bias_initializer=bias_initializer,\n depthwise_regularizer=depthwise_regularizer,\n bias_regularizer=bias_regularizer,\n activity_regularizer=activity_regularizer,\n depthwise_constraint=depthwise_constraint,\n bias_constraint=bias_constraint,\n **kwargs\n )\n\n def call(self, inputs):\n outputs = backend.depthwise_conv2d(\n inputs,\n self.depthwise_kernel,\n strides=self.strides,\n padding=self.padding,\n dilation_rate=self.dilation_rate,\n data_format=self.data_format,\n )\n\n if self.use_bias:\n outputs = backend.bias_add(\n outputs, self.bias, data_format=self.data_format\n )\n\n if self.activation is not None:\n return self.activation(outputs)\n\n return outputs\n\n @tf_utils.shape_type_conversion\n def compute_output_shape(self, input_shape):\n if self.data_format == \"channels_first\":\n rows = input_shape[2]\n cols = input_shape[3]\n out_filters = input_shape[1] * self.depth_multiplier\n elif self.data_format == \"channels_last\":\n rows = input_shape[1]\n cols = input_shape[2]\n out_filters = input_shape[3] * self.depth_multiplier\n\n rows = conv_utils.conv_output_length(\n rows,\n self.kernel_size[0],\n self.padding,\n self.strides[0],\n self.dilation_rate[0],\n )\n cols = conv_utils.conv_output_length(\n cols,\n self.kernel_size[1],\n self.padding,\n self.strides[1],\n self.dilation_rate[1],\n )\n if self.data_format == \"channels_first\":\n return (input_shape[0], out_filters, rows, cols)\n elif self.data_format == \"channels_last\":\n return (input_shape[0], rows, cols, out_filters)\n",
"# 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\"\"\"Global max pooling 3D layer.\"\"\"\n\n\nfrom keras import backend\nfrom keras.layers.pooling.base_global_pooling3d import GlobalPooling3D\n\n# isort: off\nfrom tensorflow.python.util.tf_export import keras_export\n\n\n@keras_export(\"keras.layers.GlobalMaxPool3D\", \"keras.layers.GlobalMaxPooling3D\")\nclass GlobalMaxPooling3D(GlobalPooling3D):\n \"\"\"Global Max pooling operation for 3D data.\n\n Args:\n data_format: A string,\n one of `channels_last` (default) or `channels_first`.\n The ordering of the dimensions in the inputs.\n `channels_last` corresponds to inputs with shape\n `(batch, spatial_dim1, spatial_dim2, spatial_dim3, channels)`\n while `channels_first` corresponds to inputs with shape\n `(batch, channels, spatial_dim1, spatial_dim2, spatial_dim3)`.\n It defaults to the `image_data_format` value found in your\n Keras config file at `~/.keras/keras.json`.\n If you never set it, then it will be \"channels_last\".\n keepdims: A boolean, whether to keep the spatial dimensions or not.\n If `keepdims` is `False` (default), the rank of the tensor is reduced\n for spatial dimensions.\n If `keepdims` is `True`, the spatial dimensions are retained with\n length 1.\n The behavior is the same as for `tf.reduce_max` or `np.max`.\n\n Input shape:\n - If `data_format='channels_last'`:\n 5D tensor with shape:\n `(batch_size, spatial_dim1, spatial_dim2, spatial_dim3, channels)`\n - If `data_format='channels_first'`:\n 5D tensor with shape:\n `(batch_size, channels, spatial_dim1, spatial_dim2, spatial_dim3)`\n\n Output shape:\n - If `keepdims`=False:\n 2D tensor with shape `(batch_size, channels)`.\n - If `keepdims`=True:\n - If `data_format='channels_last'`:\n 5D tensor with shape `(batch_size, 1, 1, 1, channels)`\n - If `data_format='channels_first'`:\n 5D tensor with shape `(batch_size, channels, 1, 1, 1)`\n \"\"\"\n\n def call(self, inputs):\n if self.data_format == \"channels_last\":\n return backend.max(inputs, axis=[1, 2, 3], keepdims=self.keepdims)\n else:\n return backend.max(inputs, axis=[2, 3, 4], keepdims=self.keepdims)\n\n\n# Alias\n\nGlobalMaxPool3D = GlobalMaxPooling3D\n",
"# Copyright 2021 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\"\"\"Demonstrate Keras preprocessing layers applied in tf.data.Dataset.map.\"\"\"\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport tensorflow.compat.v2 as tf\n\nfrom keras.integration_test import preprocessing_test_utils as utils\n\nds_combinations = tf.__internal__.distribute.combinations\nmulti_process_runner = tf.__internal__.distribute.multi_process_runner\ntest_combinations = tf.__internal__.test.combinations\n\n# Note: Strategy combinations are not (yet) public APIs, so they are subject\n# to API changes and backward-compatibility is not guaranteed.\nSTRATEGIES = [\n ds_combinations.default_strategy,\n ds_combinations.mirrored_strategy_with_cpu_1_and_2,\n ds_combinations.mirrored_strategy_with_two_gpus,\n ds_combinations.tpu_strategy,\n ds_combinations.cloud_tpu_strategy,\n ds_combinations.parameter_server_strategy_3worker_2ps_cpu,\n ds_combinations.parameter_server_strategy_3worker_2ps_1gpu,\n ds_combinations.multi_worker_mirrored_2x1_cpu,\n ds_combinations.multi_worker_mirrored_2x2_gpu,\n ds_combinations.central_storage_strategy_with_two_gpus,\n]\n\n\n@ds_combinations.generate(\n test_combinations.combine(strategy=STRATEGIES, mode=\"eager\")\n)\nclass PreprocessingAppliedInDatasetCreatorTest(tf.test.TestCase):\n \"\"\"Demonstrate Keras preprocessing layers applied in tf.data.Dataset.map.\"\"\"\n\n def testDistributedModelFit(self, strategy):\n if not tf.__internal__.tf2.enabled() and isinstance(\n strategy, tf.distribute.experimental.ParameterServerStrategy\n ):\n self.skipTest(\n \"Parameter Server strategy with dataset creator need to be run \"\n \"when eager execution is enabled.\"\n )\n with strategy.scope():\n preprocessing_model = utils.make_preprocessing_model(\n self.get_temp_dir()\n )\n training_model = utils.make_training_model()\n training_model.compile(optimizer=\"sgd\", loss=\"binary_crossentropy\")\n\n def dataset_fn(input_context):\n dataset = utils.make_dataset()\n dataset = dataset.shard(\n input_context.num_input_pipelines,\n input_context.input_pipeline_id,\n )\n batch_size = input_context.get_per_replica_batch_size(\n global_batch_size=utils.BATCH_SIZE\n )\n dataset = dataset.batch(batch_size).repeat().prefetch(2)\n return dataset.map(lambda x, y: (preprocessing_model(x), y))\n\n dataset_creator = tf.keras.utils.experimental.DatasetCreator(dataset_fn)\n training_model.fit(\n dataset_creator, epochs=2, steps_per_epoch=utils.STEPS\n )\n\n\nif __name__ == \"__main__\":\n multi_process_runner.test_main()\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 utils for preprocessing layers.\"\"\"\n\nimport collections\n\nimport numpy as np\nimport tensorflow.compat.v2 as tf\n\n\nclass ArrayLike:\n def __init__(self, values):\n self.values = values\n\n def __array__(self):\n return np.array(self.values)\n\n\nclass PreprocessingLayerTest(tf.test.TestCase):\n \"\"\"Base test class for preprocessing layer API validation.\"\"\"\n\n # TODO(b/137303934): Consider incorporating something like this Close vs All\n # behavior into core tf.test.TestCase.\n\n def assertAllCloseOrEqual(self, a, b, msg=None):\n \"\"\"Asserts that elements are close (if numeric) or equal (if string).\"\"\"\n if a is None or b is None:\n self.assertAllEqual(a, b, msg=msg)\n elif isinstance(a, (list, tuple)):\n self.assertEqual(len(a), len(b))\n for a_value, b_value in zip(a, b):\n self.assertAllCloseOrEqual(a_value, b_value, msg=msg)\n elif isinstance(a, collections.abc.Mapping):\n self.assertEqual(len(a), len(b))\n for key, a_value in a.items():\n b_value = b[key]\n error_message = \"{} ({})\".format(msg, key) if msg else None\n self.assertAllCloseOrEqual(a_value, b_value, error_message)\n elif (\n isinstance(a, float)\n or hasattr(a, \"dtype\")\n and np.issubdtype(a.dtype, np.number)\n ):\n self.assertAllClose(a, b, msg=msg)\n else:\n self.assertAllEqual(a, b, msg=msg)\n\n def assert_extracted_output_equal(self, combiner, acc1, acc2, msg=None):\n data_1 = combiner.extract(acc1)\n data_2 = combiner.extract(acc2)\n self.assertAllCloseOrEqual(data_1, data_2, msg=msg)\n\n # This is an injection seam so that tests like TextVectorizationTest can\n # define their own methods for asserting that accumulators are equal.\n compare_accumulators = assertAllCloseOrEqual\n\n def validate_accumulator_computation(self, combiner, data, expected):\n \"\"\"Validate that various combinations of compute and merge are\n identical.\"\"\"\n if len(data) < 4:\n raise AssertionError(\n f\"Data must have at least 4 elements. Received \"\n f\"len(data)={len(data)}.\"\n )\n data_0 = np.array([data[0]])\n data_1 = np.array([data[1]])\n data_2 = np.array(data[2:])\n\n single_compute = combiner.compute(data)\n\n all_merge = combiner.merge(\n [\n combiner.compute(data_0),\n combiner.compute(data_1),\n combiner.compute(data_2),\n ]\n )\n\n self.compare_accumulators(\n single_compute,\n all_merge,\n msg=\"Sharding data should not change the data output.\",\n )\n\n unordered_all_merge = combiner.merge(\n [\n combiner.compute(data_1),\n combiner.compute(data_2),\n combiner.compute(data_0),\n ]\n )\n self.compare_accumulators(\n all_merge,\n unordered_all_merge,\n msg=\"The order of merge arguments should not change the data \"\n \"output.\",\n )\n\n hierarchical_merge = combiner.merge(\n [\n combiner.compute(data_1),\n combiner.merge(\n [combiner.compute(data_2), combiner.compute(data_0)]\n ),\n ]\n )\n self.compare_accumulators(\n all_merge,\n hierarchical_merge,\n msg=\"Nesting merge arguments should not change the data output.\",\n )\n\n nested_compute = combiner.compute(\n data_0, combiner.compute(data_1, combiner.compute(data_2))\n )\n self.compare_accumulators(\n all_merge,\n nested_compute,\n msg=\"Nesting compute arguments should not change the data output.\",\n )\n\n mixed_compute = combiner.merge(\n [\n combiner.compute(data_0),\n combiner.compute(data_1, combiner.compute(data_2)),\n ]\n )\n self.compare_accumulators(\n all_merge,\n mixed_compute,\n msg=\"Mixing merge and compute calls should not change the data \"\n \"output.\",\n )\n\n single_merge = combiner.merge(\n [\n combiner.merge([combiner.compute(data_0)]),\n combiner.compute(data_1, combiner.compute(data_2)),\n ]\n )\n self.compare_accumulators(\n all_merge,\n single_merge,\n msg=\"Calling merge with a data length of 1 should not change \"\n \"the data output.\",\n )\n\n self.compare_accumulators(\n expected,\n all_merge,\n msg=\"Calculated accumulators \"\n \"did not match expected accumulator.\",\n )\n\n def validate_accumulator_extract(self, combiner, data, expected):\n \"\"\"Validate that the expected results of computing and extracting.\"\"\"\n acc = combiner.compute(data)\n extracted_data = combiner.extract(acc)\n self.assertAllCloseOrEqual(expected, extracted_data)\n\n def validate_accumulator_extract_and_restore(\n self, combiner, data, expected\n ):\n \"\"\"Validate that the extract<->restore loop loses no data.\"\"\"\n acc = combiner.compute(data)\n extracted_data = combiner.extract(acc)\n restored_acc = combiner.restore(extracted_data)\n self.assert_extracted_output_equal(combiner, acc, restored_acc)\n self.assertAllCloseOrEqual(expected, combiner.extract(restored_acc))\n\n def validate_accumulator_serialize_and_deserialize(\n self, combiner, data, expected\n ):\n \"\"\"Validate that the serialize<->deserialize loop loses no data.\"\"\"\n acc = combiner.compute(data)\n serialized_data = combiner.serialize(acc)\n deserialized_data = combiner.deserialize(serialized_data)\n self.compare_accumulators(acc, deserialized_data)\n self.compare_accumulators(expected, deserialized_data)\n\n def validate_accumulator_uniqueness(self, combiner, data):\n \"\"\"Validate that every call to compute creates a unique accumulator.\"\"\"\n acc = combiner.compute(data)\n acc2 = combiner.compute(data)\n self.assertIsNot(acc, acc2)\n self.compare_accumulators(acc, acc2)\n"
] | [
[
"tensorflow.python.util.tf_export.keras_export",
"tensorflow.compat.v2.name_scope"
],
[
"tensorflow.python.util.tf_export.keras_export",
"tensorflow.compat.v2.io.gfile.exists"
],
[
"tensorflow.compat.v2.test.main"
],
[
"tensorflow.compat.v2.random.uniform",
"tensorflow.compat.v2.__internal__.distribute.multi_process_runner.test_main",
"tensorflow.compat.v2.train.Checkpoint",
"tensorflow.compat.v2.__internal__.test.combinations.combine"
],
[
"tensorflow.compat.v2.data.Dataset.from_tensor_slices",
"tensorflow.python.util.tf_export.keras_export",
"tensorflow.compat.v2.cast",
"tensorflow.compat.v2.io.gfile.join",
"tensorflow.compat.v2.one_hot",
"numpy.random.randint",
"tensorflow.compat.v2.io.gfile.listdir",
"numpy.array",
"numpy.random.RandomState",
"tensorflow.compat.v2.io.gfile.walk"
],
[
"tensorflow.compat.v2.test.main",
"tensorflow.compat.v2.ragged.constant",
"tensorflow.compat.v2.shape",
"tensorflow.compat.v2.Graph",
"tensorflow.compat.v2.expand_dims",
"tensorflow.compat.v2.constant",
"tensorflow.compat.v2.compat.v1.placeholder_with_default"
],
[
"tensorflow.compat.v2.keras.models.load_model",
"tensorflow.compat.v2.compat.v1.gfile.DeleteRecursively",
"tensorflow.compat.v2.io.gfile.makedirs",
"tensorflow.compat.v2.compat.v1.test.get_temp_dir"
],
[
"tensorflow.compat.v2.config.set_soft_device_placement",
"numpy.array",
"tensorflow.compat.v2.__internal__.distribute.multi_process_runner.test_main",
"tensorflow.compat.v2.__internal__.test.combinations.combine"
],
[
"tensorflow.compat.v2.test.main",
"tensorflow.compat.v2.as_dtype",
"tensorflow.compat.v2.RaggedTensor.from_row_splits",
"tensorflow.python.framework.type_spec.register",
"tensorflow.compat.v2.cast",
"tensorflow.compat.v2.convert_to_tensor",
"tensorflow.compat.v2.ones",
"tensorflow.compat.v2.zeros",
"tensorflow.compat.v2.TensorShape",
"tensorflow.python.framework.type_spec.register_type_spec_from_value_converter",
"tensorflow.compat.v2.TensorSpec"
],
[
"tensorflow.python.util.tf_export.keras_export"
],
[
"tensorflow.python.util.tf_export.keras_export"
],
[
"tensorflow.compat.v2.keras.utils.experimental.DatasetCreator",
"tensorflow.compat.v2.__internal__.tf2.enabled"
],
[
"numpy.issubdtype",
"numpy.array"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
haribharadwaj/statsmodels | [
"8675b890607fe6f116b1186dcba4c387c5e3778a",
"8675b890607fe6f116b1186dcba4c387c5e3778a",
"8675b890607fe6f116b1186dcba4c387c5e3778a",
"8675b890607fe6f116b1186dcba4c387c5e3778a",
"844381797a475a01c05a4e162592a5a6e3a48032",
"8675b890607fe6f116b1186dcba4c387c5e3778a"
] | [
"statsmodels/regression/feasible_gls.py",
"statsmodels/graphics/tests/test_tsaplots.py",
"statsmodels/sandbox/tests/test_predict_functional.py",
"examples/incomplete/dates.py",
"statsmodels/tsa/statespace/tests/test_impulse_responses.py",
"statsmodels/tsa/vector_ar/svar_model.py"
] | [
"# -*- coding: utf-8 -*-\n\"\"\"\n\nCreated on Tue Dec 20 20:24:20 2011\n\nAuthor: Josef Perktold\nLicense: BSD-3\n\n\"\"\"\n\nfrom statsmodels.compat.python import range\nimport numpy as np\nimport statsmodels.base.model as base\nfrom statsmodels.regression.linear_model import OLS, GLS, WLS, RegressionResults\n\n\ndef atleast_2dcols(x):\n x = np.asarray(x)\n if x.ndim == 1:\n x = x[:,None]\n return x\n\n\nclass GLSHet2(GLS):\n '''WLS with heteroscedasticity that depends on explanatory variables\n\n note: mixing GLS sigma and weights for heteroscedasticity might not make\n sense\n\n I think rewriting following the pattern of GLSAR is better\n stopping criteria: improve in GLSAR also, e.g. change in rho\n\n '''\n\n\n def __init__(self, endog, exog, exog_var, sigma=None):\n self.exog_var = atleast_2dcols(exog_var)\n super(self.__class__, self).__init__(endog, exog, sigma=sigma)\n\n\n def fit(self, lambd=1.):\n #maybe iterate\n #preliminary estimate\n res_gls = GLS(self.endog, self.exog, sigma=self.sigma).fit()\n res_resid = OLS(res_gls.resid**2, self.exog_var).fit()\n #or log-link\n #res_resid = OLS(np.log(res_gls.resid**2), self.exog_var).fit()\n #here I could use whiten and current instance instead of delegating\n #but this is easier\n #see pattern of GLSAR, calls self.initialize and self.fit\n res_wls = WLS(self.endog, self.exog, weights=1./res_resid.fittedvalues).fit()\n\n res_wls._results.results_residual_regression = res_resid\n return res_wls\n\n\nclass GLSHet(WLS):\n \"\"\"\n A regression model with an estimated heteroscedasticity.\n\n A subclass of WLS, that additionally estimates the weight matrix as a\n function of additional explanatory variables.\n\n Parameters\n ----------\n endog : array_like\n exog : array_like\n exog_var : array_like, 1d or 2d\n regressors, explanatory variables for the variance\n weights : array_like or None\n If weights are given, then they are used in the first step estimation.\n link : link function or None\n If None, then the variance is assumed to be a linear combination of\n the exog_var. If given, then ... not tested yet\n\n *extra attributes*\n\n history : dict\n contains the parameter estimates in both regression for each iteration\n\n result instance has\n\n results_residual_regression : OLS result instance\n result of heteroscedasticity estimation\n\n except for fit_iterative all methods are inherited from WLS.\n\n Notes\n -----\n GLSHet is considered to be experimental.\n\n `fit` is just standard WLS fit for fixed weights\n `fit_iterative` updates the estimate for weights, see its docstring\n\n The two alternative for handling heteroscedasticity in the data are to\n use heteroscedasticity robust standard errors or estimating the\n heteroscedasticity\n Estimating heteroscedasticity and using weighted least squares produces\n smaller confidence intervals for the estimated parameters then the\n heteroscedasticity robust standard errors if the heteroscedasticity is\n correctly specified. If the heteroscedasticity is incorrectly specified\n then the estimated covariance is inconsistent.\n\n Stock and Watson for example argue in favor of using OLS with\n heteroscedasticity robust standard errors instead of GLSHet sind we are\n seldom sure enough about the correct specification (in economics).\n\n GLSHet has asymptotically the same distribution as WLS if the true\n weights are know. In both cases the asymptotic distribution of the\n parameter estimates is the normal distribution.\n\n The assumption of the model:\n\n y = X*beta + u,\n with E(u) = 0, E(X*u)=0, var(u_i) = z_i*gamma\n or for vector of all observations Sigma = diag(Z*gamma)\n\n where\n y : endog (nobs)\n X : exog (nobs, k_vars)\n Z : exog_var (nobs, k_vars2)\n beta, gamma estimated parameters\n\n If a link is specified, then the heteroscedasticity is\n\n var(u_i) = link.inverse(z_i*gamma), or\n link(var(u_i)) = z_i*gamma\n\n for example for log-linkg\n var(u_i) = exp(z_i*gamma)\n\n\n Usage : see example ....\n\n TODO: test link option\n\n \"\"\"\n def __init__(self, endog, exog, exog_var=None, weights=None, link=None):\n self.exog_var = atleast_2dcols(exog_var)\n if weights is None:\n weights = np.ones(endog.shape)\n if link is not None:\n self.link = link\n self.linkinv = link.inverse #as defined in families.links\n else:\n self.link = lambda x: x #no transformation\n self.linkinv = lambda x: x\n\n super(self.__class__, self).__init__(endog, exog, weights=weights)\n\n def iterative_fit(self, maxiter=3):\n \"\"\"\n Perform an iterative two-step procedure to estimate a WLS model.\n\n The model is assumed to have heteroscedastic errors.\n The variance is estimated by OLS regression of the link transformed\n squared residuals on Z, i.e.::\n\n link(sigma_i) = x_i*gamma.\n\n Parameters\n ----------\n maxiter : integer, optional\n the number of iterations\n\n Notes\n -----\n maxiter=1: returns the estimated based on given weights\n maxiter=2: performs a second estimation with the updated weights,\n this is 2-step estimation\n maxiter>2: iteratively estimate and update the weights\n\n TODO: possible extension stop iteration if change in parameter\n estimates is smaller than x_tol\n\n Repeated calls to fit_iterative, will do one redundant pinv_wexog\n calculation. Calling fit_iterative(maxiter) ones does not do any\n redundant recalculations (whitening or calculating pinv_wexog).\n\n \"\"\"\n\n import collections\n self.history = collections.defaultdict(list) #not really necessary\n res_resid = None #if maxiter < 2 no updating\n for i in range(maxiter):\n #pinv_wexog is cached\n if hasattr(self, 'pinv_wexog'):\n del self.pinv_wexog\n #self.initialize()\n #print 'wls self',\n results = self.fit()\n self.history['self_params'].append(results.params)\n if not i == maxiter-1: #skip for last iteration, could break instead\n #print 'ols',\n self.results_old = results #for debugging\n #estimate heteroscedasticity\n res_resid = OLS(self.link(results.resid**2), self.exog_var).fit()\n self.history['ols_params'].append(res_resid.params)\n #update weights\n self.weights = 1./self.linkinv(res_resid.fittedvalues)\n self.weights /= self.weights.max() #not required\n self.weights[self.weights < 1e-14] = 1e-14 #clip\n #print 'in iter', i, self.weights.var() #debug, do weights change\n self.initialize()\n\n #note results is the wrapper, results._results is the results instance\n results._results.results_residual_regression = res_resid\n return results\n",
"from statsmodels.compat.python import lmap, BytesIO\n\nfrom distutils.version import LooseVersion\n\nimport numpy as np\nimport pandas as pd\nfrom numpy.testing import assert_equal, assert_\nimport pytest\n\nimport statsmodels.api as sm\nfrom statsmodels.graphics.tsaplots import (plot_acf, plot_pacf, month_plot,\n quarter_plot, seasonal_plot)\nimport statsmodels.tsa.arima_process as tsp\n\n\ntry:\n import matplotlib.pyplot as plt\n have_matplotlib = True\nexcept:\n have_matplotlib = False\n\npandas_lt_0_19_2 = LooseVersion(pd.__version__) < '0.19.1'\n\n\n\[email protected](not have_matplotlib, reason='matplotlib not available')\ndef test_plot_acf(close_figures):\n # Just test that it runs.\n fig = plt.figure()\n ax = fig.add_subplot(111)\n\n ar = np.r_[1., -0.9]\n ma = np.r_[1., 0.9]\n armaprocess = tsp.ArmaProcess(ar, ma)\n rs = np.random.RandomState(1234)\n acf = armaprocess.generate_sample(100, distrvs=rs.standard_normal)\n plot_acf(acf, ax=ax, lags=10)\n plot_acf(acf, ax=ax)\n plot_acf(acf, ax=ax, alpha=None)\n\n\[email protected](not have_matplotlib, reason='matplotlib not available')\ndef test_plot_acf_irregular(close_figures):\n # Just test that it runs.\n fig = plt.figure()\n ax = fig.add_subplot(111)\n\n ar = np.r_[1., -0.9]\n ma = np.r_[1., 0.9]\n armaprocess = tsp.ArmaProcess(ar, ma)\n rs = np.random.RandomState(1234)\n acf = armaprocess.generate_sample(100, distrvs=rs.standard_normal)\n plot_acf(acf, ax=ax, lags=np.arange(1, 11))\n plot_acf(acf, ax=ax, lags=10, zero=False)\n plot_acf(acf, ax=ax, alpha=None, zero=False)\n\n\[email protected](not have_matplotlib, reason='matplotlib not available')\ndef test_plot_pacf(close_figures):\n # Just test that it runs.\n fig = plt.figure()\n ax = fig.add_subplot(111)\n\n ar = np.r_[1., -0.9]\n ma = np.r_[1., 0.9]\n armaprocess = tsp.ArmaProcess(ar, ma)\n rs = np.random.RandomState(1234)\n pacf = armaprocess.generate_sample(100, distrvs=rs.standard_normal)\n plot_pacf(pacf, ax=ax)\n plot_pacf(pacf, ax=ax, alpha=None)\n\n\[email protected](not have_matplotlib, reason='matplotlib not available')\ndef test_plot_pacf_kwargs(close_figures):\n # Just test that it runs.\n fig = plt.figure()\n ax = fig.add_subplot(111)\n\n ar = np.r_[1., -0.9]\n ma = np.r_[1., 0.9]\n armaprocess = tsp.ArmaProcess(ar, ma)\n rs = np.random.RandomState(1234)\n pacf = armaprocess.generate_sample(100, distrvs=rs.standard_normal)\n\n buff = BytesIO()\n plot_pacf(pacf, ax=ax)\n fig.savefig(buff, format='rgba')\n\n buff_linestyle = BytesIO()\n fig_linestyle = plt.figure()\n ax = fig_linestyle.add_subplot(111)\n plot_pacf(pacf, ax=ax, ls='-')\n fig_linestyle.savefig(buff_linestyle, format='rgba')\n\n buff_with_vlines = BytesIO()\n fig_with_vlines = plt.figure()\n ax = fig_with_vlines.add_subplot(111)\n vlines_kwargs = {'linestyles': 'dashdot'}\n plot_pacf(pacf, ax=ax, vlines_kwargs=vlines_kwargs)\n fig_with_vlines.savefig(buff_with_vlines, format='rgba')\n\n buff.seek(0)\n buff_linestyle.seek(0)\n buff_with_vlines.seek(0)\n plain = buff.read()\n linestyle = buff_linestyle.read()\n with_vlines = buff_with_vlines.read()\n\n assert_(plain != linestyle)\n assert_(with_vlines != plain)\n assert_(linestyle != with_vlines)\n\n\[email protected](not have_matplotlib, reason='matplotlib not available')\ndef test_plot_acf_kwargs(close_figures):\n # Just test that it runs.\n fig = plt.figure()\n ax = fig.add_subplot(111)\n\n ar = np.r_[1., -0.9]\n ma = np.r_[1., 0.9]\n armaprocess = tsp.ArmaProcess(ar, ma)\n rs = np.random.RandomState(1234)\n acf = armaprocess.generate_sample(100, distrvs=rs.standard_normal)\n\n buff = BytesIO()\n plot_acf(acf, ax=ax)\n fig.savefig(buff, format='rgba')\n\n buff_with_vlines = BytesIO()\n fig_with_vlines = plt.figure()\n ax = fig_with_vlines.add_subplot(111)\n vlines_kwargs = {'linestyles': 'dashdot'}\n plot_acf(acf, ax=ax, vlines_kwargs=vlines_kwargs)\n fig_with_vlines.savefig(buff_with_vlines, format='rgba')\n\n buff.seek(0)\n buff_with_vlines.seek(0)\n plain = buff.read()\n with_vlines = buff_with_vlines.read()\n\n assert_(with_vlines != plain)\n\n\[email protected](not have_matplotlib, reason='matplotlib not available')\ndef test_plot_pacf_irregular(close_figures):\n # Just test that it runs.\n fig = plt.figure()\n ax = fig.add_subplot(111)\n\n ar = np.r_[1., -0.9]\n ma = np.r_[1., 0.9]\n armaprocess = tsp.ArmaProcess(ar, ma)\n rs = np.random.RandomState(1234)\n pacf = armaprocess.generate_sample(100, distrvs=rs.standard_normal)\n plot_pacf(pacf, ax=ax, lags=np.arange(1, 11))\n plot_pacf(pacf, ax=ax, lags=10, zero=False)\n plot_pacf(pacf, ax=ax, alpha=None, zero=False)\n\n\[email protected](not have_matplotlib or pandas_lt_0_19_2,\n reason='matplotlib not available or pandas too old')\ndef test_plot_month(close_figures):\n dta = sm.datasets.elnino.load_pandas().data\n dta['YEAR'] = dta.YEAR.astype(int).apply(str)\n dta = dta.set_index('YEAR').T.unstack()\n dates = pd.to_datetime(['-'.join([x[1], x[0]]) for x in dta.index.values])\n\n # test dates argument\n fig = month_plot(dta.values, dates=dates, ylabel='el nino')\n\n # test with a TimeSeries DatetimeIndex with no freq\n dta.index = pd.DatetimeIndex(dates)\n fig = month_plot(dta)\n\n # w freq\n dta.index = pd.DatetimeIndex(dates, freq='MS')\n fig = month_plot(dta)\n\n # test with a TimeSeries PeriodIndex\n dta.index = pd.PeriodIndex(dates, freq='M')\n fig = month_plot(dta)\n\n\[email protected](not have_matplotlib or pandas_lt_0_19_2,\n reason='matplotlib not available or pandas too old')\ndef test_plot_quarter(close_figures):\n dta = sm.datasets.macrodata.load_pandas().data\n dates = lmap('Q'.join, zip(dta.year.astype(int).apply(str),\n dta.quarter.astype(int).apply(str)))\n # test dates argument\n quarter_plot(dta.unemp.values, dates)\n\n # test with a DatetimeIndex with no freq\n dta.set_index(pd.to_datetime(dates), inplace=True)\n quarter_plot(dta.unemp)\n\n # w freq\n # see pandas #6631\n dta.index = pd.DatetimeIndex(pd.to_datetime(dates), freq='QS-Oct')\n quarter_plot(dta.unemp)\n\n # w PeriodIndex\n dta.index = pd.PeriodIndex(pd.to_datetime(dates), freq='Q')\n quarter_plot(dta.unemp)\n\n\[email protected](not have_matplotlib, reason='matplotlib not available')\ndef test_seasonal_plot(close_figures):\n rs = np.random.RandomState(1234)\n data = rs.randn(20,12)\n data += 6*np.sin(np.arange(12.0)/11*np.pi)[None,:]\n data = data.ravel()\n months = np.tile(np.arange(1,13),(20,1))\n months = months.ravel()\n df = pd.DataFrame([data,months],index=['data','months']).T\n grouped = df.groupby('months')['data']\n labels = ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec']\n fig = seasonal_plot(grouped, labels)\n ax = fig.get_axes()[0]\n output = [tl.get_text() for tl in ax.get_xticklabels()]\n assert_equal(labels, output)\n",
"from statsmodels.sandbox.predict_functional import predict_functional\nimport numpy as np\nimport pandas as pd\nimport pytest\nimport statsmodels.api as sm\nfrom numpy.testing import dec\n\n# If true, the output is written to a multi-page pdf file.\npdf_output = False\n\ntry:\n import matplotlib.pyplot as plt\n import matplotlib\n have_matplotlib = True\nexcept ImportError:\n have_matplotlib = False\n\ndef pctl(q):\n return lambda x : np.percentile(x, 100 *q)\n\n\nclass TestPredFunc(object):\n\n @classmethod\n def setup_class(cls):\n if pdf_output:\n from matplotlib.backends.backend_pdf import PdfPages\n cls.pdf = PdfPages(\"predict_functional.pdf\")\n\n @classmethod\n def teardown_class(cls):\n if pdf_output:\n cls.pdf.close()\n\n def close_or_save(self, fig):\n if pdf_output:\n self.pdf.savefig(fig)\n\n @pytest.mark.skipif(not have_matplotlib, reason='matplotlib not available')\n def test_formula(self, close_figures):\n\n np.random.seed(542)\n n = 500\n x1 = np.random.normal(size=n)\n x2 = np.random.normal(size=n)\n x3 = np.random.normal(size=n)\n x4 = np.random.randint(0, 5, size=n)\n x4 = np.asarray([\"ABCDE\"[i] for i in x4])\n x5 = np.random.normal(size=n)\n y = 0.3*x2**2 + (x4 == \"B\") + 0.1*(x4 == \"B\")*x2**2 + x5 + np.random.normal(size=n)\n\n df = pd.DataFrame({\"y\": y, \"x1\": x1, \"x2\": x2, \"x3\": x3, \"x4\": x4, \"x5\": x5})\n\n fml = \"y ~ x1 + bs(x2, df=4) + x3 + x2*x3 + I(x1**2) + C(x4) + C(x4)*bs(x2, df=4) + x5\"\n model = sm.OLS.from_formula(fml, data=df)\n result = model.fit()\n\n summaries = {\"x1\": np.mean, \"x3\": pctl(0.75), \"x5\": np.mean}\n\n values = {\"x4\": \"B\"}\n pr1, ci1, fvals1 = predict_functional(result, \"x2\", summaries, values)\n\n values = {\"x4\": \"C\"}\n pr2, ci2, fvals2 = predict_functional(result, \"x2\", summaries, values)\n\n plt.clf()\n fig = plt.figure()\n ax = plt.axes([0.1, 0.1, 0.7, 0.8])\n plt.plot(fvals1, pr1, '-', label='x4=B')\n plt.plot(fvals2, pr2, '-', label='x4=C')\n ha, lb = ax.get_legend_handles_labels()\n plt.figlegend(ha, lb, \"center right\")\n plt.xlabel(\"Focus variable\", size=15)\n plt.ylabel(\"Fitted mean\", size=15)\n plt.title(\"Linear model prediction\")\n self.close_or_save(fig)\n\n plt.clf()\n fig = plt.figure()\n ax = plt.axes([0.1, 0.1, 0.7, 0.8])\n plt.plot(fvals1, pr1, '-', label='x4=B')\n plt.fill_between(fvals1, ci1[:, 0], ci1[:, 1], color='grey')\n plt.plot(fvals2, pr2, '-', label='x4=C')\n plt.fill_between(fvals2, ci2[:, 0], ci2[:, 1], color='grey')\n ha, lb = ax.get_legend_handles_labels()\n plt.figlegend(ha, lb, \"center right\")\n plt.xlabel(\"Focus variable\", size=15)\n plt.ylabel(\"Fitted mean\", size=15)\n plt.title(\"Linear model prediction\")\n self.close_or_save(fig)\n\n @pytest.mark.skipif(not have_matplotlib, reason='matplotlib not available')\n def test_lm_contrast(self, close_figures):\n\n np.random.seed(542)\n n = 200\n x1 = np.random.normal(size=n)\n x2 = np.random.normal(size=n)\n x3 = np.random.normal(size=n)\n y = x1 + 2*x2 + x3 - x1*x2 + x2*x3 + np.random.normal(size=n)\n\n df = pd.DataFrame({\"y\": y, \"x1\": x1, \"x2\": x2, \"x3\": x3})\n\n fml = \"y ~ x1 + x2 + x3 + x1*x2 + x2*x3\"\n model = sm.OLS.from_formula(fml, data=df)\n result = model.fit()\n\n values = {\"x2\": 1, \"x3\": 1} # y = 4\n values2 = {\"x2\": 0, \"x3\": 0} # y = x1\n pr, cb, fvals = predict_functional(result, \"x1\", values=values,\n values2=values2, ci_method='scheffe')\n\n plt.clf()\n fig = plt.figure()\n ax = plt.axes([0.1, 0.1, 0.67, 0.8])\n plt.plot(fvals, pr, '-', label=\"Estimate\", color='orange', lw=4)\n plt.plot(fvals, 4 - fvals, '-', label=\"Truth\", color='lime', lw=4)\n plt.fill_between(fvals, cb[:, 0], cb[:, 1], color='grey')\n ha, lb = ax.get_legend_handles_labels()\n leg = plt.figlegend(ha, lb, \"center right\")\n leg.draw_frame(False)\n plt.xlabel(\"Focus variable\", size=15)\n plt.ylabel(\"Mean contrast\", size=15)\n plt.title(\"Linear model contrast\")\n self.close_or_save(fig)\n\n @pytest.mark.skipif(not have_matplotlib, reason='matplotlib not available')\n def test_glm_formula_contrast(self, close_figures):\n\n np.random.seed(542)\n n = 50\n x1 = np.random.normal(size=n)\n x2 = np.random.normal(size=n)\n x3 = np.random.normal(size=n)\n mn = 5 + 0.1*x1 + 0.1*x2 + 0.1*x3 - 0.1*x1*x2\n y = np.random.poisson(np.exp(mn), size=len(mn))\n\n df = pd.DataFrame({\"y\": y, \"x1\": x1, \"x2\": x2, \"x3\": x3})\n\n fml = \"y ~ x1 + x2 + x3 + x1*x2\"\n model = sm.GLM.from_formula(fml, data=df, family=sm.families.Poisson())\n result = model.fit()\n\n values = {\"x2\": 1, \"x3\": 1} # y = 5.2\n values2 = {\"x2\": 0, \"x3\": 0} # y = 5 + 0.1*x1\n pr, cb, fvals = predict_functional(result, \"x1\", values=values,\n values2=values2, ci_method='simultaneous')\n\n plt.clf()\n fig = plt.figure()\n ax = plt.axes([0.1, 0.1, 0.67, 0.8])\n plt.plot(fvals, pr, '-', label=\"Estimate\", color='orange', lw=4)\n plt.plot(fvals, 0.2 - 0.1*fvals, '-', label=\"Truth\", color='lime', lw=4)\n plt.fill_between(fvals, cb[:, 0], cb[:, 1], color='grey')\n ha, lb = ax.get_legend_handles_labels()\n leg = plt.figlegend(ha, lb, \"center right\")\n leg.draw_frame(False)\n plt.xlabel(\"Focus variable\", size=15)\n plt.ylabel(\"Linear predictor contrast\", size=15)\n plt.title(\"Poisson regression contrast\")\n self.close_or_save(fig)\n\n @pytest.mark.skipif(not have_matplotlib, reason='matplotlib not available')\n def test_scb(self, close_figures):\n\n np.random.seed(473)\n n = 100\n x = np.random.normal(size=(n,4))\n x[:, 0] = 1\n\n for fam_name in \"poisson\", \"binomial\", \"gaussian\":\n\n if fam_name == \"poisson\":\n y = np.random.poisson(20, size=n)\n fam = sm.families.Poisson()\n true_mean = 20\n true_lp = np.log(20)\n elif fam_name == \"binomial\":\n y = 1 * (np.random.uniform(size=n) < 0.5)\n fam = sm.families.Binomial()\n true_mean = 0.5\n true_lp = 0\n elif fam_name == \"gaussian\":\n y = np.random.normal(size=n)\n fam = sm.families.Gaussian()\n true_mean = 0\n true_lp = 0\n\n model = sm.GLM(y, x, family=fam)\n result = model.fit()\n\n # CB is for linear predictor or mean response\n for linear in False, True:\n\n true = true_lp if linear else true_mean\n\n values = {'const': 1, \"x2\": 0}\n summaries = {\"x3\": np.mean}\n pred1, cb1, fvals1 = predict_functional(result, \"x1\",\n values=values, summaries=summaries, linear=linear)\n pred2, cb2, fvals2 = predict_functional(result, \"x1\",\n values=values, summaries=summaries,\n ci_method='simultaneous', linear=linear)\n\n plt.clf()\n fig = plt.figure()\n ax = plt.axes([0.1, 0.1, 0.58, 0.8])\n plt.plot(fvals1, pred1, '-', color='black', label='Estimate')\n plt.plot(fvals1, true * np.ones(len(pred1)), '-', color='purple',\n label='Truth')\n plt.plot(fvals1, cb1[:, 0], color='blue', label='Pointwise CB')\n plt.plot(fvals1, cb1[:, 1], color='blue')\n plt.plot(fvals2, cb2[:, 0], color='green', label='Simultaneous CB')\n plt.plot(fvals2, cb2[:, 1], color='green')\n ha, lb = ax.get_legend_handles_labels()\n leg = plt.figlegend(ha, lb, \"center right\")\n leg.draw_frame(False)\n plt.xlabel(\"Focus variable\", size=15)\n if linear:\n plt.ylabel(\"Linear predictor\", size=15)\n else:\n plt.ylabel(\"Fitted mean\", size=15)\n plt.title(\"%s family prediction\" % fam_name.capitalize())\n\n self.close_or_save(fig)\n\n\n @pytest.mark.skipif(not have_matplotlib, reason='matplotlib not available')\n def test_glm_formula(self, close_figures):\n\n np.random.seed(542)\n n = 500\n x1 = np.random.normal(size=n)\n x2 = np.random.normal(size=n)\n x3 = np.random.randint(0, 3, size=n)\n x3 = np.asarray([\"ABC\"[i] for i in x3])\n lin_pred = -1 + 0.5*x1**2 + (x3 == \"B\")\n prob = 1 / (1 + np.exp(-lin_pred))\n y = 1 * (np.random.uniform(size=n) < prob)\n\n df = pd.DataFrame({\"y\": y, \"x1\": x1, \"x2\": x2, \"x3\": x3})\n\n fml = \"y ~ x1 + I(x1**2) + x2 + C(x3)\"\n model = sm.GLM.from_formula(fml, family=sm.families.Binomial(), data=df)\n result = model.fit()\n summaries = {\"x2\": np.mean}\n\n for linear in False, True:\n\n values = {\"x3\": \"B\"}\n pr1, ci1, fvals1 = predict_functional(result, \"x1\", summaries, values, linear=linear)\n\n values = {\"x3\": \"C\"}\n pr2, ci2, fvals2 = predict_functional(result, \"x1\", summaries, values, linear=linear)\n\n exact1 = -1 + 0.5*fvals1**2 + 1\n exact2 = -1 + 0.5*fvals2**2\n\n if not linear:\n exact1 = 1 / (1 + np.exp(-exact1))\n exact2 = 1 / (1 + np.exp(-exact2))\n\n plt.clf()\n fig = plt.figure()\n ax = plt.axes([0.1, 0.1, 0.7, 0.8])\n plt.plot(fvals1, pr1, '-', label='x3=B')\n plt.plot(fvals2, pr2, '-', label='x3=C')\n plt.plot(fvals1, exact1, '-', label='x3=B (exact)')\n plt.plot(fvals2, exact2, '-', label='x3=C (exact)')\n ha, lb = ax.get_legend_handles_labels()\n plt.figlegend(ha, lb, \"center right\")\n plt.xlabel(\"Focus variable\", size=15)\n if linear:\n plt.ylabel(\"Fitted linear predictor\", size=15)\n else:\n plt.ylabel(\"Fitted probability\", size=15)\n plt.title(\"Binomial GLM prediction\")\n self.close_or_save(fig)\n\n plt.clf()\n fig = plt.figure()\n ax = plt.axes([0.1, 0.1, 0.7, 0.8])\n plt.plot(fvals1, pr1, '-', label='x3=B', color='orange')\n plt.fill_between(fvals1, ci1[:, 0], ci1[:, 1], color='grey')\n plt.plot(fvals2, pr2, '-', label='x3=C', color='lime')\n plt.fill_between(fvals2, ci2[:, 0], ci2[:, 1], color='grey')\n ha, lb = ax.get_legend_handles_labels()\n plt.figlegend(ha, lb, \"center right\")\n plt.xlabel(\"Focus variable\", size=15)\n if linear:\n plt.ylabel(\"Fitted linear predictor\", size=15)\n else:\n plt.ylabel(\"Fitted probability\", size=15)\n plt.title(\"Binomial GLM prediction\")\n self.close_or_save(fig)\n\n @pytest.mark.skipif(not have_matplotlib, reason='matplotlib not available')\n def test_noformula_prediction(self, close_figures):\n\n np.random.seed(6434)\n n = 200\n x1 = np.random.normal(size=n)\n x2 = np.random.normal(size=n)\n x3 = np.random.normal(size=n)\n y = x1 - x2 + np.random.normal(size=n)\n\n exog = np.vstack((x1, x2, x3)).T\n\n model = sm.OLS(y, exog)\n result = model.fit()\n\n summaries = {\"x3\": pctl(0.75)}\n values = {\"x2\": 1}\n pr1, ci1, fvals1 = predict_functional(result, \"x1\", summaries, values)\n\n values = {\"x2\": -1}\n pr2, ci2, fvals2 = predict_functional(result, \"x1\", summaries, values)\n\n plt.clf()\n fig = plt.figure()\n ax = plt.axes([0.1, 0.1, 0.7, 0.8])\n plt.plot(fvals1, pr1, '-', label='x2=1', lw=4, alpha=0.6, color='orange')\n plt.plot(fvals2, pr2, '-', label='x2=-1', lw=4, alpha=0.6, color='lime')\n ha, lb = ax.get_legend_handles_labels()\n leg = plt.figlegend(ha, lb, \"center right\")\n leg.draw_frame(False)\n plt.xlabel(\"Focus variable\", size=15)\n plt.ylabel(\"Fitted mean\", size=15)\n plt.title(\"Linear model prediction\")\n self.close_or_save(fig)\n\n plt.clf()\n fig = plt.figure()\n ax = plt.axes([0.1, 0.1, 0.7, 0.8])\n plt.plot(fvals1, pr1, '-', label='x2=1', lw=4, alpha=0.6, color='orange')\n plt.fill_between(fvals1, ci1[:, 0], ci1[:, 1], color='grey')\n plt.plot(fvals1, pr2, '-', label='x2=1', lw=4, alpha=0.6, color='lime')\n plt.fill_between(fvals2, ci2[:, 0], ci2[:, 1], color='grey')\n ha, lb = ax.get_legend_handles_labels()\n plt.figlegend(ha, lb, \"center right\")\n plt.xlabel(\"Focus variable\", size=15)\n plt.ylabel(\"Fitted mean\", size=15)\n plt.title(\"Linear model prediction\")\n self.close_or_save(fig)\n",
"\"\"\"\nUsing dates with timeseries models\n\"\"\"\nimport statsmodels.api as sm\nimport pandas as pd\n\n# Getting started\n# ---------------\n\ndata = sm.datasets.sunspots.load()\n\n# Right now an annual date series must be datetimes at the end of the year.\n\ndates = sm.tsa.datetools.dates_from_range('1700', length=len(data.endog))\n\n# Using Pandas\n# ------------\n\n# Make a pandas Series or DataFrame with DatetimeIndex\nendog = pd.Series(data.endog, index=dates)\n\n# and instantiate the model\nar_model = sm.tsa.AR(endog, freq='A')\npandas_ar_res = ar_model.fit(maxlag=9, method='mle', disp=-1)\n\n# Let's do some out-of-sample prediction\npred = pandas_ar_res.predict(start='2005', end='2015')\nprint(pred)\n\n# Using explicit dates\n# --------------------\n\nar_model = sm.tsa.AR(data.endog, dates=dates, freq='A')\nar_res = ar_model.fit(maxlag=9, method='mle', disp=-1)\npred = ar_res.predict(start='2005', end='2015')\nprint(pred)\n\n# This just returns a regular array, but since the model has date information\n# attached, you can get the prediction dates in a roundabout way.\n\nprint(ar_res.data.predict_dates)\n\n# This attribute only exists if predict has been called. It holds the dates\n# associated with the last call to predict.\n#..TODO: should this be attached to the results instance?\n",
"\"\"\"\nTests for impulse responses of time series\n\nAuthor: Chad Fulton\nLicense: Simplified-BSD\n\"\"\"\n\nfrom __future__ import division, absolute_import, print_function\n\nimport warnings\nimport numpy as np\nimport pandas as pd\nimport os\nfrom scipy.signal import lfilter\n\nfrom statsmodels.tsa.statespace import (sarimax, structural, varmax,\n dynamic_factor)\nfrom numpy.testing import (assert_allclose, assert_almost_equal, assert_equal)\n\n\ndef test_sarimax():\n # AR(1)\n mod = sarimax.SARIMAX([0], order=(1, 0, 0))\n phi = 0.5\n actual = mod.impulse_responses([phi, 1], steps=10)\n desired = np.r_[[phi**i for i in range(11)]]\n assert_allclose(actual, desired)\n\n # MA(1)\n mod = sarimax.SARIMAX([0], order=(0, 0, 1))\n theta = 0.5\n actual = mod.impulse_responses([theta, 1], steps=10)\n desired = np.r_[1, theta, [0]*9]\n assert_allclose(actual, desired)\n\n # ARMA(2, 2) + constant\n # Stata:\n # webuse lutkepohl2\n # arima dln_inc, arima(2, 0, 2)\n # irf create irf1, set(irf1) step(10)\n # irf table irf\n params = [.01928228, -.03656216, .7588994,\n .27070341, -.72928328, .01122177**0.5]\n mod = sarimax.SARIMAX([0], order=(2, 0, 2), trend='c')\n actual = mod.impulse_responses(params, steps=10)\n desired = [1, .234141, .021055, .17692, .00951, .133917, .002321, .101544,\n -.001951, .077133, -.004301]\n assert_allclose(actual, desired, atol=1e-6)\n\n # SARIMAX(1,1,1)x(1,0,1,4) + constant + exog\n # Stata:\n # webuse lutkepohl2\n # gen exog = _n^2\n # arima inc exog, arima(1,1,1) sarima(1,0,1,4)\n # irf create irf2, set(irf2) step(10)\n # irf table irf\n params = [.12853289, 12.207156, .86384742, -.71463236,\n .81878967, -.9533955, 14.043884**0.5]\n exog = np.arange(1, 92)**2\n mod = sarimax.SARIMAX(np.zeros(91), order=(1, 1, 1),\n seasonal_order=(1, 0, 1, 4), trend='c', exog=exog,\n simple_differencing=True)\n actual = mod.impulse_responses(params, steps=10)\n desired = [1, .149215, .128899, .111349, -.038417, .063007, .054429,\n .047018, -.069598, .018641, .016103]\n assert_allclose(actual, desired, atol=1e-6)\n\n\ndef test_structural():\n steps = 10\n\n # AR(1)\n mod = structural.UnobservedComponents([0], autoregressive=1)\n phi = 0.5\n actual = mod.impulse_responses([1, phi], steps)\n desired = np.r_[[phi**i for i in range(steps + 1)]]\n assert_allclose(actual, desired)\n\n # ARX(1)\n # This is adequately tested in test_simulate.py, since in the time-varying\n # case `impulse_responses` just calls `simulate`\n\n # Irregular\n mod = structural.UnobservedComponents([0], 'irregular')\n actual = mod.impulse_responses([1.], steps)\n assert_allclose(actual, 0)\n\n # Fixed intercept\n # (in practice this is a deterministic constant, because an irregular\n # component must be added)\n with warnings.catch_warnings():\n warnings.simplefilter(\"ignore\")\n mod = structural.UnobservedComponents([0], 'fixed intercept')\n actual = mod.impulse_responses([1.], steps)\n assert_allclose(actual, 0)\n\n # Deterministic constant\n mod = structural.UnobservedComponents([0], 'deterministic constant')\n actual = mod.impulse_responses([1.], steps)\n assert_allclose(actual, 0)\n\n # Local level\n mod = structural.UnobservedComponents([0], 'local level')\n actual = mod.impulse_responses([1., 1.], steps)\n assert_allclose(actual, 1)\n\n # Random walk\n mod = structural.UnobservedComponents([0], 'random walk')\n actual = mod.impulse_responses([1.], steps)\n assert_allclose(actual, 1)\n\n # Fixed slope\n # (in practice this is a deterministic trend, because an irregular\n # component must be added)\n with warnings.catch_warnings():\n warnings.simplefilter(\"ignore\")\n mod = structural.UnobservedComponents([0], 'fixed slope')\n actual = mod.impulse_responses([1.], steps)\n assert_allclose(actual, 0)\n\n # Deterministic trend\n mod = structural.UnobservedComponents([0], 'deterministic trend')\n actual = mod.impulse_responses([1.], steps)\n assert_allclose(actual, 0)\n\n # Local linear deterministic trend\n mod = structural.UnobservedComponents(\n [0], 'local linear deterministic trend')\n actual = mod.impulse_responses([1., 1.], steps)\n assert_allclose(actual, 1)\n\n # Random walk with drift\n mod = structural.UnobservedComponents([0], 'random walk with drift')\n actual = mod.impulse_responses([1.], steps)\n assert_allclose(actual, 1)\n\n # Local linear trend\n mod = structural.UnobservedComponents([0], 'local linear trend')\n # - shock the level\n actual = mod.impulse_responses([1., 1., 1.], steps)\n assert_allclose(actual, 1)\n # - shock the trend\n actual = mod.impulse_responses([1., 1., 1.], steps, impulse=1)\n assert_allclose(actual, np.arange(steps + 1))\n\n # Smooth trend\n mod = structural.UnobservedComponents([0], 'smooth trend')\n actual = mod.impulse_responses([1., 1.], steps)\n assert_allclose(actual, np.arange(steps + 1))\n\n # Random trend\n mod = structural.UnobservedComponents([0], 'random trend')\n actual = mod.impulse_responses([1., 1.], steps)\n assert_allclose(actual, np.arange(steps + 1))\n\n # Seasonal (deterministic)\n mod = structural.UnobservedComponents([0], 'irregular', seasonal=2,\n stochastic_seasonal=False)\n actual = mod.impulse_responses([1.], steps)\n assert_allclose(actual, 0)\n\n # Seasonal (stochastic)\n mod = structural.UnobservedComponents([0], 'irregular', seasonal=2)\n actual = mod.impulse_responses([1., 1.], steps)\n desired = np.r_[1, np.tile([-1, 1], steps // 2)]\n assert_allclose(actual, desired)\n\n # Cycle (deterministic)\n mod = structural.UnobservedComponents([0], 'irregular', cycle=True)\n actual = mod.impulse_responses([1., 1.2], steps)\n assert_allclose(actual, 0)\n\n # Cycle (stochastic)\n mod = structural.UnobservedComponents([0], 'irregular', cycle=True,\n stochastic_cycle=True)\n actual = mod.impulse_responses([1., 1., 1.2], steps=10)\n x1 = [np.cos(1.2), np.sin(1.2)]\n x2 = [-np.sin(1.2), np.cos(1.2)]\n T = np.array([x1, x2])\n desired = np.zeros(steps + 1)\n states = [1, 0]\n for i in range(steps + 1):\n desired[i] += states[0]\n states = np.dot(T, states)\n assert_allclose(actual, desired)\n\n\ndef test_varmax():\n steps = 10\n\n # Clear warnings\n varmax.__warningregistry__ = {}\n\n # VAR(2) - single series\n mod1 = varmax.VARMAX([[0]], order=(2, 0), trend='nc')\n mod2 = sarimax.SARIMAX([0], order=(2, 0, 0))\n actual = mod1.impulse_responses([0.5, 0.2, 1], steps)\n desired = mod2.impulse_responses([0.5, 0.2, 1], steps)\n assert_allclose(actual, desired)\n\n # VMA(2) - single series\n mod1 = varmax.VARMAX([[0]], order=(0, 2), trend='nc')\n mod2 = sarimax.SARIMAX([0], order=(0, 0, 2))\n actual = mod1.impulse_responses([0.5, 0.2, 1], steps)\n desired = mod2.impulse_responses([0.5, 0.2, 1], steps)\n assert_allclose(actual, desired)\n\n # VARMA(2, 2) - single series\n with warnings.catch_warnings():\n warnings.simplefilter(\"ignore\")\n mod1 = varmax.VARMAX([[0]], order=(2, 2), trend='nc')\n mod2 = sarimax.SARIMAX([0], order=(2, 0, 2))\n actual = mod1.impulse_responses([0.5, 0.2, 0.1, -0.2, 1], steps)\n desired = mod2.impulse_responses([0.5, 0.2, 0.1, -0.2, 1], steps)\n assert_allclose(actual, desired)\n\n # VARMA(2, 2) + trend - single series\n mod1 = varmax.VARMAX([[0]], order=(2, 2), trend='c')\n mod2 = sarimax.SARIMAX([0], order=(2, 0, 2), trend='c')\n actual = mod1.impulse_responses([10, 0.5, 0.2, 0.1, -0.2, 1], steps)\n desired = mod2.impulse_responses([10, 0.5, 0.2, 0.1, -0.2, 1], steps)\n assert_allclose(actual, desired)\n\n # VAR(2) + constant\n # Stata:\n # webuse lutkepohl2\n # var dln_inv dln_inc, lags(1/2)\n # irf create irf3, set(irf3) step(10)\n # irf table irf\n # irf table oirf\n params = [-.00122728, .01503679,\n -.22741923, .71030531, -.11596357, .51494891,\n .05974659, .02094608, .05635125, .08332519,\n .04297918, .00159473, .01096298]\n irf_00 = [1, -.227419, -.021806, .093362, -.001875, -.00906, .009605,\n .001323, -.001041, .000769, .00032]\n irf_01 = [0, .059747, .044015, -.008218, .007845, .004629, .000104,\n .000451, .000638, .000063, .000042]\n irf_10 = [0, .710305, .36829, -.065697, .084398, .043038, .000533,\n .005755, .006051, .000548, .000526]\n irf_11 = [1, .020946, .126202, .066419, .028735, .007477, .009878,\n .003287, .001266, .000986, .0005]\n oirf_00 = [0.042979, -0.008642, -0.00035, 0.003908, 0.000054, -0.000321,\n 0.000414, 0.000066, -0.000035, 0.000034, 0.000015]\n oirf_01 = [0.001595, 0.002601, 0.002093, -0.000247, 0.000383, 0.000211,\n 0.00002, 0.000025, 0.000029, 4.30E-06, 2.60E-06]\n oirf_10 = [0, 0.007787, 0.004037, -0.00072, 0.000925, 0.000472, 5.80E-06,\n 0.000063, 0.000066, 6.00E-06, 5.80E-06]\n oirf_11 = [0.010963, 0.00023, 0.001384, 0.000728, 0.000315, 0.000082,\n 0.000108, 0.000036, 0.000014, 0.000011, 5.50E-06]\n\n mod = varmax.VARMAX([[0, 0]], order=(2, 0), trend='c')\n\n # IRFs\n actual = mod.impulse_responses(params, steps, impulse=0)\n assert_allclose(actual, np.c_[irf_00, irf_01], atol=1e-6)\n\n actual = mod.impulse_responses(params, steps, impulse=1)\n assert_allclose(actual, np.c_[irf_10, irf_11], atol=1e-6)\n\n # Orthogonalized IRFs\n actual = mod.impulse_responses(params, steps, impulse=0,\n orthogonalized=True)\n assert_allclose(actual, np.c_[oirf_00, oirf_01], atol=1e-6)\n\n actual = mod.impulse_responses(params, steps, impulse=1,\n orthogonalized=True)\n assert_allclose(actual, np.c_[oirf_10, oirf_11], atol=1e-6)\n\n # VARMA(2, 2) + trend + exog\n # TODO: This is just a smoke test\n with warnings.catch_warnings():\n warnings.simplefilter(\"ignore\")\n mod = varmax.VARMAX(\n np.random.normal(size=(steps, 2)), order=(2, 2), trend='c',\n exog=np.ones(steps), enforce_stationarity=False,\n enforce_invertibility=False)\n mod.impulse_responses(mod.start_params, steps)\n\n\ndef test_dynamic_factor():\n steps = 10\n exog = np.random.normal(size=steps)\n\n # DFM: 2 series, AR(2) factor\n mod1 = dynamic_factor.DynamicFactor([[0, 0]], k_factors=1, factor_order=2)\n mod2 = sarimax.SARIMAX([0], order=(2, 0, 0))\n actual = mod1.impulse_responses([-0.9, 0.8, 1., 1., 0.5, 0.2], steps)\n desired = mod2.impulse_responses([0.5, 0.2, 1], steps)\n assert_allclose(actual[:, 0], -0.9 * desired)\n assert_allclose(actual[:, 1], 0.8 * desired)\n\n # DFM: 2 series, AR(2) factor, exog\n mod1 = dynamic_factor.DynamicFactor(np.zeros((steps, 2)), k_factors=1,\n factor_order=2, exog=exog)\n mod2 = sarimax.SARIMAX([0], order=(2, 0, 0))\n actual = mod1.impulse_responses(\n [-0.9, 0.8, 5, -2, 1., 1., 0.5, 0.2], steps)\n desired = mod2.impulse_responses([0.5, 0.2, 1], steps)\n assert_allclose(actual[:, 0], -0.9 * desired)\n assert_allclose(actual[:, 1], 0.8 * desired)\n\n # DFM, 3 series, VAR(2) factor, exog, error VAR\n # TODO: This is just a smoke test\n mod = dynamic_factor.DynamicFactor(np.random.normal(size=(steps, 3)),\n k_factors=2, factor_order=2, exog=exog,\n error_order=2, error_var=True,\n enforce_stationarity=False)\n mod.impulse_responses(mod.start_params, steps)\n",
"# -*- coding: utf-8 -*-\n\"\"\"\nVector Autoregression (VAR) processes\n\nReferences\n----------\nLütkepohl (2005) New Introduction to Multiple Time Series Analysis\n\"\"\"\nfrom __future__ import print_function, division\nfrom statsmodels.compat.python import range\n\nimport numpy as np\nimport numpy.linalg as npl\nfrom numpy.linalg import slogdet\n\nfrom statsmodels.tools.numdiff import (approx_hess, approx_fprime)\nfrom statsmodels.tools.decorators import cache_readonly\nfrom statsmodels.tsa.vector_ar.irf import IRAnalysis\nfrom statsmodels.tsa.vector_ar.var_model import VARProcess, \\\n VARResults\n\nimport statsmodels.tsa.vector_ar.util as util\nimport statsmodels.tsa.base.tsa_model as tsbase\nfrom statsmodels.compat.numpy import np_matrix_rank\n\nmat = np.array\n\n\ndef svar_ckerr(svar_type, A, B):\n if A is None and (svar_type == 'A' or svar_type == 'AB'):\n raise ValueError('SVAR of type A or AB but A array not given.')\n if B is None and (svar_type == 'B' or svar_type == 'AB'):\n\n raise ValueError('SVAR of type B or AB but B array not given.')\n\n\nclass SVAR(tsbase.TimeSeriesModel):\n r\"\"\"\n Fit VAR and then estimate structural components of A and B, defined:\n\n .. math:: Ay_t = A_1 y_{t-1} + \\ldots + A_p y_{t-p} + B\\var(\\epsilon_t)\n\n Parameters\n ----------\n endog : array-like\n 1-d endogenous response variable. The independent variable.\n dates : array-like\n must match number of rows of endog\n svar_type : str\n \"A\" - estimate structural parameters of A matrix, B assumed = I\n \"B\" - estimate structural parameters of B matrix, A assumed = I\n \"AB\" - estimate structural parameters indicated in both A and B matrix\n A : array-like\n neqs x neqs with unknown parameters marked with 'E' for estimate\n B : array-like\n neqs x neqs with unknown parameters marked with 'E' for estimate\n\n References\n ----------\n Hamilton (1994) Time Series Analysis\n \"\"\"\n def __init__(self, endog, svar_type, dates=None,\n freq=None, A=None, B=None, missing='none'):\n super(SVAR, self).__init__(endog, None, dates, freq, missing=missing)\n #(self.endog, self.names,\n # self.dates) = data_util.interpret_data(endog, names, dates)\n\n self.y = self.endog #keep alias for now\n self.neqs = self.endog.shape[1]\n\n types = ['A', 'B', 'AB']\n if svar_type not in types:\n raise ValueError('SVAR type not recognized, must be in '\n + str(types))\n self.svar_type = svar_type\n\n svar_ckerr(svar_type, A, B)\n\n #initialize A, B as I if not given\n #Initialize SVAR masks\n if A is None:\n A = np.identity(self.neqs)\n self.A_mask = A_mask = np.zeros(A.shape, dtype=bool)\n else:\n A_mask = np.logical_or(A == 'E', A == 'e')\n self.A_mask = A_mask\n if B is None:\n B = np.identity(self.neqs)\n self.B_mask = B_mask = np.zeros(B.shape, dtype=bool)\n else:\n B_mask = np.logical_or(B == 'E', B == 'e')\n self.B_mask = B_mask\n\n # convert A and B to numeric\n #TODO: change this when masked support is better or with formula\n #integration\n Anum = np.zeros(A.shape, dtype=float)\n Anum[~A_mask] = A[~A_mask]\n Anum[A_mask] = np.nan\n self.A = Anum\n\n Bnum = np.zeros(B.shape, dtype=float)\n Bnum[~B_mask] = B[~B_mask]\n Bnum[B_mask] = np.nan\n self.B = Bnum\n\n #LikelihoodModel.__init__(self, endog)\n\n #super(SVAR, self).__init__(endog)\n\n def fit(self, A_guess=None, B_guess=None, maxlags=None, method='ols',\n ic=None, trend='c', verbose=False, s_method='mle',\n solver=\"bfgs\", override=False, maxiter=500, maxfun=500):\n \"\"\"\n Fit the SVAR model and solve for structural parameters\n\n Parameters\n ----------\n A_guess : array-like, optional\n A vector of starting values for all parameters to be estimated\n in A.\n B_guess : array-like, optional\n A vector of starting values for all parameters to be estimated\n in B.\n maxlags : int\n Maximum number of lags to check for order selection, defaults to\n 12 * (nobs/100.)**(1./4), see select_order function\n method : {'ols'}\n Estimation method to use\n ic : {'aic', 'fpe', 'hqic', 'bic', None}\n Information criterion to use for VAR order selection.\n aic : Akaike\n fpe : Final prediction error\n hqic : Hannan-Quinn\n bic : Bayesian a.k.a. Schwarz\n verbose : bool, default False\n Print order selection output to the screen\n trend, str {\"c\", \"ct\", \"ctt\", \"nc\"}\n \"c\" - add constant\n \"ct\" - constant and trend\n \"ctt\" - constant, linear and quadratic trend\n \"nc\" - co constant, no trend\n Note that these are prepended to the columns of the dataset.\n s_method : {'mle'}\n Estimation method for structural parameters\n solver : {'nm', 'newton', 'bfgs', 'cg', 'ncg', 'powell'}\n Solution method\n See statsmodels.base for details\n override : bool, default False\n If True, returns estimates of A and B without checking\n order or rank condition\n maxiter : int, default 500\n Number of iterations to perform in solution method\n maxfun : int\n Number of function evaluations to perform\n\n Notes\n -----\n Lütkepohl pp. 146-153\n Hamilton pp. 324-336\n\n Returns\n -------\n est : SVARResults\n \"\"\"\n lags = maxlags\n\n if ic is not None:\n selections = self.select_order(maxlags=maxlags, verbose=verbose)\n if ic not in selections:\n raise Exception(\"%s not recognized, must be among %s\"\n % (ic, sorted(selections)))\n lags = selections[ic]\n if verbose:\n print('Using %d based on %s criterion' % (lags, ic))\n else:\n if lags is None:\n lags = 1\n\n self.nobs = len(self.endog) - lags\n\n # initialize starting parameters\n start_params = self._get_init_params(A_guess, B_guess)\n\n return self._estimate_svar(start_params, lags, trend=trend,\n solver=solver, override=override,\n maxiter=maxiter, maxfun=maxfun)\n\n def _get_init_params(self, A_guess, B_guess):\n \"\"\"\n Returns either the given starting or .1 if none are given.\n \"\"\"\n\n var_type = self.svar_type.lower()\n\n n_masked_a = self.A_mask.sum()\n if var_type in ['ab', 'a']:\n if A_guess is None:\n A_guess = np.array([.1]*n_masked_a)\n else:\n if len(A_guess) != n_masked_a:\n msg = 'len(A_guess) = %s, there are %s parameters in A'\n raise ValueError(msg % (len(A_guess), n_masked_a))\n else:\n A_guess = []\n\n n_masked_b = self.B_mask.sum()\n if var_type in ['ab', 'b']:\n if B_guess is None:\n B_guess = np.array([.1]*n_masked_b)\n else:\n if len(B_guess) != n_masked_b:\n msg = 'len(B_guess) = %s, there are %s parameters in B'\n raise ValueError(msg % (len(B_guess), n_masked_b))\n else:\n B_guess = []\n\n return np.r_[A_guess, B_guess]\n\n def _estimate_svar(self, start_params, lags, maxiter, maxfun,\n trend='c', solver=\"nm\", override=False):\n \"\"\"\n lags : int\n trend : string or None\n As per above\n \"\"\"\n k_trend = util.get_trendorder(trend)\n y = self.endog\n z = util.get_var_endog(y, lags, trend=trend, has_constant='raise')\n y_sample = y[lags:]\n\n # Lutkepohl p75, about 5x faster than stated formula\n var_params = np.linalg.lstsq(z, y_sample, rcond=-1)[0]\n resid = y_sample - np.dot(z, var_params)\n\n # Unbiased estimate of covariance matrix $\\Sigma_u$ of the white noise\n # process $u$\n # equivalent definition\n # .. math:: \\frac{1}{T - Kp - 1} Y^\\prime (I_T - Z (Z^\\prime Z)^{-1}\n # Z^\\prime) Y\n # Ref: Lutkepohl p.75\n # df_resid right now is T - Kp - 1, which is a suggested correction\n\n avobs = len(y_sample)\n\n df_resid = avobs - (self.neqs * lags + k_trend)\n\n sse = np.dot(resid.T, resid)\n #TODO: should give users the option to use a dof correction or not\n omega = sse / df_resid\n self.sigma_u = omega\n\n A, B = self._solve_AB(start_params, override=override,\n solver=solver,\n maxiter=maxiter,\n maxfun=maxfun)\n A_mask = self.A_mask\n B_mask = self.B_mask\n\n return SVARResults(y, z, var_params, omega, lags,\n names=self.endog_names, trend=trend,\n dates=self.data.dates, model=self,\n A=A, B=B, A_mask=A_mask, B_mask=B_mask)\n\n def loglike(self, params):\n \"\"\"\n Loglikelihood for SVAR model\n\n Notes\n -----\n This method assumes that the autoregressive parameters are\n first estimated, then likelihood with structural parameters\n is estimated\n \"\"\"\n\n #TODO: this doesn't look robust if A or B is None\n A = self.A\n B = self.B\n A_mask = self.A_mask\n B_mask = self.B_mask\n A_len = len(A[A_mask])\n B_len = len(B[B_mask])\n\n if A is not None:\n A[A_mask] = params[:A_len]\n if B is not None:\n B[B_mask] = params[A_len:A_len+B_len]\n\n nobs = self.nobs\n neqs = self.neqs\n sigma_u = self.sigma_u\n\n W = np.dot(npl.inv(B),A)\n trc_in = np.dot(np.dot(W.T,W),sigma_u)\n sign, b_logdet = slogdet(B**2) #numpy 1.4 compat\n b_slogdet = sign * b_logdet\n\n likl = -nobs/2. * (neqs * np.log(2 * np.pi) - \\\n np.log(npl.det(A)**2) + b_slogdet + \\\n np.trace(trc_in))\n\n return likl\n\n def score(self, AB_mask):\n \"\"\"\n Return the gradient of the loglike at AB_mask.\n\n Parameters\n ----------\n AB_mask : unknown values of A and B matrix concatenated\n\n Notes\n -----\n Return numerical gradient\n \"\"\"\n loglike = self.loglike\n return approx_fprime(AB_mask, loglike, epsilon=1e-8)\n\n def hessian(self, AB_mask):\n \"\"\"\n Returns numerical hessian.\n \"\"\"\n loglike = self.loglike\n return approx_hess(AB_mask, loglike)\n\n def _solve_AB(self, start_params, maxiter, maxfun, override=False,\n solver='bfgs'):\n \"\"\"\n Solves for MLE estimate of structural parameters\n\n Parameters\n ----------\n\n override : bool, default False\n If True, returns estimates of A and B without checking\n order or rank condition\n solver : str or None, optional\n Solver to be used. The default is 'nm' (Nelder-Mead). Other\n choices are 'bfgs', 'newton' (Newton-Raphson), 'cg'\n conjugate, 'ncg' (non-conjugate gradient), and 'powell'.\n maxiter : int, optional\n The maximum number of iterations. Default is 500.\n maxfun : int, optional\n The maximum number of function evalutions.\n\n Returns\n -------\n A_solve, B_solve: ML solutions for A, B matrices\n\n \"\"\"\n #TODO: this could stand a refactor\n A_mask = self.A_mask\n B_mask = self.B_mask\n A = self.A\n B = self.B\n A_len = len(A[A_mask])\n\n A[A_mask] = start_params[:A_len]\n B[B_mask] = start_params[A_len:]\n\n if override == False:\n J = self._compute_J(A, B)\n self.check_order(J)\n self.check_rank(J)\n else: #TODO: change to a warning?\n print(\"Order/rank conditions have not been checked\")\n\n retvals = super(SVAR, self).fit(start_params=start_params,\n method=solver, maxiter=maxiter,\n maxfun=maxfun, ftol=1e-20, disp=0).params\n\n A[A_mask] = retvals[:A_len]\n B[B_mask] = retvals[A_len:]\n\n return A, B\n\n def _compute_J(self, A_solve, B_solve):\n\n #first compute appropriate duplication matrix\n # taken from Magnus and Neudecker (1980),\n #\"The Elimination Matrix: Some Lemmas and Applications\n # the creation of the D_n matrix follows MN (1980) directly,\n #while the rest follows Hamilton (1994)\n\n neqs = self.neqs\n sigma_u = self.sigma_u\n A_mask = self.A_mask\n B_mask = self.B_mask\n\n #first generate duplication matrix, see MN (1980) for notation\n\n D_nT = np.zeros([int((1.0 / 2) * (neqs) * (neqs + 1)), neqs**2])\n\n for j in range(neqs):\n i=j\n while j <= i < neqs:\n u=np.zeros([int((1.0/2)*neqs*(neqs+1)), 1])\n u[int(j * neqs + (i + 1) - (1.0 / 2) * (j + 1) * j - 1)] = 1\n Tij=np.zeros([neqs,neqs])\n Tij[i,j]=1\n Tij[j,i]=1\n D_nT=D_nT+np.dot(u,(Tij.ravel('F')[:,None]).T)\n i=i+1\n\n D_n=D_nT.T\n D_pl=npl.pinv(D_n)\n\n #generate S_B\n S_B = np.zeros((neqs**2, len(A_solve[A_mask])))\n S_D = np.zeros((neqs**2, len(B_solve[B_mask])))\n\n j = 0\n j_d = 0\n if len(A_solve[A_mask]) is not 0:\n A_vec = np.ravel(A_mask, order='F')\n for k in range(neqs**2):\n if A_vec[k] == True:\n S_B[k,j] = -1\n j += 1\n if len(B_solve[B_mask]) is not 0:\n B_vec = np.ravel(B_mask, order='F')\n for k in range(neqs**2):\n if B_vec[k] == True:\n S_D[k,j_d] = 1\n j_d +=1\n\n #now compute J\n invA = npl.inv(A_solve)\n J_p1i = np.dot(np.dot(D_pl, np.kron(sigma_u, invA)), S_B)\n J_p1 = -2.0 * J_p1i\n J_p2 = np.dot(np.dot(D_pl, np.kron(invA, invA)), S_D)\n\n J = np.append(J_p1, J_p2, axis=1)\n\n return J\n\n def check_order(self, J):\n if np.size(J, axis=0) < np.size(J, axis=1):\n raise ValueError(\"Order condition not met: \"\n \"solution may not be unique\")\n\n def check_rank(self, J):\n rank = np_matrix_rank(J)\n if rank < np.size(J, axis=1):\n raise ValueError(\"Rank condition not met: \"\n \"solution may not be unique.\")\n\n\nclass SVARProcess(VARProcess):\n \"\"\"\n Class represents a known SVAR(p) process\n\n Parameters\n ----------\n coefs : ndarray (p x k x k)\n intercept : ndarray (length k)\n sigma_u : ndarray (k x k)\n names : sequence (length k)\n A : neqs x neqs np.ndarray with unknown parameters marked with 'E'\n A_mask : neqs x neqs mask array with known parameters masked\n B : neqs x neqs np.ndarry with unknown parameters marked with 'E'\n B_mask : neqs x neqs mask array with known parameters masked\n\n Returns\n -------\n **Attributes**:\n \"\"\"\n def __init__(self, coefs, intercept, sigma_u, A_solve, B_solve,\n names=None):\n self.k_ar = len(coefs)\n self.neqs = coefs.shape[1]\n self.coefs = coefs\n self.intercept = intercept\n self.sigma_u = sigma_u\n self.A_solve = A_solve\n self.B_solve = B_solve\n self.names = names\n\n def orth_ma_rep(self, maxn=10, P=None):\n \"\"\"\n\n Unavailable for SVAR\n\n \"\"\"\n raise NotImplementedError\n\n def svar_ma_rep(self, maxn=10, P=None):\n \"\"\"\n\n Compute Structural MA coefficient matrices using MLE\n of A, B\n\n \"\"\"\n if P is None:\n A_solve = self.A_solve\n B_solve = self.B_solve\n P = np.dot(npl.inv(A_solve), B_solve)\n\n ma_mats = self.ma_rep(maxn=maxn)\n return mat([np.dot(coefs, P) for coefs in ma_mats])\n\n\nclass SVARResults(SVARProcess, VARResults):\n \"\"\"\n Estimate VAR(p) process with fixed number of lags\n\n Parameters\n ----------\n endog : array\n endog_lagged : array\n params : array\n sigma_u : array\n lag_order : int\n model : VAR model instance\n trend : str {'nc', 'c', 'ct'}\n names : array-like\n List of names of the endogenous variables in order of appearance in `endog`.\n dates\n\n\n Returns\n -------\n **Attributes**\n aic\n bic\n bse\n coefs : ndarray (p x K x K)\n Estimated A_i matrices, A_i = coefs[i-1]\n cov_params\n dates\n detomega\n df_model : int\n df_resid : int\n endog\n endog_lagged\n fittedvalues\n fpe\n intercept\n info_criteria\n k_ar : int\n k_trend : int\n llf\n model\n names\n neqs : int\n Number of variables (equations)\n nobs : int\n n_totobs : int\n params\n k_ar : int\n Order of VAR process\n params : ndarray (Kp + 1) x K\n A_i matrices and intercept in stacked form [int A_1 ... A_p]\n pvalue\n names : list\n variables names\n resid\n sigma_u : ndarray (K x K)\n Estimate of white noise process variance Var[u_t]\n sigma_u_mle\n stderr\n trenorder\n tvalues\n y :\n ys_lagged\n \"\"\"\n\n _model_type = 'SVAR'\n\n def __init__(self, endog, endog_lagged, params, sigma_u, lag_order,\n A=None, B=None, A_mask=None, B_mask=None, model=None,\n trend='c', names=None, dates=None):\n\n self.model = model\n self.y = self.endog = endog #keep alias for now\n self.ys_lagged = self.endog_lagged = endog_lagged #keep alias for now\n self.dates = dates\n\n self.n_totobs, self.neqs = self.y.shape\n self.nobs = self.n_totobs - lag_order\n k_trend = util.get_trendorder(trend)\n if k_trend > 0: # make this the polynomial trend order\n trendorder = k_trend - 1\n else:\n trendorder = None\n self.k_trend = k_trend\n self.k_exog = k_trend # now (0.9) required by VARProcess\n self.trendorder = trendorder\n\n self.exog_names = util.make_lag_names(names, lag_order, k_trend)\n self.params = params\n self.sigma_u = sigma_u\n\n # Each matrix needs to be transposed\n reshaped = self.params[self.k_trend:]\n reshaped = reshaped.reshape((lag_order, self.neqs, self.neqs))\n\n # Need to transpose each coefficient matrix\n intercept = self.params[0]\n coefs = reshaped.swapaxes(1, 2).copy()\n\n #SVAR components\n #TODO: if you define these here, you don't also have to define\n #them in SVAR process, but I left them for now -ss\n self.A = A\n self.B = B\n self.A_mask = A_mask\n self.B_mask = B_mask\n\n super(SVARResults, self).__init__(coefs, intercept, sigma_u, A,\n B, names=names)\n\n def irf(self, periods=10, var_order=None):\n \"\"\"\n Analyze structural impulse responses to shocks in system\n\n Parameters\n ----------\n periods : int\n\n Returns\n -------\n irf : IRAnalysis\n \"\"\"\n A = self.A\n B= self.B\n P = np.dot(npl.inv(A), B)\n\n return IRAnalysis(self, P=P, periods=periods, svar=True)\n\n def sirf_errband_mc(self, orth=False, repl=1000, T=10,\n signif=0.05, seed=None, burn=100, cum=False):\n \"\"\"\n Compute Monte Carlo integrated error bands assuming normally\n distributed for impulse response functions\n\n Parameters\n ----------\n orth: bool, default False\n Compute orthoganalized impulse response error bands\n repl: int\n number of Monte Carlo replications to perform\n T: int, default 10\n number of impulse response periods\n signif: float (0 < signif <1)\n Significance level for error bars, defaults to 95% CI\n seed: int\n np.random.seed for replications\n burn: int\n number of initial observations to discard for simulation\n cum: bool, default False\n produce cumulative irf error bands\n\n Notes\n -----\n Lütkepohl (2005) Appendix D\n\n Returns\n -------\n Tuple of lower and upper arrays of ma_rep monte carlo standard errors\n\n \"\"\"\n neqs = self.neqs\n mean = self.mean()\n k_ar = self.k_ar\n coefs = self.coefs\n sigma_u = self.sigma_u\n intercept = self.intercept\n df_model = self.df_model\n nobs = self.nobs\n\n ma_coll = np.zeros((repl, T+1, neqs, neqs))\n A = self.A\n B = self.B\n A_mask = self.A_mask\n B_mask = self.B_mask\n A_pass = np.zeros(A.shape, dtype='|S1')\n B_pass = np.zeros(B.shape, dtype='|S1')\n A_pass[~A_mask] = A[~A_mask]\n B_pass[~B_mask] = B[~B_mask]\n A_pass[A_mask] = 'E'\n B_pass[B_mask] = 'E'\n if A_mask.sum() == 0:\n s_type = 'B'\n elif B_mask.sum() == 0:\n s_type = 'A'\n else:\n s_type = 'AB'\n g_list = []\n\n for i in range(repl):\n #discard first hundred to correct for starting bias\n sim = util.varsim(coefs, intercept, sigma_u,\n steps=nobs+burn)\n sim = sim[burn:]\n if cum == True:\n if i < 10:\n sol = SVAR(sim, svar_type=s_type, A=A_pass,\n B=B_pass).fit(maxlags=k_ar)\n g_list.append(np.append(sol.A[sol.A_mask].\\\n tolist(),\n sol.B[sol.B_mask].\\\n tolist()))\n ma_coll[i] = sol.svar_ma_rep(maxn=T).cumsum(axis=0)\n elif i >= 10:\n if i == 10:\n mean_AB = np.mean(g_list, axis = 0)\n split = len(A_pass[A_mask])\n opt_A = mean_AB[:split]\n opt_B = mean_AB[split:]\n ma_coll[i] = SVAR(sim, svar_type=s_type, A=A_pass,\n B=B_pass).fit(maxlags=k_ar,\\\n A_guess=opt_A, B_guess=opt_B).\\\n svar_ma_rep(maxn=T).cumsum(axis=0)\n\n elif cum == False:\n if i < 10:\n sol = SVAR(sim, svar_type=s_type, A=A_pass,\n B=B_pass).fit(maxlags=k_ar)\n g_list.append(np.append(sol.A[A_mask].tolist(),\n sol.B[B_mask].tolist()))\n ma_coll[i] = sol.svar_ma_rep(maxn=T)\n elif i >= 10:\n if i == 10:\n mean_AB = np.mean(g_list, axis = 0)\n split = len(A[A_mask])\n opt_A = mean_AB[:split]\n opt_B = mean_AB[split:]\n ma_coll[i] = SVAR(sim, svar_type=s_type, A=A_pass,\n B=B_pass).fit(maxlags=k_ar,\\\n A_guess = opt_A, B_guess = opt_B).\\\n svar_ma_rep(maxn=T)\n\n ma_sort = np.sort(ma_coll, axis=0) #sort to get quantiles\n index = round(signif/2*repl)-1,round((1-signif/2)*repl)-1\n lower = ma_sort[index[0],:, :, :]\n upper = ma_sort[index[1],:, :, :]\n return lower, upper\n"
] | [
[
"numpy.asarray",
"numpy.ones"
],
[
"numpy.testing.assert_equal",
"pandas.to_datetime",
"pandas.PeriodIndex",
"numpy.arange",
"pandas.DatetimeIndex",
"pandas.DataFrame",
"numpy.testing.assert_",
"numpy.random.RandomState",
"matplotlib.pyplot.figure"
],
[
"numpy.asarray",
"pandas.DataFrame",
"matplotlib.pyplot.axes",
"matplotlib.pyplot.plot",
"numpy.exp",
"numpy.random.randint",
"matplotlib.backends.backend_pdf.PdfPages",
"numpy.random.poisson",
"matplotlib.pyplot.figure",
"numpy.log",
"matplotlib.pyplot.title",
"matplotlib.pyplot.fill_between",
"matplotlib.pyplot.ylabel",
"numpy.random.seed",
"matplotlib.pyplot.figlegend",
"numpy.percentile",
"numpy.random.uniform",
"numpy.random.normal",
"matplotlib.pyplot.clf",
"matplotlib.pyplot.xlabel",
"numpy.vstack"
],
[
"pandas.Series"
],
[
"numpy.dot",
"numpy.arange",
"numpy.cos",
"numpy.tile",
"numpy.sin",
"numpy.ones",
"numpy.random.normal",
"numpy.testing.assert_allclose",
"numpy.array",
"numpy.zeros"
],
[
"numpy.dot",
"numpy.log",
"numpy.linalg.inv",
"numpy.linalg.slogdet",
"numpy.kron",
"numpy.sort",
"numpy.logical_or",
"numpy.linalg.pinv",
"numpy.append",
"numpy.linalg.lstsq",
"numpy.identity",
"numpy.size",
"numpy.mean",
"numpy.linalg.det",
"numpy.ravel",
"numpy.array",
"numpy.zeros",
"numpy.trace"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [
"0.23",
"0.21",
"2.0",
"1.4",
"1.3",
"0.19",
"1.1",
"1.5",
"0.24",
"0.20",
"1.0",
"0.25",
"1.2"
],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [
"0.23",
"0.21",
"2.0",
"1.4",
"0.19",
"1.1",
"1.5",
"1.2",
"0.24",
"0.20",
"1.0",
"0.25",
"1.3"
],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [
"0.23",
"0.21",
"2.0",
"1.4",
"0.19",
"1.1",
"1.5",
"1.2",
"0.24",
"0.20",
"1.0",
"0.25",
"1.3"
],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
Westlake-AI/openmixup | [
"ea81250819e740dd823e30cb7ce382d14a3c1b91",
"ea81250819e740dd823e30cb7ce382d14a3c1b91",
"ea81250819e740dd823e30cb7ce382d14a3c1b91",
"ea81250819e740dd823e30cb7ce382d14a3c1b91"
] | [
"openmixup/models/heads/mim_head.py",
"benchmarks/classification/svm_voc07/extract.py",
"openmixup/models/selfsup/relative_loc.py",
"openmixup/models/losses/regression_loss.py"
] | [
"import torch\nimport torch.nn as nn\nfrom mmcv.runner import BaseModule\nfrom torch.nn import functional as F\nfrom mmcv.cnn.utils.weight_init import trunc_normal_init\n\nfrom ..builder import build_loss\nfrom ..registry import HEADS\nfrom .cls_head import ClsHead\nfrom openmixup.utils import print_log\n\n\[email protected]_module\nclass MAEPretrainHead(BaseModule):\n \"\"\"Pre-training head for MAE.\n\n Args:\n norm_pix_loss (bool): Whether or not normalize target.\n Defaults to False.\n patch_size (int): Patch size. Defaults to 16.\n \"\"\"\n\n def __init__(self, norm_pix=False, patch_size=16):\n super(MAEPretrainHead, self).__init__()\n self.norm_pix = norm_pix\n self.patch_size = patch_size\n\n def patchify(self, imgs):\n\n p = self.patch_size\n assert imgs.shape[2] == imgs.shape[3] and imgs.shape[2] % p == 0\n\n h = w = imgs.shape[2] // p\n x = imgs.reshape(shape=(imgs.shape[0], 3, h, p, w, p))\n x = torch.einsum('nchpwq->nhwpqc', x)\n x = x.reshape(shape=(imgs.shape[0], h * w, p**2 * 3))\n return x\n\n def forward(self, x, x_rec, mask):\n losses = dict()\n target = self.patchify(x)\n if self.norm_pix:\n mean = target.mean(dim=-1, keepdim=True)\n var = target.var(dim=-1, keepdim=True)\n target = (target - mean) / (var + 1.e-6)**.5\n\n loss = (x_rec - target)**2\n loss = loss.mean(dim=-1)\n\n loss = (loss * mask).sum() / mask.sum()\n losses['loss'] = loss\n return losses\n\n\[email protected]_module()\nclass MAEFinetuneHead(ClsHead):\n \"\"\"Fine-tuning head for MAE.\n\n Args:\n embed_dim (int): The dim of the feature before the classifier head.\n num_classes (int): The total classes. Defaults to 1000.\n \"\"\"\n\n def __init__(self, **kwargs):\n super(MAEFinetuneHead, self).__init__(**kwargs)\n\n def init_weights(self):\n for m in self.modules():\n if isinstance(m, nn.Linear):\n trunc_normal_init(m, std=2e-5, bias=0)\n\n def forward(self, x):\n \"\"\"\"Get the logits.\"\"\"\n assert isinstance(x, (tuple, list)) and len(x) == 1\n x = x[0]\n return [self.fc(x)]\n\n\[email protected]_module()\nclass MAELinprobeHead(ClsHead):\n \"\"\"Linear probing head for MAE.\n\n Args:\n embed_dim (int): The dim of the feature before the classifier head.\n num_classes (int): The total classes. Defaults to 1000.\n \"\"\"\n\n def __init__(self, in_channels=786, **kwargs):\n super(MAELinprobeHead, self).__init__(in_channels=in_channels, **kwargs)\n self.bn = nn.BatchNorm1d(in_channels, affine=False, eps=1e-6)\n\n def init_weights(self):\n for m in self.modules():\n if isinstance(m, nn.Linear):\n trunc_normal_init(m, std=0.01, bias=0)\n\n def forward(self, x):\n \"\"\"\"Get the logits.\"\"\"\n assert isinstance(x, (tuple, list)) and len(x) == 1\n x = self.bn(x[0])\n return [self.fc(x)]\n\n\[email protected]_module\nclass SimMIMHead(BaseModule):\n \"\"\"Pretrain Head for SimMIM.\n\n Args:\n encoder_in_channels (int): Number of input channels for encoder.\n \"\"\"\n\n def __init__(self, encoder_in_channels=3):\n super(SimMIMHead, self).__init__()\n self.encoder_in_channels = encoder_in_channels\n\n def forward(self, x, x_rec, mask):\n scale_h, scale_w = x.size(2) / mask.size(1), x.size(3) / mask.size(2)\n if scale_h > 1:\n mask = mask.repeat_interleave(int(scale_h), 1).repeat_interleave(\n int(scale_w), 2).unsqueeze(1).contiguous()\n else:\n mask = F.interpolate(mask.type_as(x).unsqueeze(1),\n scale_factor=(scale_h, scale_w), mode=\"nearest\")\n \n loss_rec = F.l1_loss(x_rec, x, reduction='none')\n loss = (loss_rec * mask).sum() / (mask.sum() +\n 1e-5) / self.encoder_in_channels\n losses = dict()\n losses['loss'] = loss\n\n return losses\n\n\[email protected]_module\nclass MIMHead(BaseModule):\n \"\"\"Head for A2MIM training.\n\n Args:\n loss (dict): Config of regression loss.\n encoder_in_channels (int): Number of input channels for encoder.\n unmask_weight (float): Loss weight for unmasked patches.\n fft_weight (float): Loss weight for the fft prediction loss. Default to 0.\n fft_reweight (bool): Whether to use the fft reweight loss. Default to False.\n fft_focal (bool): Whether to adopt the focal fft loss. Default to False.\n fft_unmask_replace (str): Mode to replace (detach) unmask patches for the fft\n loss, in {None, 'target', 'prediction', 'mean', 'mixed',}.\n fft_unmask_weight (float): Loss weight to caculate the fft loss on unmask\n tokens. Default to 0.\n \"\"\"\n\n def __init__(self,\n loss=dict(\n type='RegressionLoss', loss_weight=1.0, mode=\"l1_loss\"),\n encoder_in_channels=3,\n unmask_weight=0,\n fft_weight=0,\n fft_reweight=False,\n fft_focal=False,\n fft_unmask_replace=None,\n fft_unmask_weight=0,\n **kwargs,\n ):\n super(MIMHead, self).__init__()\n self.encoder_in_channels = encoder_in_channels\n self.unmask_weight = unmask_weight\n self.fft_weight = fft_weight\n self.fft_reweight = fft_reweight\n self.fft_focal = fft_focal\n self.fft_unmask_weight = fft_unmask_weight\n self.fft_unmask_replace = fft_unmask_replace\n assert fft_unmask_replace in [None, 'target', 'prediction', 'mean', 'mixed',]\n assert 0 <= unmask_weight <= 1 and 0 <= fft_unmask_weight <= 1\n if self.unmask_weight < 1:\n if fft_unmask_replace is None and fft_weight > 0:\n self.fft_unmask_replace = 'target'\n print_log(\"When using the fft loss, `fft_unmask_replace` should \" + \\\n \"not be None. Reset as `fft_unmask_replace='target'`.\")\n \n # spatial loss\n assert loss is None or isinstance(loss, dict)\n if loss is None:\n loss = dict(\n type='RegressionLoss', loss_weight=1.0, mode=\"l1_loss\")\n self.criterion = build_loss(loss)\n # fft loss\n if fft_focal:\n fft_loss = dict(\n type='FocalFrequencyLoss', loss_weight=1.0, alpha=1.0,\n ave_spectrum=True, log_matrix=True, batch_matrix=True)\n else:\n fft_loss = loss\n if loss[\"mode\"] not in [\"l1_loss\", \"mse_loss\", \"focal_l1_loss\", \"focal_mse_loss\",]:\n fft_loss['mode'] = \"l1_loss\"\n self.fft_loss = build_loss(fft_loss)\n\n def forward(self, x, x_rec, mask):\n # upsampling mask\n scale_h, scale_w = x.size(2) / mask.size(1), x.size(3) / mask.size(2)\n if scale_h > 1:\n mask = mask.repeat_interleave(int(scale_h), 1).repeat_interleave(\n int(scale_w), 2).unsqueeze(1).contiguous()\n else:\n mask = F.interpolate(mask.type_as(x).unsqueeze(1),\n scale_factor=(scale_h, scale_w), mode=\"nearest\")\n \n # spatial loss\n if self.unmask_weight > 0.:\n # reweight unmasked patches\n mask_s = mask.clone()\n mask_s = mask_s + (1. - mask_s) * self.unmask_weight\n else:\n mask_s = mask\n loss_rec = self.criterion(x_rec, target=x, reduction_override='none')\n loss_rec = (loss_rec * mask_s).sum() / (mask_s.sum() + 1e-5) / self.encoder_in_channels\n \n # fourier domain loss\n if self.fft_weight > 0:\n # replace unmask patches (with detach)\n x_replace = None\n if self.fft_unmask_replace is not None:\n if self.fft_unmask_replace == 'target':\n x_replace = x.clone()\n elif self.fft_unmask_replace == 'prediction':\n x_replace = x_rec.clone().detach()\n elif self.fft_unmask_replace == 'mean':\n x_replace = x.mean(dim=[2, 3], keepdim=True).expand(x.size())\n elif self.fft_unmask_replace == 'mixed':\n x_replace = 0.5 * x_rec.clone().detach() + 0.5 * x.clone()\n if self.fft_unmask_weight < 1:\n mask_f = mask.clone()\n mask_f = mask_f + (1. - mask_f) * self.fft_unmask_weight\n x_rec = (x_rec * mask_f) + (x_replace * (1. - mask_f)) # replace unmask tokens\n \n # apply fft loss\n if self.fft_focal:\n loss_fft = self.fft_loss(x_rec, x)\n else:\n f_x = torch.fft.fftn(x, dim=(2, 3), norm='ortho')\n f_x_rec = torch.fft.fftn(x_rec, dim=(2, 3), norm='ortho')\n if self.fft_reweight:\n loss_fft = self.fft_loss(f_x_rec, target=f_x, reduction_override='none')\n fft_weight = loss_fft.clone().detach()\n loss_fft = (fft_weight * loss_fft).mean()\n else:\n loss_fft = self.fft_loss(f_x_rec, target=f_x, reduction_override='mean')\n loss_rec += self.fft_weight * loss_fft\n \n losses = dict()\n losses['loss'] = loss_rec\n \n return losses\n",
"# Copyright (c) OpenMMLab. All rights reserved.\nimport argparse\nimport os\nimport os.path as osp\nimport time\n\nimport mmcv\nimport numpy as np\nimport torch\nfrom mmcv import DictAction\nfrom mmcv.parallel import MMDataParallel, MMDistributedDataParallel\nfrom mmcv.runner import get_dist_info, init_dist, load_checkpoint\n\nfrom openmixup.datasets import build_dataloader, build_dataset\nfrom openmixup.models import build_model\nfrom openmixup.hooks import MultiExtractProcess\nfrom openmixup.utils import get_root_logger\n\n\ndef parse_args():\n parser = argparse.ArgumentParser(\n description='MMSelfSup extract features of a model')\n parser.add_argument('config', help='test config file path')\n parser.add_argument('--checkpoint', default=None, help='checkpoint file')\n parser.add_argument(\n '--dataset-config',\n default='configs/benchmarks/classification/svm_voc07.py',\n help='extract dataset config file path')\n parser.add_argument(\n '--layer-ind',\n type=str,\n help='layer indices, separated by comma, e.g., \"0,1,2,3,4\"')\n parser.add_argument(\n '--work_dir',\n type=str,\n default=None,\n help='the dir to save logs and models')\n parser.add_argument(\n '--launcher',\n choices=['none', 'pytorch', 'slurm', 'mpi'],\n default='none',\n help='job launcher')\n parser.add_argument('--local_rank', type=int, default=0)\n parser.add_argument(\n '--cfg-options',\n nargs='+',\n action=DictAction,\n help='override some settings in the used config, the key-value pair '\n 'in xxx=yyy format will be merged into config file. If the value to '\n 'be overwritten is a list, it should be like key=\"[a,b]\" or key=a,b '\n 'It also allows nested list/tuple values, e.g. key=\"[(a,b),(c,d)]\" '\n 'Note that the quotation marks are necessary and that no white space '\n 'is allowed.')\n args = parser.parse_args()\n if 'LOCAL_RANK' not in os.environ:\n os.environ['LOCAL_RANK'] = str(args.local_rank)\n return args\n\n\ndef main():\n args = parse_args()\n cfg = mmcv.Config.fromfile(args.config)\n if args.cfg_options is not None:\n cfg.merge_from_dict(args.cfg_options)\n # set cudnn_benchmark\n if cfg.get('cudnn_benchmark', False):\n torch.backends.cudnn.benchmark = True\n # work_dir is determined in this priority: CLI > segment in file > filename\n if args.work_dir is not None:\n # update configs according to CLI args if args.work_dir is not None\n cfg.work_dir = args.work_dir\n elif cfg.get('work_dir', None) is None:\n # use config filename as default work_dir if cfg.work_dir is None\n work_type = args.config.split('/')[1]\n cfg.work_dir = osp.join('./work_dirs', work_type,\n osp.splitext(osp.basename(args.config))[0])\n\n # get out_indices from args\n layer_ind = [int(idx) for idx in args.layer_ind.split(',')]\n cfg.model.backbone.out_indices = layer_ind\n\n # init distributed env first, since logger depends on the dist info.\n if args.launcher == 'none':\n distributed = False\n else:\n distributed = True\n init_dist(args.launcher, **cfg.dist_params)\n\n # create work_dir\n mmcv.mkdir_or_exist(osp.abspath(cfg.work_dir))\n # init the logger before other steps\n timestamp = time.strftime('%Y%m%d_%H%M%S', time.localtime())\n log_file = osp.join(cfg.work_dir, f'extract_{timestamp}.log')\n logger = get_root_logger(log_file=log_file, log_level=cfg.log_level)\n\n # build the dataloader\n dataset_cfg = mmcv.Config.fromfile(args.dataset_config)\n dataset = build_dataset(dataset_cfg.data.extract)\n \n data_loader = build_dataloader(\n dataset,\n imgs_per_gpu=dataset_cfg.data.imgs_per_gpu,\n workers_per_gpu=dataset_cfg.data.workers_per_gpu,\n dist=distributed,\n shuffle=False)\n\n # build the model\n model = build_model(cfg.model)\n model.init_weights()\n\n # model is determined in this priority: init_cfg > checkpoint > random\n if getattr(cfg.model.backbone.init_cfg, 'type', None) == 'Pretrained':\n logger.info(\n f'Use pretrained model: '\n f'{cfg.model.backbone.init_cfg.checkpoint} to extract features')\n elif args.checkpoint is not None:\n logger.info(f'Use checkpoint: {args.checkpoint} to extract features')\n load_checkpoint(model, args.checkpoint, map_location='cpu')\n else:\n logger.info('No pretrained or checkpoint is given, use random init.')\n\n if not distributed:\n model = MMDataParallel(model, device_ids=[0])\n else:\n model = MMDistributedDataParallel(\n model.cuda(),\n device_ids=[torch.cuda.current_device()],\n broadcast_buffers=False)\n\n # build extraction processor\n extractor = MultiExtractProcess(\n pool_type='specified', backbone='resnet50', layer_indices=layer_ind)\n\n # run\n outputs = extractor.extract(model, data_loader, distributed=distributed)\n rank, _ = get_dist_info()\n mmcv.mkdir_or_exist(f'{args.work_dir}/features/')\n if rank == 0:\n for key, val in outputs.items():\n split_num = len(dataset_cfg.split_name)\n split_at = dataset_cfg.split_at\n for ss in range(split_num):\n output_file = f'{args.work_dir}/features/' \\\n f'{dataset_cfg.split_name[ss]}_{key}.npy'\n if ss == 0:\n np.save(output_file, val[:split_at[0]])\n elif ss == split_num - 1:\n np.save(output_file, val[split_at[-1]:])\n else:\n np.save(output_file, val[split_at[ss - 1]:split_at[ss]])\n\n\nif __name__ == '__main__':\n main()\n",
"# reference: https://github.com/open-mmlab/mmselfsup/tree/master/mmselfsup/models/algorithms\n# modified from mmselfsup relative_loc.py\nimport torch\n\nfrom openmixup.utils import auto_fp16, print_log\n\nfrom ..classifiers import BaseModel\nfrom .. import builder\nfrom ..registry import MODELS\n\n\[email protected]_module\nclass RelativeLoc(BaseModel):\n \"\"\"Relative patch location.\n\n Implementation of \"Unsupervised Visual Representation Learning\n by Context Prediction (https://arxiv.org/abs/1505.05192)\".\n\n Args:\n backbone (dict): Config dict for module of backbone ConvNet.\n neck (dict): Config dict for module of deep features to compact feature vectors.\n Default: None.\n head (dict): Config dict for module of loss functions. Default: None.\n pretrained (str, optional): Path to pre-trained weights. Default: None.\n \"\"\"\n\n def __init__(self,\n backbone,\n neck=None,\n head=None,\n pretrained=None,\n init_cfg=None,\n **kwargs):\n super(RelativeLoc, self).__init__(init_cfg, **kwargs)\n self.backbone = builder.build_backbone(backbone)\n assert isinstance(neck, dict) and isinstance(head, dict)\n self.neck = builder.build_neck(neck)\n self.head = builder.build_head(head)\n self.init_weights(pretrained=pretrained)\n\n def init_weights(self, pretrained=None):\n \"\"\"Initialize the weights of model.\n\n Args:\n pretrained (str, optional): Path to pre-trained weights.\n Default: None.\n \"\"\"\n super(RelativeLoc, self).init_weights()\n\n if pretrained is not None:\n print_log('load model from: {}'.format(pretrained), logger='root')\n self.backbone.init_weights(pretrained=pretrained)\n self.neck.init_weights(init_linear='normal')\n self.head.init_weights(init_linear='normal', std=0.005)\n\n def forward_backbone(self, img):\n \"\"\"Forward backbone.\n\n Args:\n img (Tensor): Input images of shape (N, C, H, W).\n Typically these should be mean centered and std scaled.\n\n Returns:\n tuple[Tensor]: backbone outputs.\n \"\"\"\n x = self.backbone(img)\n return x\n\n def forward_train(self, img, patch_label, **kwargs):\n \"\"\"Forward computation during training.\n\n Args:\n img (Tensor): Input images of shape (N, C, H, W).\n Typically these should be mean centered and std scaled.\n patch_label (Tensor): Labels for the relative patch locations.\n kwargs: Any keyword arguments to be used to forward.\n\n Returns:\n dict[str, Tensor]: A dictionary of loss components.\n \"\"\"\n img1, img2 = torch.chunk(img, 2, dim=1)\n x1 = self.forward_backbone(img1) # tuple\n x2 = self.forward_backbone(img2) # tuple\n x = (torch.cat((x1[0], x2[0]), dim=1),)\n x = self.neck(x)\n outs = self.head(x)\n loss_inputs = (outs, patch_label)\n losses = self.head.loss(*loss_inputs)\n return losses\n\n def forward_test(self, img, **kwargs):\n \"\"\"Forward computation during training.\n\n Args:\n img (Tensor): Input images of shape (N, C, H, W).\n Typically these should be mean centered and std scaled.\n\n Returns:\n dict[str, Tensor]: A dictionary of output features.\n \"\"\"\n img1, img2 = torch.chunk(img, 2, dim=1)\n x1 = self.forward_backbone(img1) # tuple\n x2 = self.forward_backbone(img2) # tuple\n x = (torch.cat((x1[0], x2[0]), dim=1),)\n x = self.neck(x)\n outs = self.head(x)\n keys = [f'head{i}' for i in range(len(outs))]\n out_tensors = [out.cpu() for out in outs]\n return dict(zip(keys, out_tensors))\n\n @auto_fp16(apply_to=('img', ))\n def forward(self, img, patch_label=None, mode='train', **kwargs):\n \"\"\"Forward function to select mode and modify the input image shape.\n\n Args:\n img (Tensor): Input images, the shape depends on mode.\n Typically these should be mean centered and std scaled.\n \"\"\"\n if mode != \"extract\" and img.dim() == 5: # Nx8x(2C)xHxW\n assert patch_label.dim() == 2 # Nx8\n img = img.view(\n img.size(0) * img.size(1), img.size(2), img.size(3),\n img.size(4)) # (8N)x(2C)xHxW\n patch_label = torch.flatten(patch_label) # (8N)\n if mode == 'train':\n return self.forward_train(img, patch_label, **kwargs)\n elif mode == 'test':\n return self.forward_test(img, **kwargs)\n elif mode == 'extract':\n return self.forward_backbone(img)\n else:\n raise Exception(\"No such mode: {}\".format(mode))\n",
"import math\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\n\nfrom ..registry import LOSSES\n\n\ndef l1_loss(pred, target, weight=None, reduction='mean', **kwargs):\n \"\"\"Calculate L1 loss.\"\"\"\n loss = F.l1_loss(pred, target, reduction='none')\n if weight is not None:\n loss *= weight.expand_as(loss)\n if reduction == 'mean':\n loss = loss.mean()\n elif reduction == 'sum':\n loss = loss.sum()\n return loss\n\n\ndef mse_loss(pred, target, weight=None, reduction='mean', **kwargs):\n \"\"\"Calculate MSE (L2) loss.\"\"\"\n loss = F.mse_loss(pred, target, reduction='none')\n if weight is not None:\n loss *= weight.expand_as(loss)\n if reduction == 'mean':\n loss = loss.mean()\n elif reduction == 'sum':\n loss = loss.sum()\n return loss\n\n\ndef focal_l1_loss(pred, target,\n alpha=0.2, gamma=1.0, activate='sigmoid', residual=False,\n weight=None, reduction='mean', **kwargs):\n r\"\"\"Calculate Focal L1 loss.\n\n Delving into Deep Imbalanced Regression. In ICML, 2021.\n <https://arxiv.org/abs/2102.09554>\n\n Args:\n pred (torch.Tensor): The prediction with shape (N, \\*).\n target (torch.Tensor): The regression target with shape (N, \\*).\n alpha (float): A balanced form for Focal Loss. Defaults to 0.2.\n gamma (float): The gamma for calculating the modulating factor.\n Defaults to 1.0.\n activate (str): activate methods in Focal loss in {'sigmoid', 'tanh'}.\n Defaults to 'sigmoid'.\n residual (bool): Whether to use the original l1_loss, i.e., l1 + focal_l1.\n Defaults to False.\n weight (tensor): Sample-wise reweight of (N, \\*) or element-wise\n reweight of (1, \\*). Defaults to None.\n reduction (str): The method used to reduce the loss.\n\n Returns:\n torch.Tensor: The calculated loss\n \"\"\"\n _loss = F.l1_loss(pred, target, reduction='none')\n if activate == 'tanh':\n loss = _loss * (torch.tanh(alpha * _loss)) ** gamma\n else:\n loss = _loss * (2. * torch.sigmoid(alpha * _loss) - 1.) ** gamma\n if residual:\n loss += _loss\n\n if weight is not None:\n loss *= weight.expand_as(loss)\n if reduction == 'mean':\n loss = loss.mean()\n elif reduction == 'sum':\n loss = loss.sum()\n return loss\n\n\ndef focal_mse_loss(pred, target,\n alpha=0.2, gamma=1.0, activate='sigmoid', residual=False,\n weight=None, reduction='mean', **kwargs):\n r\"\"\"Calculate Focal MSE (L2) loss.\n\n Delving into Deep Imbalanced Regression. In ICML, 2021.\n <https://arxiv.org/abs/2102.09554>\n\n Args:\n pred (torch.Tensor): The prediction with shape (N, \\*).\n target (torch.Tensor): The regression target with shape (N, \\*).\n alpha (float): A balanced form for Focal Loss. Defaults to 0.2.\n gamma (float): The gamma for calculating the modulating factor.\n Defaults to 1.0.\n activate (str): activate methods in Focal loss in {'sigmoid', 'tanh'}.\n Defaults to 'sigmoid'.\n residual (bool): Whether to use the original l2_loss, i.e., l2 + focal_l2.\n Defaults to False.\n weight (tensor): Sample-wise reweight of (N, \\*) or element-wise\n reweight of (1, \\*). Defaults to None.\n reduction (str): The method used to reduce the loss.\n\n Returns:\n torch.Tensor: The calculated loss\n \"\"\"\n _l2_loss = (pred - target) ** 2\n _l1_loss = torch.abs(pred - target)\n if activate == 'tanh':\n loss = _l2_loss * (torch.tanh(alpha * _l1_loss)) ** gamma\n else:\n loss = _l2_loss * (2. * torch.sigmoid(alpha * _l1_loss) - 1.) ** gamma\n if residual:\n loss += _l2_loss\n \n if weight is not None:\n loss *= weight.expand_as(loss)\n if reduction == 'mean':\n loss = loss.mean()\n elif reduction == 'sum':\n loss = loss.sum()\n return loss\n\n\ndef huber_loss(pred,\n target,\n beta=1.0,\n weight=None,\n reduction='mean',\n **kwargs):\n r\"\"\"Calculate Huber loss.\n\n Args:\n pred (torch.Tensor): The prediction with shape (N, \\*).\n target (torch.Tensor): The regression target with shape (N, \\*).\n beta (float): Weight factor of the L1 and L2 losses.\n weight (tensor): Sample-wise reweight of (N, \\*) or element-wise\n reweight of (1, \\*). Defaults to None.\n reduction (str): The method used to reduce the loss.\n\n Returns:\n torch.Tensor: The calculated loss\n \"\"\"\n _loss = torch.abs(pred - target)\n cond = _loss < beta\n loss = torch.where(cond, 0.5 * _loss ** 2 / beta, _loss - 0.5 * beta)\n\n if weight is not None:\n loss *= weight.expand_as(loss)\n if reduction == 'mean':\n loss = loss.mean()\n elif reduction == 'sum':\n loss = loss.sum()\n return loss\n\n\ndef balanced_l1_loss(pred, target,\n alpha=0.5, beta=1.0, gamma=1.5,\n weight=None, reduction='mean', **kwargs):\n r\"\"\"Calculate Balanced L1 loss.\n\n Libra R-CNN: Towards Balanced Learning for Object Detection. In CVPR, 2019.\n <https://arxiv.org/abs/1904.02701>\n\n Args:\n pred (torch.Tensor): The prediction with shape (N, \\*).\n target (torch.Tensor): The regression target with shape (N, \\*).\n beta (float): The loss is a piecewise function of prediction and\n target and ``beta`` serves as a threshold for the difference\n between the prediction and target. Defaults to 1.0.\n alpha (float): The denominator ``alpha`` in the balanced L1 loss.\n Defaults to 0.5.\n gamma (float): The ``gamma`` in the balanced L1 loss.\n Defaults to 1.5.\n weight (tensor): Sample-wise reweight of (N, \\*) or element-wise\n reweight of (1, \\*). Defaults to None.\n reduction (str): The method used to reduce the loss.\n\n Returns:\n torch.Tensor: The calculated loss\n \"\"\"\n assert beta > 0 and alpha > 0\n if target.numel() == 0:\n return pred.sum() * 0\n\n _loss = torch.abs(pred - target)\n b = math.e ** (gamma / alpha) - 1\n loss = torch.where(\n _loss < beta, alpha / b * (b * _loss + 1) * torch.log(b * _loss / beta + 1) - \\\n alpha * _loss, gamma * _loss + gamma / b - alpha * beta)\n \n if weight is not None:\n loss *= weight.expand_as(loss)\n if reduction == 'mean':\n loss = loss.mean()\n elif reduction == 'sum':\n loss = loss.sum()\n return loss\n\n\ndef kl_loss(pred,\n target,\n weight=None,\n reduction='batchmean',\n **kwargs):\n r\"\"\"Calculate KL loss.\n\n Args:\n pred (torch.Tensor): The prediction with shape (N, \\*).\n target (torch.Tensor): The regression target with shape (N, \\*).\n weight (tensor): Sample-wise reweight of (N, \\*) or element-wise\n reweight of (1, \\*). Defaults to None.\n reduction (str): The method used to reduce the loss.\n\n Returns:\n torch.Tensor: The calculated loss\n \"\"\"\n loss = F.kl_div(pred, target, reduction='none', log_target=False)\n\n if weight is not None:\n loss *= weight.expand_as(loss)\n if reduction == 'mean':\n loss = loss.mean()\n elif reduction == 'batchmean':\n loss = loss.sum() / pred.size(0)\n elif reduction == 'sum':\n loss = loss.sum()\n return loss\n\n\ndef general_kl_loss(pred,\n target,\n alpha=0.1,\n weight=None,\n reduction='mean',\n **kwargs):\n r\"\"\"Calculate General KL loss.\n\n GenURL: A General Framework for Unsupervised Representation Learning.\n <https://arxiv.org/abs/2110.14553>\n\n Args:\n pred (torch.Tensor): The prediction with shape (N, \\*).\n target (torch.Tensor): The regression target with shape (N, \\*).\n weight (tensor): Sample-wise reweight of (N, \\*) or element-wise\n reweight of (1, \\*). Defaults to None.\n alpha (float): Weight factor of the KL and sum losses.\n reduction (str): The method used to reduce the loss.\n\n Returns:\n torch.Tensor: The calculated loss\n \"\"\"\n EPS = 1e-10\n # remove negative target\n if (target < 0.).any() == True: # min-max normalization\n B, C = target.shape[:2]\n t_min, _ = torch.min(target.view(B, C, -1), dim=2)\n t_max, _ = torch.max(target.view(B, C, -1), dim=2)\n target = (target - t_min.view(B, C, 1)) / \\\n (t_max.view(B, C, 1) - t_min.view(B, C, 1))\n\n # element-wise losses\n sum1 = - (pred * torch.log(target + EPS))\n sum2 = F.l1_loss(pred, target)\n loss = sum1 + alpha * sum2\n\n if weight is not None:\n loss *= weight.expand_as(loss)\n if reduction == 'mean':\n loss = loss.mean()\n elif reduction == 'batchmean':\n loss = loss.sum() / pred.size(0)\n elif reduction == 'sum':\n loss = loss.sum()\n return loss\n\n\ndef fuzzy_ce_loss(pred,\n target,\n weight=None,\n reduction='mean',\n **kwargs):\n r\"\"\"Calculate Fuzzy System Cross-entropy (CE) loss.\n\n UMAP: Uniform Manifold Approximation and Projection for Dimension Reduction.\n <https://arxiv.org/abs/1802.03426v1>\n\n Args:\n pred (torch.Tensor): The prediction with shape (N, \\*).\n target (torch.Tensor): The regression target with shape (N, \\*).\n weight (tensor): Sample-wise reweight of (N, \\*) or element-wise\n reweight of (1, \\*). Defaults to None.\n reduction (str): The method used to reduce the loss.\n\n Returns:\n torch.Tensor: The calculated loss\n \"\"\"\n EPS = 1e-10\n # remove negative target\n if (target < 0.).any() == True: # min-max normalization\n B, C = target.shape[:2]\n t_min, _ = torch.min(target.view(B, C, -1), dim=2)\n t_max, _ = torch.max(target.view(B, C, -1), dim=2)\n target = (target - t_min.view(B, C, 1)) / \\\n (t_max.view(B, C, 1) - t_min.view(B, C, 1))\n \n # element-wise losses\n sum1 = (pred * torch.log(target + EPS))\n sum2 = ((1 - pred) * torch.log(1 - target + EPS))\n loss = -1 * (sum1 + sum2)\n\n if weight is not None:\n loss *= weight.expand_as(loss)\n if reduction == 'mean':\n loss = loss.mean()\n elif reduction == 'batchmean':\n loss = loss.sum() / pred.size(0)\n elif reduction == 'sum':\n loss = loss.sum()\n return loss\n\n\ndef charbonnier_loss(pred,\n target,\n weight=None,\n eps=1e-8,\n reduction='mean',\n **kwargs):\n r\"\"\"Charbonnier loss (one variant of Robust L1Loss, a differentiable\n variant of L1Loss).\n\n Fast and Accurate Image Super-Resolution with Deep Laplacian Pyramid\n Networks. In TPAMI, 2018.\n <https://arxiv.org/abs/1710.01992v1>\n\n Args:\n pred (Tensor): Prediction Tensor with shape (N, \\*).\n target ([type]): Target Tensor with shape (N, \\*).\n weight (tensor): Sample-wise reweight of (N, \\*) or element-wise\n reweight of (1, \\*). Defaults to None.\n eps (float): A value used to control the curvature near zero.\n Default: 1e-12.\n\n Returns:\n torch.Tensor: The calculated loss.\n \"\"\"\n loss = torch.sqrt((pred - target) ** 2 + eps)\n\n if weight is not None:\n loss *= weight.expand_as(loss)\n if reduction == 'mean':\n loss = loss.mean()\n elif reduction == 'sum':\n loss = loss.sum()\n return loss\n\n\nclass BMCLoss(nn.Module):\n r\"\"\"Balanced MSE loss (Batch-based Monte-Carlo).\n\n Balanced MSE for Imbalanced Visual Regression. In CVPR 2022.\n <https://arxiv.org/abs/2203.16427>\n\n Args:\n init_noise_sigma (float): Initial scale of the noise.\n \"\"\"\n\n def __init__(self, init_noise_sigma=1.0):\n super(BMCLoss, self).__init__()\n self.noise_sigma = nn.Parameter(\n torch.tensor(init_noise_sigma), requires_grad=True)\n\n def bmc_loss(self, pred, target, noise_var):\n logits = - 0.5 * (pred - target.T).pow(2) / noise_var\n loss = F.cross_entropy(logits, torch.arange(pred.shape[0]).cuda())\n loss = loss * (2 * noise_var).detach()\n return loss\n\n def forward(self, pred, target, weight=None, reduction='mean', **kwargs):\n \"\"\"forward BMC loss.\n\n Args:\n pred (Tensor): Prediction Tensor with shape (N, \\*).\n target ([type]): Target Tensor with shape (N, \\*).\n weight (tensor): Sample-wise reweight of (N, \\*) or element-wise\n reweight of (1, \\*). Defaults to None.\n\n Returns:\n torch.Tensor: The calculated loss\n \"\"\"\n noise_var = self.noise_sigma ** 2\n loss = self.bmc_loss(\n pred.view(pred.size(0), -1), target.view(target.size(0), -1), noise_var)\n \n if weight is not None:\n loss *= weight.expand_as(loss)\n if reduction == 'mean':\n loss = loss.mean()\n elif reduction == 'sum':\n loss = loss.sum()\n return loss\n\n\nclass BNILoss(nn.Module):\n r\"\"\"Balanced MSE loss (Bin-based Numerical Integration).\n\n Balanced MSE for Imbalanced Visual Regression. In CVPR 2022.\n <https://arxiv.org/abs/2203.16427>\n\n Args:\n init_noise_sigma (float): Initial scale of the noise.\n bucket_centers (np.array): Pre-defined bin centers.\n bucket_weights (np.array): Pre-defined weight for each bin.\n \"\"\"\n\n def __init__(self,\n init_noise_sigma=1.0,\n bucket_centers=None, bucket_weights=None):\n super(BNILoss, self).__init__()\n self.noise_sigma = nn.Parameter(\n torch.tensor(init_noise_sigma), requires_grad=True)\n self.bucket_centers = torch.tensor(bucket_centers).cuda()\n self.bucket_weights = torch.tensor(bucket_weights).cuda()\n\n def bni_loss(self, pred, target, noise_var, bucket_centers, bucket_weights):\n mse_term = F.mse_loss(pred, target, reduction='none') / 2 / noise_var\n\n num_bucket = bucket_centers.shape[0]\n bucket_center = bucket_centers.unsqueeze(0).repeat(pred.shape[0], 1)\n bucket_weights = bucket_weights.unsqueeze(0).repeat(pred.shape[0], 1)\n\n balancing_term = - 0.5 * (\n pred.expand(-1, num_bucket) - bucket_center).pow(2) \\\n / noise_var + bucket_weights.log()\n balancing_term = torch.logsumexp(balancing_term, dim=-1, keepdim=True)\n loss = mse_term + balancing_term\n loss = loss * (2 * noise_var).detach()\n return loss\n\n def forward(self, pred, target, weight=None, reduction='mean', **kwargs):\n \"\"\"forward BNI loss.\n\n Args:\n pred (Tensor): Prediction Tensor with shape (N, \\*).\n target ([type]): Target Tensor with shape (N, \\*).\n weight (tensor): Sample-wise reweight of (N, \\*) or element-wise\n reweight of (1, \\*). Defaults to None.\n\n Returns:\n torch.Tensor: The calculated loss\n \"\"\"\n noise_var = self.noise_sigma ** 2\n loss = self.bni_loss(\n pred.view(pred.size(0), -1), target.view(target.size(0), -1),\n noise_var, self.bucket_centers, self.bucket_weights)\n \n if weight is not None:\n loss *= weight.expand_as(loss)\n if reduction == 'mean':\n loss = loss.mean()\n elif reduction == 'sum':\n loss = loss.sum()\n return loss\n\n\[email protected]_module()\nclass RegressionLoss(nn.Module):\n r\"\"\"Simple Regression Loss.\n\n Args:\n mode (bool): Type of regression loss. Notice that when using\n FP16 training, {'mse_loss', 'smooth_l1_loss'} should use\n 'mmcv' mode. Defaults to \"mse_loss\".\n reduction (str): The method used to reduce the loss. Options\n are \"none\", \"mean\" and \"sum\". Defaults to 'mean'.\n loss_weight (float): Weight of the loss. Defaults to 1.0.\n \"\"\"\n\n def __init__(self,\n mode=\"mse_loss\",\n reduction='mean',\n loss_weight=1.0,\n **kwargs):\n super(RegressionLoss, self).__init__()\n self.mode = mode\n self.reduction = reduction\n self.loss_weight = loss_weight\n self.loss_kwargs = dict()\n self.norm_loss_list = [\n \"mse_loss\", \"l1_loss\", \"smooth_l1_loss\", \"huber_loss\",\n \"charbonnier_loss\", \"focal_mse_loss\", \"focal_l1_loss\",\n \"balanced_l1_loss\", \"balanced_mse_loss\",\n ]\n self.div_loss_list = [\n \"kl_loss\", \"general_kl_loss\", \"fuzzy_ce_loss\",\n ]\n assert mode in self.norm_loss_list + self.div_loss_list\n\n # loss func\n if self.mode in self.norm_loss_list:\n assert reduction in [None, 'none', 'mean', 'sum']\n if \"focal\" in self.mode:\n self.loss_kwargs = dict(\n alpha = kwargs.get('alpha', 0.2),\n gamma = kwargs.get('gamma', 1.0),\n activate = kwargs.get('activate', 'sigmoid'),\n residual = kwargs.get('residual', False),\n )\n self.criterion = eval(self.mode)\n elif self.mode == \"charbonnier_loss\":\n self.loss_kwargs['eps'] = kwargs.get('eps', 1e-10)\n self.criterion = eval(self.mode)\n elif self.mode == \"balanced_l1_loss\":\n self.loss_kwargs = dict(\n beta = kwargs.get('beta', 1.0),\n alpha = kwargs.get('alpha', 0.5),\n gamma = kwargs.get('gamma', 1.5),\n )\n self.criterion = eval(self.mode)\n elif self.mode == \"balanced_mse_loss\":\n if kwargs.get(\"mode\", \"BMC\") == \"BMC\":\n self.criterion = BMCLoss(\n init_noise_sigma=kwargs.get(\"init_noise_sigma\", 1.)\n )\n else:\n self.criterion = BNILoss(\n init_noise_sigma=kwargs.get(\"init_noise_sigma\", 1.),\n bucket_centers=kwargs.get(\"bucket_centers\", None),\n bucket_weights=kwargs.get(\"bucket_weights\", None),\n )\n else:\n self.criterion = eval(self.mode)\n else:\n assert reduction in [None, 'none', 'mean', 'batchmean', 'sum']\n if self.mode == \"general_kl_loss\":\n self.loss_kwargs['alpha'] = kwargs.get('alpha', 0.1)\n self.criterion = eval(self.mode)\n \n def forward(self,\n pred,\n target,\n weight=None,\n reduction_override=None,\n **kwargs):\n \"\"\"caculate loss\n \n Args:\n pred (tensor): Predicted logits of (N, \\*).\n target (tensor): Groundtruth label of (N, \\*).\n weight (tensor): Sample-wise reweight of (N, \\*) or element-wise reweight\n of (1, \\*). Defaults to None.\n reduction_override (str): Reduction methods.\n \"\"\"\n assert reduction_override in (None, 'none', 'mean', 'batchmean', 'sum',)\n reduction = (\n reduction_override if reduction_override is not None else self.reduction)\n kwargs.update(self.loss_kwargs)\n\n loss_reg = self.loss_weight * self.criterion(\n pred, target, weight=weight, reduction=reduction, **kwargs)\n\n return loss_reg\n"
] | [
[
"torch.einsum",
"torch.nn.BatchNorm1d",
"torch.nn.functional.l1_loss",
"torch.fft.fftn"
],
[
"numpy.save",
"torch.cuda.current_device"
],
[
"torch.chunk",
"torch.flatten",
"torch.cat"
],
[
"torch.nn.functional.kl_div",
"torch.abs",
"torch.sigmoid",
"torch.nn.functional.l1_loss",
"torch.sqrt",
"torch.tensor",
"torch.tanh",
"torch.nn.functional.mse_loss",
"torch.log",
"torch.where",
"torch.arange",
"torch.logsumexp"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
fabiansinz/locker | [
"9ca397d0a9aa747552bc43188b07056b87c6e9f0",
"9ca397d0a9aa747552bc43188b07056b87c6e9f0"
] | [
"scripts/fig3_locking_across_frequencies.py",
"locker/modeling.py"
] | [
"import matplotlib\nmatplotlib.use('Agg')\nfrom matplotlib.collections import PolyCollection\nfrom numpy.fft import fft, fftfreq, fftshift\nfrom locker import mkdir\nfrom locker.analysis import *\nfrom locker.data import *\nfrom scripts.config import params as plot_params, FormatedFigure\n\n\ndef generate_filename(cell, contrast):\n dir = 'figures/figure_locking_across_frequencies/%s/' % (cell['cell_type'],)\n mkdir(dir)\n return dir + '%s_contrast%.2f.pdf' % (cell['cell_id'], contrast)\n\n\ndef gauss(t, m, v):\n return np.exp(-(t - m) ** 2 / 2 / v)\n\n\nclass FigureMechanisms(FormatedFigure):\n def prepare(self):\n sns.set_context('paper')\n sns.set_style('ticks')\n with plt.rc_context(plot_params):\n self.fig = plt.figure(figsize=(7, 5), dpi=400)\n gs = plt.GridSpec(3, 4)\n self.ax = {}\n self.ax['violin'] = self.fig.add_subplot(gs[:3, 3])\n self.ax['spectrum'] = self.fig.add_subplot(gs[:3, :3])\n\n self.gs = gs\n\n @staticmethod\n def format_spectrum(ax):\n ax.set_xlim((0, 1500))\n ax.set_xticks(np.linspace(0, 1500, 7))\n ax.legend(bbox_to_anchor=(1.05, 1), bbox_transform=ax.transAxes, ncol=3, frameon=False)\n sns.despine(ax=ax, left=True, trim=True, offset=0)\n ax.set_yticks([])\n ax.set_ylim((-.5, 9.5))\n ax.set_xlabel('frequency [Hz]')\n ax.text(-0.01, 0.99, 'A', transform=ax.transAxes, fontweight='bold')\n\n @staticmethod\n def format_violin(ax):\n ax.set_xlim((0, 2 * np.pi))\n ax.set_xticks(np.linspace(0, 2 * np.pi, 5))\n ax.set_xticklabels([r'$0$', r'$\\frac{\\pi}{2}$', r'$\\pi$', r'$\\frac{3\\pi}{4}$', r'$2\\pi$'])\n ax.set_ylabel(r'$\\Delta f$ [Hz]')\n ax.set_xlabel('phase')\n for art in ax.get_children():\n if isinstance(art, PolyCollection):\n art.set_edgecolor(None)\n leg = ax.legend(ncol=1, title='PSTH per cycle of', bbox_to_anchor=(1, 0.97), frameon=False)\n\n plt.setp(leg.get_title(), fontsize=leg.get_texts()[0].get_fontsize())\n ax.text(-0.15, 1.01, 'B', transform=ax.transAxes, fontweight='bold', va='top', ha='right')\n sns.despine(ax=ax, trim=True, offset=0)\n\n\n def format_figure(self):\n self.ax['violin'].set_ylim([e / .8 for e in self.ax['spectrum'].get_ylim()])\n for a in self.ax.values():\n a.tick_params(length=3, width=1)\n a.spines['bottom'].set_linewidth(1)\n a.spines['left'].set_linewidth(1)\n\n self.gs.tight_layout(self.fig)\n\n\nif __name__ == \"__main__\":\n f_max = 2000 # Hz\n N = 10\n delta_f = 200\n frequency_restriction = '(delta_f > -319) or (delta_f < -381)'\n runs = Runs()\n for cell in (Cells() & dict(cell_type='p-unit', cell_id=\"2014-12-03-aj\")).fetch(as_dict=True):\n # for cell in (Cells() & dict(cell_type='p-unit')).fetch.as_dict:\n\n unit = cell['cell_type']\n print('Processing', cell['cell_id'])\n\n # for contrast in [5, 10, 20]:\n for contrast in [20]:\n print(\"contrast: %.2f%%\" % (contrast,))\n\n target_trials = SecondOrderSpikeSpectra() * runs & cell & \\\n dict(contrast=contrast, am=0, n_harmonics=0) & frequency_restriction\n if target_trials:\n with FigureMechanisms(filename=generate_filename(cell, contrast=contrast)) as (fig, ax):\n\n # --- plot spectra\n y = [0]\n stim_freq, eod_freq, deltaf_freq = [], [], []\n done = []\n for i, spec in enumerate(sorted(target_trials.fetch(as_dict=True), key=lambda x: x['delta_f'])):\n if spec['delta_f'] in done:\n continue\n else:\n done.append(spec['delta_f'])\n print(u\"\\t\\t\\u0394 f=%.2f\" % spec['delta_f'])\n\n f, v = spec['frequencies'], spec['vector_strengths']\n idx = (f >= 0) & (f <= f_max) & ~np.isnan(v)\n ax['spectrum'].fill_between(f[idx], y[-1] + 0 * f[idx], y[-1] + v[idx], lw=0,\n color='k')\n if i == 0:\n ax['spectrum'].plot([20, 20], [8., 8.5], '-', color='k', lw=2,\n solid_capstyle='butt')\n ax['spectrum'].text(40, 8.15, '0.5 vector strength', fontsize=6)\n y.append(y[-1] + .8)\n stim_freq.append(spec['eod'] + spec['delta_f'])\n deltaf_freq.append(spec['delta_f'])\n eod_freq.append(spec['eod'])\n\n ax['spectrum'].plot(eod_freq, y[:-1], '-', alpha=.25, zorder=-10, lw=4, color=colordict['eod'],\n label='EODf')\n ax['spectrum'].plot(stim_freq, y[:-1], '-', alpha=.25, zorder=-10, lw=4,\n color=colordict['stimulus'],\n label='stimulus')\n ax['spectrum'].plot(np.abs(deltaf_freq), y[:-1], '-', alpha=.25, zorder=-10, lw=4,\n color=colordict['delta_f'],\n label=r'$|\\Delta f|$')\n\n # --- plot locking\n PhaseLockingHistogram().violin_plot(ax['violin'], restrictions=target_trials.proj(),\n palette=[colordict['eod'], colordict['stimulus']])\n ax['violin'].legend().set_visible(False)\n\n",
"import warnings\nfrom pprint import pformat\n\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport pandas as pd\nimport seaborn as sns\nfrom scipy import stats\nfrom scipy.integrate import odeint\nfrom scipy.signal import butter, filtfilt\n\nimport datajoint as dj\nimport pycircstat as circ\nimport datajoint as dj\n\nfrom .utils.modeling import estimate_fundamental, get_best_time_window, get_harm_coeff, \\\n second_order_critical_vector_strength, val_at\nfrom .analysis import TrialAlign\nfrom . import mkdir\nfrom .utils.data import peakdet\nfrom .data import Runs, Cells, EFishes, PaperCells\nfrom scipy import interp\nfrom . import colordict, markerdict\n\nschema = dj.schema('efish_modeling', locals())\n\n\n# =======================================================================================\n\n@schema\nclass NoHarmonics(dj.Lookup):\n definition = \"\"\"\n no_harmonics : int # number of harmonics that are fitted\n \"\"\"\n\n contents = [(8,)]\n\n\n@schema\nclass EODFit(dj.Computed):\n definition = \"\"\"\n ->EFishes\n ->NoHarmonics\n ---\n fundamental : double # fundamental frequency\n \"\"\"\n\n @property\n def key_source(self):\n return EFishes() * NoHarmonics() & (PaperCells() & dict(locking_experiment=1))\n\n def _make_tuples(self, key):\n print('Populating', pformat(key))\n if not Runs() * Runs.GlobalEOD() & key:\n print('Found no entry in Runs() * Runs.GlobalEOD() for key', key)\n return\n dat = (Runs() * Runs.GlobalEOD() & key).fetch(limit=1, as_dict=True)[0] # get some EOD trace\n\n w0 = estimate_fundamental(dat['global_voltage'], dat['samplingrate'], highcut=3000, normalize=.5)\n t, win = get_best_time_window(dat['global_voltage'], dat['samplingrate'], w0, eod_cycles=10)\n\n fundamental = estimate_fundamental(win, dat['samplingrate'], highcut=3000)\n assert abs(fundamental - dat['eod']) < 2, \\\n \"EOD and fundamental estimation are more than 2Hz apart: %.2fHz, %.2fHz\" % (fundamental, dat['eod'])\n harm_coeff = get_harm_coeff(t, win, fundamental, key['no_harmonics'])\n\n self.insert1(dict(key, fundamental=fundamental))\n for key['harmonic'], (key['sin'], key['cos']) in enumerate(harm_coeff):\n EODFit.Harmonic().insert1(key)\n\n class Harmonic(dj.Part):\n definition = \"\"\"\n # sin and cos coefficient for harmonics\n -> EODFit\n harmonic : int # 0th is fundamental, 1st is frist harmonic and so on\n ---\n sin : double # coefficient for sin\n cos : double # coefficient for cos\n \"\"\"\n\n def generate_eod(self, t, key):\n w = (self & key).fetch1('fundamental')\n\n ret = 0 * t\n VR = w * 2. * np.pi\n for i, coeff_sin, coeff_cos in zip(*(self.Harmonic() & key).fetch('harmonic', 'sin', 'cos')):\n V1 = np.sin(t * (i + 1) * VR)\n V2 = np.cos(t * (i + 1) * VR)\n V1 = V1 / np.sqrt(sum(V1 ** 2.))\n V2 = V2 / np.sqrt(sum(V2 ** 2.))\n\n VS = coeff_sin * V1\n VC = coeff_cos * V2\n ret = ret + VS + VC\n return ret\n\n def eod_func(self, key, fundamental=None, harmonics=None):\n harm_coeff = np.vstack((EODFit.Harmonic() & key).fetch('sin', 'cos', order_by='harmonic')).T\n if harmonics is not None:\n harm_coeff = harm_coeff[:harmonics + 1, :]\n if fundamental is None:\n fundamental = (self & key).fetch1('fundamental')\n\n A = np.sqrt(np.sum(harm_coeff[0, :] ** 2))\n\n def ret_func(t):\n vr = fundamental * 2 * np.pi\n ret = 0 * t\n for i, (coeff_sin, coeff_cos) in enumerate(harm_coeff / A):\n ret += coeff_sin * np.sin(t * (i + 1) * vr)\n ret += coeff_cos * np.cos(t * (i + 1) * vr)\n return ret\n\n return ret_func\n\n def plot_eods(self, fundamental=800, outdir='./'):\n t = np.linspace(0, 10 / 800, 200)\n for key in self.fetch.keys():\n print('Plotting', key)\n f = self.eod_func(key, fundamental=fundamental)\n fig, ax = plt.subplots()\n ax.plot(t, f(t), '-k')\n ax.set_xlabel('time [s]')\n ax.set_ylabel('EOD')\n fig.savefig(outdir + '/{fish_id}.png'.format(**key))\n plt.close(fig)\n\n\n@schema\nclass LIFPUnit(dj.Computed):\n definition = \"\"\"\n # parameters for a LIF P-Unit simulation\n\n id : varchar(100) # non-double unique identifier\n ->EODFit\n ---\n zeta : double\n resonant_freq : double # resonant frequency of the osciallator in Hz\n tau : double\n gain : double\n offset : double\n noise_sd : double\n threshold : double\n reset : double\n lif_tau : double\n \"\"\"\n\n def _make_tuples(self, key):\n eod = (EODFit() & key).fetch1('fundamental')\n self.insert1(dict(key, id='nwgimproved',\n zeta=0.2,\n tau=0.002,\n resonant_freq=eod,\n gain=70,\n offset=9,\n noise_sd=30,\n threshold=14.,\n reset=0.,\n lif_tau=0.001\n ))\n\n def simulate(self, key, n, t, stimulus, y0=None):\n \"\"\"\n Samples spikes from leaky integrate and fire neuron with id==settings_name and time t.\n Returns n trials\n\n :param key: key that uniquely identifies a setting\n :param n: number of trials\n :param t: time array\n :param stimulus: stimulus as a function of time (function handle)\n :return: spike times\n \"\"\"\n\n # --- get parameters from database\n zeta, tau, gain, wr, lif_tau, offset, threshold, reset, noisesd = (self & key).fetch1(\n 'zeta', 'tau', 'gain', 'resonant_freq', 'lif_tau', 'offset', 'threshold', 'reset', 'noise_sd')\n wr *= 2 * np.pi\n w0 = wr / np.sqrt(1 - 2 * zeta ** 2)\n Zm = np.sqrt((2 * w0 * zeta) ** 2 + (wr ** 2 - w0 ** 2) ** 2 / wr ** 2)\n alpha = wr * Zm\n\n # --- set initial values if not given\n if y0 is None:\n y0 = np.zeros(3)\n\n # --- differential equations for resonantor\n def _d(y, t):\n return np.array([\n y[1],\n stimulus(t) - 2 * zeta * w0 * y[1] - w0 ** 2 * y[0],\n (-y[2] + gain * alpha * max(y[0], 0)) / tau\n ])\n\n # --- simulate LIF\n dt = t[1] - t[0]\n\n Vin = odeint(lambda y, tt: _d(y, tt), y0, t).T[2]\n Vin -= offset\n\n Vout = np.zeros(n)\n\n ret = [list() for _ in range(n)]\n\n sdB = np.sqrt(dt) * noisesd\n\n for i, T in enumerate(t):\n Vout += (-Vout + Vin[i]) * dt / lif_tau + np.random.randn(n) * sdB\n idx = Vout > threshold\n for j in np.where(idx)[0]:\n ret[j].append(T)\n Vout[idx] = reset\n\n return tuple(np.asarray(e) for e in ret), Vin\n\n@schema\nclass HarmonicStimulation(dj.Lookup):\n definition = \"\"\"\n harmonic_stimulation : smallint # 0 if only fundamental was used for stimulation and 1 if all harmonics were used\n ---\n \"\"\"\n\n contents = [(0,),(1,)]\n\n@schema\nclass PUnitSimulations(dj.Computed):\n definition = \"\"\"\n # LIF simulations\n\n ->LIFPUnit\n ->Runs\n -> HarmonicStimulation\n ---\n dt : double # time resolution for differential equation\n duration : double # duration of trial in seconds\n \"\"\"\n\n @property\n def key_source(self):\n return LIFPUnit() * Runs() * Cells()*HarmonicStimulation() & dict(am=0, n_harmonics=0, cell_type='p-unit', contrast=20)\n\n def _make_tuples(self, key):\n print('Populating',dict(key))\n dt, duration = 0.000005, 1\n trials = 50\n ikey = dict(key)\n ikey['dt'] = dt\n ikey['duration'] = duration\n\n eod = (EODFit() & key).fetch1('fundamental')\n\n delta_f = (Runs() & key).fetch1('delta_f')\n other_eod = eod + delta_f\n\n t = np.arange(0, duration, dt)\n\n baseline = EODFit().eod_func(key)\n # 198 = '2014lepto0021'\n if key['harmonic_stimulation'] == 1:\n foreign_eod = EODFit().eod_func(dict(fish_id=198), fundamental=other_eod)\n else:\n foreign_eod = EODFit().eod_func(dict(fish_id=198), fundamental=other_eod, harmonics=0)\n\n bl = baseline(t)\n foreign = foreign_eod(t)\n fac = (bl.max() - bl.min()) * 0.2 / (foreign.max() - foreign.min())\n stimulus = lambda tt: baseline(tt) + fac * foreign_eod(tt)\n\n spikes_base, membran_base = LIFPUnit().simulate(key, trials, t, baseline)\n spikes_stim, membran_stim = LIFPUnit().simulate(key, trials, t, stimulus)\n\n n = int(duration / dt)\n w = np.fft.fftfreq(n, d=dt)\n w = w[(w >= 0) & (w <= 4000)]\n vs = np.mean([circ.event_series.direct_vector_strength_spectrum(sp, w) for sp in spikes_stim], axis=0)\n ci = second_order_critical_vector_strength(spikes_stim)\n\n self.insert1(ikey)\n\n for i, (bsp, ssp) in enumerate(zip(spikes_base, spikes_stim)):\n PUnitSimulations.BaselineSpikes().insert1(dict(key, trial_idx=i, times=bsp))\n PUnitSimulations.StimulusSpikes().insert1(dict(key, trial_idx=i, times=ssp))\n\n PUnitSimulations.BaselineMembranePotential().insert1(dict(key, potential=membran_base))\n PUnitSimulations.StimulusMembranePotential().insert1(dict(key, potential=membran_stim))\n PUnitSimulations.Baseline().insert1(dict(key, signal=bl))\n PUnitSimulations.Stimulus().insert1(dict(key, signal=stimulus(t)))\n PUnitSimulations.StimulusSecondOrderSpectrum().insert1(dict(key, spectrum=vs, ci=ci, freq=w))\n\n class BaselineSpikes(dj.Part):\n definition = \"\"\"\n # holds the simulated spiketimes\n\n ->PUnitSimulations\n trial_idx : int # index of trial\n ---\n times : longblob # spike times\n \"\"\"\n\n class StimulusSpikes(dj.Part):\n definition = \"\"\"\n # holds the simulated spiketimes\n\n ->PUnitSimulations\n trial_idx : int # index of trial\n ---\n times : longblob # spike times\n \"\"\"\n\n class StimulusSecondOrderSpectrum(dj.Part):\n definition = \"\"\"\n # holds the vector strength spectrum of simulated spiketimes\n\n ->PUnitSimulations\n ---\n freq : longblob # frequencies at which the vector strengths are computed\n spectrum : longblob # spike times\n ci : double # (1-0.001) confidence interval\n \"\"\"\n\n class BaselineMembranePotential(dj.Part):\n definition = \"\"\"\n # holds the simulated membrane potential\n\n ->PUnitSimulations\n ---\n potential : longblob # membrane potential\n \"\"\"\n\n class StimulusMembranePotential(dj.Part):\n definition = \"\"\"\n # holds the simulated membrane potential\n\n ->PUnitSimulations\n ---\n potential : longblob # membrane potential\n \"\"\"\n\n class Baseline(dj.Part):\n definition = \"\"\"\n # holds the simulated membrane potential\n\n ->PUnitSimulations\n ---\n signal : longblob # membrane potential\n \"\"\"\n\n class Stimulus(dj.Part):\n definition = \"\"\"\n # holds the simulated membrane potential\n\n ->PUnitSimulations\n ---\n signal : longblob # membrane potential\n \"\"\"\n\n def axes_font_size(self, ax):\n xtl = ax.xaxis.get_ticklabels()\n ytl = ax.yaxis.get_ticklabels()\n if len(xtl) > 0:\n return xtl[0].get_fontsize()\n elif len(ytl) > 0:\n return ytl[0].get_fontsize()\n else:\n raise ValueError('No xtick or ytick labels found')\n\n def plot_stimulus_spectrum(self, key, ax, f_max=2000):\n dt = (self & key).fetch1('dt')\n eod = (EODFit() & key).fetch1('fundamental')\n fstim = eod + (Runs() & key).fetch1('delta_f')\n\n stimulus_signal = (PUnitSimulations.Stimulus() & key).fetch1('signal')\n w = np.fft.fftfreq(len(stimulus_signal), d=dt)\n idx = (w > 0) & (w < f_max)\n\n S = np.abs(np.fft.fft(stimulus_signal))\n S /= S.max()\n\n ax.fill_between(w[idx], 0 * w[idx], S[idx], color='k')\n\n # --- get parameters from database\n zeta, tau, gain, wr, lif_tau, offset, threshold, reset, noisesd = (LIFPUnit() & key).fetch1(\n 'zeta', 'tau', 'gain', 'resonant_freq', 'lif_tau', 'offset', 'threshold', 'reset', 'noise_sd')\n wr *= 2 * np.pi\n w0 = wr / np.sqrt(1 - 2 * zeta ** 2)\n\n w2 = w * 2 * np.pi\n Zm = np.sqrt((2 * w0 * zeta) ** 2 + (w2 ** 2 - w0 ** 2) ** 2 / w2 ** 2)\n dho = 1. / (w2[idx] * Zm[idx])\n\n ax.plot(w[idx], dho / np.nanmax(dho), '--', dashes=(2, 2), color='gray', label='harmonic oscillator', lw=1,\n zorder=-10)\n lp = 1. / np.sqrt(w2[idx] ** 2 * tau ** 2 + 1)\n ax.plot(w[idx], lp / lp.max(), '--', color='gray', label='low pass filter', lw=1, zorder=-10)\n\n # tmp = lp * dho\n # tmp /=tmp.max()\n # ax.plot(w[idx], tmp, '-', color='gray', label=' filter product', lw=1, zorder=-10)\n fonsize=self.axes_font_size(ax)\n ax.text(eod, 1.1, r'EODf', rotation=0, horizontalalignment='center',\n verticalalignment='bottom', fontsize=fonsize)\n ax.plot(eod, val_at(w[idx], S[idx], eod), marker=markerdict['eod'], color=colordict['eod'])\n ax.text(eod * 2, 0.35, r'2 EODf', rotation=0, horizontalalignment='center',\n verticalalignment='bottom', fontsize=fonsize)\n ax.plot(eod * 2, val_at(w[idx], S[idx],2* eod), marker=markerdict['eod'], color=colordict['eod'])\n\n ax.text(fstim, 0.27, r'$f_s$', rotation=0, horizontalalignment='center',\n verticalalignment='bottom', fontsize=fonsize)\n ax.plot(fstim, val_at(w[idx], S[idx],fstim), marker=markerdict['stimulus'], color=colordict['stimulus'])\n ax.set_ylim((0, 2))\n ax.set_yticks([])\n ax.set_ylabel('amplitude spectrum of\\nstimulus s(t)')\n ax.legend(loc='upper right', ncol=2)\n\n ax.set_xlim((0, f_max))\n\n def plot_membrane_potential_spectrum(self, key, ax, f_max=2000):\n dt = (self & key).fetch1('dt')\n eod = (EODFit() & key).fetch1('fundamental')\n fstim = eod + (Runs() & key).fetch1('delta_f')\n\n membrane_potential = (PUnitSimulations.StimulusMembranePotential() & key).fetch1('potential')\n w = np.fft.fftfreq(len(membrane_potential), d=dt)\n idx = (w > 0) & (w < f_max)\n\n # fig, ax = plt.subplots()\n # stimulus_signal = (PUnitSimulations.Stimulus() & key).fetch1['signal']\n # print(stimulus_signal.shape, membrane_potential.shape)\n # ax.plot(w[idx],np.abs(np.fft.fft(membrane_potential))[idx], '--b')\n # ax.plot(w[idx],np.abs(np.fft.fft(stimulus_signal))[idx], '-r')\n # # ax.twinx().plot(stimulus_signal[5000:8000],'-r')\n # plt.show()\n\n M = np.abs(np.fft.fft(membrane_potential))\n M /= M[idx].max()\n ax.fill_between(w[idx], 0 * w[idx], M[idx], color='k')\n ax.set_ylim((0, 1.5))\n ax.set_xlim([0, 2000])\n fonsize=self.axes_font_size(ax)\n ax.text(fstim - eod, 0.47, r'$\\Delta f$', rotation=0, horizontalalignment='center',\n verticalalignment='bottom', fontsize=fonsize)\n\n ax.plot(fstim - eod, val_at(w[idx], M[idx], np.abs(fstim - eod)),\n marker=markerdict['delta_f'], color=colordict['delta_f'])\n\n ax.text(eod + fstim, 0.07, r'EODf + $f_s$' % (eod + fstim), rotation=0, horizontalalignment='center',\n verticalalignment='bottom', fontsize=fonsize)\n ax.set_yticks([])\n ax.set_ylabel('amplitude spectrum of\\nLIF input z(t)')\n\n def plot_spike_spectrum(self, key, ax, f_max=2000):\n df = (Runs() & key).fetch1('delta_f')\n eod = (EODFit() & key).fetch1('fundamental')\n eod2 = eod + df\n eod3 = eod - df\n\n w, vs, ci = (PUnitSimulations.StimulusSecondOrderSpectrum() & key).fetch1('freq', 'spectrum', 'ci')\n stimulus_spikes = (PUnitSimulations.StimulusSpikes() & key).fetch('times')\n idx = (w > 0) & (w < f_max)\n\n ax.set_ylim((0, .8))\n ax.set_xlim([0, 2000])\n ax.set_yticks(np.arange(0, 1, .4))\n fonsize=self.axes_font_size(ax)\n ax.fill_between(w[idx], 0 * w[idx], vs[idx], color='k')\n ci = second_order_critical_vector_strength(stimulus_spikes)\n ax.fill_between(w[idx], 0 * w[idx], 0 * w[idx] + ci, color='silver', alpha=.5)\n ax.text(eod3, 0.27, r'EODf - $\\Delta f$' % eod3, rotation=0, horizontalalignment='center',\n verticalalignment='bottom', fontsize=fonsize)\n ax.plot(eod3, val_at(w[idx], vs[idx], eod3),\n marker=markerdict['combinations'], color=colordict['combinations'])\n ax.set_ylabel('vector strength')\n\n def plot_isi(self, key, ax):\n eod = (EODFit() & key).fetch1('fundamental')\n period = 1 / eod\n baseline_spikes = (PUnitSimulations.BaselineSpikes() & key).fetch('times')\n isi = np.hstack((np.diff(r) for r in baseline_spikes))\n ax.hist(isi, bins=320, lw=0, color=sns.xkcd_rgb['charcoal grey'])\n ax.set_xlim((0, 15 * period))\n ax.set_xticks(np.arange(0, 20, 5) * period)\n ax.set_xticklabels(np.arange(0, 20, 5))\n ax.set_label('time [EOD cycles]')\n\n\n# @schema\n# class RandomTrials(dj.Lookup):\n# definition = \"\"\"\n# n_total : int # total number of trials\n# repeat_id : int # repeat number\n# ---\n#\n# \"\"\"\n#\n# class TrialSet(dj.Part):\n# definition = \"\"\"\n# ->RandomTrials\n# new_trial_id : int # index of the particular trial\n# ->Runs.SpikeTimes\n# ---\n# \"\"\"\n#\n# class PhaseSet(dj.Part):\n# definition = \"\"\"\n# ->RandomTrials\n# new_trial_id : int # index of the phase sample\n# ---\n# ->EFishes\n# \"\"\"\n#\n# def _prepare(self):\n# lens = [len(self & dict(n_total=ntot)) == 10 for ntot in (100,)]\n# n_total = 100\n# if not np.all(lens):\n# # data = (Runs() * Runs.SpikeTimes() & dict(contrast=20, cell_id=\"2014-12-03-ad\",\n# # delta_f=-300)).project().fetch.as_dict()\n# data = (Runs() * Runs.SpikeTimes() & dict(contrast=20, cell_id=\"2014-06-06-ak\",\n# delta_f=300)).project().fetch.as_dict()\n# print('Using ', len(data), 'trials')\n# data = list(sorted(data, key=lambda x: x['trial_id']))\n# n = len(data)\n#\n# df = pd.DataFrame(CenteredPUnitPhases().fetch[dj.key])\n# ts = self.TrialSet()\n# ps = self.PhaseSet()\n#\n# for repeat_id in range(10):\n# key = dict(n_total=n_total, repeat_id=repeat_id)\n# self.insert1(key, skip_duplicates=True)\n# for new_trial_id, trial_id in enumerate(np.random.randint(n, size=n_total)):\n# key['new_trial_id'] = new_trial_id\n# key.update(data[trial_id])\n# ts.insert1(key)\n#\n# key = dict(n_total=n_total, repeat_id=repeat_id)\n# for new_trial_id, ix in enumerate(np.random.randint(len(df), size=n_total)):\n# key['new_trial_id'] = new_trial_id\n# key.update(df.iloc[ix].to_dict())\n# ps.insert1(key)\n#\n# def load_spikes(self, key, centered=True, plot=False):\n# if centered:\n# Phases = (RandomTrials.PhaseSet() * CenteredPUnitPhases()).project('phase', phase_cell='cell_id')\n# else:\n# Phases = (RandomTrials.PhaseSet() * UncenteredPUnitPhases()).project('phase', phase_cell='cell_id')\n# trials = Runs.SpikeTimes() * RandomTrials.TrialSet() * Phases * TrialAlign() & key\n#\n# times, phase, align_times = trials.fetch['times', 'phase', 't0']\n#\n# dt = 1. / (Runs() & trials).fetch1['samplingrate']\n#\n# eod, duration = (Runs() & trials).fetch1['eod', 'duration']\n# rad2period = 1 / 2 / np.pi / eod\n# # get spikes, convert to s, align to EOD, add bootstrapped phase\n# print('Phase std', circ.std(phase), 'Centered', centered)\n#\n# if plot:\n# figdir = 'figures/sanity/pyr_lif_stimulus/'\n# mkdir(figdir)\n# fig, ax = plt.subplots(2, 1, sharex=True)\n#\n# spikes = [s / 1000 - t0 for s, t0 in zip(times, align_times)]\n# for i, s in enumerate(spikes):\n# ax[0].plot(s, 0 * s + i, '.k', ms=1)\n# ax[0].set_title('without phase variation')\n# spikes = [s / 1000 - t0 + ph * rad2period for s, t0, ph in zip(times, align_times, phase)]\n# for i, s in enumerate(spikes):\n# ax[1].plot(s, 0 * s + i, '.k', ms=1)\n# ax[1].set_title('with phase variation')\n# fig.savefig(figdir +\n# 'alignments_{n_total}_{pyr_simul_id}_{repeat_id}_{centered}.pdf'.format(centered=centered, **key))\n#\n#\n# spikes = [s / 1000 - t0 + ph * rad2period for s, t0, ph in zip(times, align_times, phase)]\n#\n# return spikes, dt, eod, duration\n\n\n# @schema\n# class PyramidalSimulationParameters(dj.Lookup):\n# definition = \"\"\"\n# pyr_simul_id : tinyint\n# ---\n# tau_synapse : double # time constant of the synapse\n# tau_neuron : double # time constant of the lif\n# n : int # how many trials to simulate\n# noisesd : double # noise standard deviation\n# amplitude : double # multiplicative factor on the input\n# offset : double # additive factor on the input\n# threshold : double # LIF threshold\n# reset : double # reset potential\n# \"\"\"\n#\n# contents = [\n# dict(pyr_simul_id=0, tau_synapse=0.001, tau_neuron=0.01, n=50, noisesd=35,\n# amplitude=1.8, threshold=15, reset=0, offset=-30),\n# ]\n\n\n# @schema\n# class PyramidalLIF(dj.Computed):\n# definition = \"\"\"\n# ->RandomTrials\n# ->PyramidalSimulationParameters\n# centered : bool # whether the phases got centered per fish\n# ---\n#\n# \"\"\"\n#\n# class SpikeTimes(dj.Part):\n# definition = \"\"\"\n# ->PyramidalLIF\n# simul_trial_id : smallint # trial number\n# ---\n# times : longblob # spike times in s\n# \"\"\"\n#\n# def _make_tuples(self, key):\n# key0 = dict(key)\n# figdir = 'figures/sanity/PyrLIF/'\n# mkdir(figdir)\n# for centered in [True, False]:\n# # load spike trains for randomly selected trials\n# data, dt, eod, duration = RandomTrials().load_spikes(key0, centered=centered)\n# key = dict(key0, centered=centered)\n# print('EOD',eod,'stim',eod-300)\n#\n# eod_period = 1 / eod\n#\n# # get parameters for simulation\n# params = (PyramidalSimulationParameters() & key).fetch1()\n# params.pop('pyr_simul_id')\n# print('Parameters', key)\n#\n# # plot histogram of jittered data\n# fig, ax = plt.subplots()\n# ax.hist(np.hstack(data) % (1 / eod), bins=100)\n# fig.savefig(figdir + 'punitinput_{repeat_id}_{centered}.png'.format(**key))\n# plt.close(fig)\n#\n# # convolve with exponential filter\n# tau_s = params.pop('tau_synapse')\n# bins = np.arange(0, duration + dt, dt)\n# t = np.arange(0, 10 * tau_s, dt)\n# h = np.exp(-np.abs(t) / tau_s)\n# trials = np.vstack([np.convolve(np.histogram(sp, bins=bins)[0], h, 'full') for sp in data])[:, :-len(h) + 1]\n#\n#\n# fig, ax = plt.subplots()\n# inp = trials.sum(axis=0)\n# w = np.fft.fftshift(np.fft.fftfreq(len(inp), dt))\n# a = np.fft.fftshift(np.abs(np.fft.fft(inp)))\n# idx = (w >= -1200) & (w <= 1200)\n# ax.plot(w[idx], a[idx])\n# ax.set_xticks([eod,eod+300])\n# fig.savefig(figdir + 'pyr_spectrum_{repeat_id}_{centered}.png'.format(**key))\n# plt.close(fig)\n#\n# # # simulate neuron\n# # t = np.arange(0, duration, dt)\n# # ret, V = simple_lif(t, trials.sum(axis=0),\n# # **params) # TODO mean would be more elegent than sum\n# # isi = [np.diff(r) for r in ret]\n# # # fig, ax = plt.subplots()\n# # # ax.hist(np.hstack(isi), bins=100)\n# # # ax.set_xticks(eod_period * np.arange(0, 50, 10))\n# # # ax.set_xticklabels(np.arange(0, 50, 10))\n# # # fig.savefig(figdir + 'pyr_isi_{repeat_id}_{centered}.png'.format(**key))\n# # # plt.close(fig)\n# #\n# # sisi = np.hstack(isi)\n# # print('Firing rates (min, max, avg)', (1 / sisi).min(), (1 / sisi).max(), np.mean([len(r) for r in ret]))\n# #\n# # self.insert1(key)\n# # st = self.SpikeTimes()\n# # for i, trial in enumerate(ret):\n# # key['simul_trial_id'] = i\n# # key['times'] = np.asarray(trial)\n# # st.insert1(key)\n#\n#\n\n# @schema\n# class LIFStimulusLocking(dj.Computed):\n# definition = \"\"\"\n# -> PyramidalLIF # each run has a spectrum\n# ---\n# stimulus_frequency : float # stimulus frequency\n# vector_strength : float # vector strength at the stimulus frequency\n# \"\"\"\n#\n# def _make_tuples(self, key):\n# key = dict(key)\n# trials = PyramidalLIF.SpikeTimes() & key\n# aggregated_spikes = np.hstack(trials.fetch['times'])\n#\n#\n# # compute stimulus frequency\n# delta_f, eod = np.unique((Runs() * RandomTrials() * RandomTrials.TrialSet() & key).fetch['delta_f','eod'])\n# stim_freq = eod + delta_f\n# aggregated_spikes %= 1 / stim_freq\n#\n# # with sns.axes_style('whitegrid'):\n# # fig, ax = plt.subplots()\n# # for i, s in enumerate(trials.fetch['times']):\n# # ax.scatter(s, 0*s+i)\n# # ax.set_title('centered = {centered}'.format(**key))\n# # plt.show()\n# # plt.close(fig)\n#\n#\n# # plt.hist(aggregated_spikes * stim_freq * 2 * np.pi, bins=100)\n# # plt.title('centered={centered}'.format(**key))\n# # plt.show()\n# key['vector_strength'] = circ.vector_strength(aggregated_spikes * stim_freq * 2 * np.pi)\n# key['stimulus_frequency'] = stim_freq\n# self.insert1(key)\n\n# #\n# # @schema\n# # class LIFFirstOrderSpikeSpectra(dj.Computed):\n# # definition = \"\"\"\n# # # table that holds 1st order vector strength spectra\n# #\n# # -> PyramidalLIF # each run has a spectrum\n# #\n# # ---\n# #\n# # frequencies : longblob # frequencies at which the spectra are computed\n# # vector_strengths : longblob # vector strengths at those frequencies\n# # critical_value : float # critical value for significance with alpha=0.001\n# # \"\"\"\n# #\n# # def _make_tuples(self, key):\n# # print('Processing', key)\n# #\n# # trials = PyramidalLIF.SpikeTimes() & key\n# # samplingrate = (Runs() & RandomTrials.TrialSet() * PyramidalLIF()).fetch1['samplingrate']\n# # aggregated_spikes = np.hstack(trials.fetch['times'])\n# #\n# # key['frequencies'], key['vector_strengths'], key['critical_value'] = \\\n# # compute_1st_order_spectrum(aggregated_spikes, samplingrate, alpha=0.001)\n# # vs = key['vector_strengths']\n# # vs[np.isnan(vs)] = 0\n# # self.insert1(key)\n# #\n# # def plot_avg_spectrum(self, ax, centered, f_max=2000):\n# # print(self & dict(centered=centered))\n# # freqs, vs = (self & dict(centered=centered)).fetch['frequencies', 'vector_strengths']\n# # f = np.hstack(freqs)\n# # idx = np.argsort(f)\n# # f = f[idx]\n# #\n# # v = [interp(f, fr, v) for fr, v in zip(freqs, vs)]\n# # # vm = np.mean(v, axis=0)\n# # # vs = np.std(v, axis=0)\n# # vm = vs[0]\n# # vs = 0*vs[0]\n# # f = freqs[0]\n# #\n# # idx = (f >=0) & (f <= f_max)\n# # f = f[idx]\n# # vm = vm[idx]\n# # vs = vs[idx]\n# # ax.fill_between(f, vm-vs, vm+vs, color='silver')\n# # ax.plot(f, vm, '-k')\n# # #----------------------------------\n# # # TODO: Remove this later\n# # from IPython import embed\n# # embed()\n# # # exit()\n# # #----------------------------------\n#\n#\n#\n#\n# def simple_lif(t, I, n=10, offset=0, amplitude=1, noisesd=30, threshold=15, reset=0, tau_neuron=0.01):\n# dt = t[1] - t[0]\n#\n# I = amplitude * I + offset\n#\n# Vout = np.ones(n) * reset\n#\n# ret = [list() for _ in range(n)]\n#\n# sdB = np.sqrt(dt) * noisesd\n# V = np.zeros((n, len(I)))\n# for i, t_step in enumerate(t):\n# Vout += (-Vout + I[i]) * dt / tau_neuron + np.random.randn(n) * sdB\n# idx = Vout > threshold\n# for j in np.where(idx)[0]:\n# ret[j].append(t_step)\n# Vout[idx] = reset\n# V[:, i] = Vout\n# return ret, V\n#\n"
] | [
[
"matplotlib.use"
],
[
"numpy.nanmax",
"numpy.sqrt",
"numpy.linspace",
"numpy.fft.fft",
"numpy.abs",
"numpy.arange",
"numpy.asarray",
"numpy.cos",
"matplotlib.pyplot.subplots",
"numpy.sin",
"numpy.where",
"numpy.diff",
"matplotlib.pyplot.close",
"numpy.fft.fftfreq",
"numpy.random.randn",
"numpy.zeros",
"numpy.sum"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
thsis/NIS18 | [
"1f2a7be1ab209fa7c0a25cb8eace744336b07c1f"
] | [
"tests/tests_helpers.py"
] | [
"import numpy as np\nfrom algorithms import helpers\n\n\ndef test_QR(Ntests):\n passed = 0\n critical = 0\n for _ in range(Ntests):\n try:\n n = np.random.randint(2, 11)\n X = np.random.uniform(low=0.0,\n high=100.0,\n size=(n, n))\n Q, R = helpers.qr_factorize(X)\n assert all(np.isclose(Q.dot(R), X).flatten())\n passed += 1\n except AssertionError:\n print(\"AssertionError with:\")\n print(X)\n continue\n except Exception:\n print(\"Other Error with:\")\n print(X)\n critical += 1\n\n print(\"Test Results:\")\n print(\"Passed {} of {} Tests.\".format(passed, Ntests))\n print(\"Failed {} tests.\".format(Ntests-passed-critical))\n print(\"{} tests failed critically\".format(critical))\n if passed == Ntests:\n return True\n else:\n return False\n\n\nassert test_QR(1000)\n"
] | [
[
"numpy.random.uniform",
"numpy.random.randint"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
starasteh/DeepLearning_from_scratch | [
"6ed4685e4da57ad5ea51edf84010f2cc9725a2ba"
] | [
"Layers/LSTM.py"
] | [
"'''\nCreated on January 2020.\n\n@author: Soroosh Tayebi Arasteh <[email protected]>\nhttps://github.com/tayebiarasteh/\n'''\n\nfrom Layers.Base import *\nimport numpy as np\nimport pdb\nfrom Layers import Sigmoid, FullyConnected, TanH\nimport copy\n\n\nclass LSTM(base_layer):\n def __init__(self, input_size, hidden_size, output_size):\n '''\n :input_size: denotes the dimension of the input vector\n :hidden_size: denotes the dimension of the hidden state.\n '''\n super().__init__()\n self.input_size = input_size\n self.hidden_size = hidden_size\n self.output_size = output_size\n self.hidden_state = np.zeros((self.hidden_size))\n self.cell_state = np.zeros((self.hidden_size))\n\n # Sets the boolean state representing whether the RNN\n # regards subsequent sequences as a belonging to the same long sequence.\n self._memorize = False\n\n self._optimizer = None\n self._gradient_weights = 0\n\n # The weights are defined as the weights which are involved in calculating the\n # hidden state as a stacked tensor. E.g. if the hidden state is computed with\n # a single Fully Connected layer, which receives a stack of the hidden state\n # and the input tensor, the weights of this particular Fully Connected Layer,\n # are the weights considered to be weights for the whole class.\n self._weights = None\n\n self.sigmoid1 = Sigmoid.Sigmoid()\n self.sigmoid2 = Sigmoid.Sigmoid()\n self.sigmoid3 = Sigmoid.Sigmoid()\n self.sigmoid4 = Sigmoid.Sigmoid()\n self.tanh1 = TanH.TanH()\n self.tanh2 = TanH.TanH()\n self.fully_middle = FullyConnected.FullyConnected(input_size=input_size + hidden_size ,\n output_size=4 * hidden_size)\n self.fully_out = FullyConnected.FullyConnected(input_size=hidden_size, output_size=output_size)\n\n\n def forward(self, input_tensor):\n output_tensor = np.zeros((input_tensor.shape[0], self.output_size))\n\n # activations and inputs for the backward\n self.o = []\n self.i = []\n self.f = []\n self.C_tilda = []\n self.cell_state_b = []\n self.hidden_state_b = []\n self.tanh2_out = []\n self.fully_middle_input = []\n\n if self._memorize == False:\n self.hidden_state = np.zeros((self.hidden_size))\n self.cell_state = np.zeros((self.hidden_size))\n\n self.cell_state_b.append(self.cell_state)\n self.hidden_state_b.append(np.zeros((self.hidden_size + 1)))\n\n # giving inputs sequentially\n for t, batch in enumerate(input_tensor):\n # Concatenation of input and previous hidden state\n X_tilda = np.concatenate([self.hidden_state, batch])\n\n # first fully connected layer\n fully_middle_out = self.fully_middle.forward(X_tilda)\n self.fully_middle_input.append((self.fully_middle.input_tensor))\n\n '''deconcatenating to 4 vectors'''\n # Calculate forget gate\n f = self.sigmoid1.forward(fully_middle_out[:fully_middle_out.shape[0]//4])\n self.f.append(f)\n\n # Calculate input gate\n i = self.sigmoid2.forward(fully_middle_out[fully_middle_out.shape[0]//4:fully_middle_out.shape[0]//2])\n self.i.append(i)\n\n # Calculate candidate\n C_tilda = self.tanh1.forward(fully_middle_out[fully_middle_out.shape[0]//2: 3*fully_middle_out.shape[0]//4])\n self.C_tilda.append(C_tilda)\n\n # Calculate memory state\n self.cell_state = f * self.cell_state + i * C_tilda\n self.cell_state_b.append(self.cell_state)\n\n # Calculate output gate\n o = self.sigmoid3.forward(fully_middle_out[3*fully_middle_out.shape[0]//4:])\n self.o.append(o)\n\n # tanh2 output\n tanh2_out = self.tanh2.forward(self.cell_state)\n self.tanh2_out.append(tanh2_out)\n\n # Calculate hidden state\n self.hidden_state = o * tanh2_out\n\n # Calculate logits\n y = self.fully_out.forward(self.hidden_state)\n self.hidden_state_b.append(self.fully_out.input_tensor)\n y = self.sigmoid4.forward(y)\n output_tensor[t] = y\n\n self.output_tensor = output_tensor\n return output_tensor\n\n\n\n def backward(self, error_tensor):\n gradient_input = np.zeros((error_tensor.shape[0], self.input_size))\n\n # initializing the hidden and cell state gradients\n gradient_hidden = np.zeros((error_tensor.shape[0] + 1, self.hidden_size))\n gradient_cell = np.zeros((error_tensor.shape[0] + 1, self.hidden_size))\n gradient_weights_out = 0\n gradient_weights_middle = 0\n\n # giving inputs sequentially\n for t in reversed(range(len(error_tensor))):\n\n # gradient of output w.r.t input\n self.sigmoid4.activation = self.output_tensor[t]\n gradient_out_wrt_in = self.sigmoid4.backward(np.copy(error_tensor)[t])\n self.fully_out.input_tensor = self.hidden_state_b[t]\n gradient_out_wrt_in = self.fully_out.backward(gradient_out_wrt_in)\n gradient_weights_out += self.fully_out.gradient_weights\n\n # gradient summing\n out_hidden = gradient_hidden[t] + gradient_out_wrt_in\n\n # gradient output gate\n o_gradient = np.copy(out_hidden) * self.tanh2_out[t]\n self.sigmoid3.activation = self.o[t]\n o_gradient = self.sigmoid3.backward(o_gradient)\n\n # gradient tanh2\n gradient_out_wrt_in_cell = np.copy(out_hidden) * self.o[t]\n self.tanh2.activation = self.tanh2_out[t]\n gradient_out_wrt_in_cell = self.tanh2.backward(gradient_out_wrt_in_cell)\n\n # gradient summing\n out_cell = gradient_out_wrt_in_cell + gradient_cell[t + 1]\n\n '''gradient of the summation'''\n # gradient candidate\n C_tilda_gradient = np.copy(out_cell) * self.i[t]\n self.tanh1.activation = self.C_tilda[t]\n C_tilda_gradient = self.tanh1.backward(C_tilda_gradient)\n\n # gradient input gate\n i_gradient = np.copy(out_cell) * self.C_tilda[t]\n self.sigmoid2.activation = self.i[t]\n i_gradient = self.sigmoid2.backward(i_gradient)\n\n # gradient cell\n gradient_cell[t] = np.copy(out_cell) * self.f[t]\n\n # gradient forget gate\n f_gradient = np.copy(out_cell) * self.cell_state_b[t]\n self.sigmoid1.activation = self.f[t]\n f_gradient = self.sigmoid1.backward(f_gradient)\n\n # concatenation for the fully connected\n self.fully_middle.input_tensor = self.fully_middle_input[t]\n y = self.fully_middle.backward(np.concatenate([f_gradient, i_gradient, C_tilda_gradient, o_gradient]))\n gradient_weights_middle += self.fully_middle.gradient_weights\n\n gradient_hidden[t - 1] = y[:self.hidden_size]\n gradient_input[t] = y[self.hidden_size:]\n\n if self._optimizer:\n self.fully_out.weights = self._optimizer2.calculate_update(self.fully_out.weights, gradient_weights_out)\n self.fully_middle.weights = self._optimizer.calculate_update(self.fully_middle.weights, gradient_weights_middle)\n\n self.final_gradient_weights = gradient_weights_middle\n return gradient_input\n\n\n def initialize(self, weights_initializer, bias_initializer):\n self.fully_middle.initialize(weights_initializer, bias_initializer)\n self.fully_out.initialize(weights_initializer, bias_initializer)\n\n\n def calculate_regularization_loss(self, layer):\n r_loss = 0\n if hasattr(layer, 'optimizer'):\n if layer.optimizer:\n if layer.optimizer.regularizer:\n r_loss += layer.optimizer.regularizer.norm(layer.weights)\n return r_loss\n\n\n\n '''Properties'''\n\n @property\n def memorize(self):\n return self._memorize\n @memorize.setter\n def memorize(self, value):\n self._memorize = value\n\n @property\n def gradient_weights(self):\n return self.final_gradient_weights\n @gradient_weights.setter\n def gradient_weights(self, value):\n self.fully_middle.gradient_weights = value\n @gradient_weights.deleter\n def gradient_weights(self):\n del self.fully_middle.gradient_weights\n\n @property\n def weights(self):\n return self.fully_middle.weights\n @weights.setter\n def weights(self, value):\n self.fully_middle.weights = value\n @weights.deleter\n def weights(self):\n del self.fully_middle.weights\n\n @property\n def optimizer(self):\n return self._optimizer\n @optimizer.setter\n def optimizer(self, value):\n self._optimizer = value\n self._optimizer2 = copy.deepcopy(self._optimizer)\n @optimizer.deleter\n def optimizer(self):\n del self._optimizer"
] | [
[
"numpy.concatenate",
"numpy.copy",
"numpy.zeros"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
LarsChrWiik/Comparing-Machine-Learning-Models | [
"050b1bdb40c1d2e9c15f927e9eb257b4b7aaacbe"
] | [
"main.py"
] | [
"\r\nfrom scipy.io import arff\r\nfrom sklearn.pipeline import Pipeline\r\nfrom sklearn.utils import shuffle\r\nfrom ModelScorer import ModelScorer\r\nimport pandas as pd\r\nfrom Plotter import *\r\nimport warnings\r\n#warnings.simplefilter(action='ignore', category=FutureWarning)\r\nwarnings.filterwarnings(\"ignore\")\r\npd.set_option('display.expand_frame_repr', False)\r\n\r\n# Machine Learning Classifiers.\r\n\r\nfrom sklearn.dummy import DummyClassifier\r\nfrom sklearn.tree import DecisionTreeClassifier\r\nfrom sklearn.ensemble import RandomForestClassifier\r\nfrom sklearn.ensemble import GradientBoostingClassifier\r\nfrom sklearn.linear_model import SGDClassifier\r\nfrom sklearn.linear_model import LogisticRegression\r\nfrom sklearn.naive_bayes import GaussianNB\r\nfrom sklearn.neighbors import KNeighborsClassifier\r\nfrom sklearn.naive_bayes import MultinomialNB, BernoulliNB\r\nfrom sklearn.neural_network import MLPClassifier\r\nfrom sklearn.svm import SVC, LinearSVC\r\nfrom sklearn.svm import OneClassSVM\r\nfrom xgboost import XGBClassifier\r\n\r\n\r\nY_col = 'C'\r\n\r\n\r\ndef read_arff(name):\r\n data = arff.loadarff(name)\r\n df = pd.DataFrame(data[0])\r\n\r\n # Convert target strings to bits.\r\n df[Y_col] = df[Y_col].map(lambda x: 1 if str(x)[2:-1]=='True' else 0)\r\n return df\r\n\r\n\r\ndef score_models():\r\n df = read_arff('dataset.arff')\r\n\r\n # Normalize.\r\n df = df.apply(lambda x: (x - x.min()) /(x.max() - x.min()), axis=0)\r\n\r\n # Unsupervised Learning.\r\n X = df.drop(Y_col, axis=1)\r\n ocsvm = OneClassSVM()\r\n ocsvm.fit(X)\r\n df['Category'] = ocsvm.predict(X)\r\n\r\n # Model Scorer.\r\n scores = []\r\n model_scorer = ModelScorer(df=df, Y_col=Y_col)\r\n scores.append(model_scorer.score_model(clf=DummyClassifier()))\r\n scores.append(model_scorer.score_model(clf=DecisionTreeClassifier()))\r\n scores.append(model_scorer.score_model(clf=RandomForestClassifier(n_estimators=100)))\r\n scores.append(model_scorer.score_model(clf=GradientBoostingClassifier(n_estimators=100)))\r\n scores.append(model_scorer.score_model(clf=XGBClassifier(n_estimators=100)))\r\n scores.append(model_scorer.score_model(clf=SGDClassifier()))\r\n scores.append(model_scorer.score_model(clf=LogisticRegression()))\r\n scores.append(model_scorer.score_model(clf=GaussianNB()))\r\n scores.append(model_scorer.score_model(clf=KNeighborsClassifier()))\r\n scores.append(model_scorer.score_model(clf=BernoulliNB()))\r\n scores.append(model_scorer.score_model(clf=SVC(kernel='linear', degree=5)))\r\n scores.append(model_scorer.score_model(clf = MLPClassifier()))\r\n scores.append(model_scorer.score_model(\r\n clf = MLPClassifier(\r\n activation = 'tanh',\r\n solver = 'lbfgs',\r\n hidden_layer_sizes = 100,\r\n learning_rate_init = 0.001,\r\n max_iter = 100000\r\n ),\r\n name='Tuned MLPClassifier')\r\n )\r\n\r\n df_result = pd.concat(scores).reset_index(drop=True)\r\n df_result = df_result.sort_values([\"accuracy\"], ascending=False)\r\n print(df_result)\r\n\r\n\r\ndef show_feature_importances():\r\n df = read_arff('dataset.arff')\r\n\r\n # Normalize.\r\n df = df.apply(lambda x: (x - x.min()) /(x.max() - x.min()), axis=0)\r\n\r\n X = df.drop(Y_col, axis=1)\r\n Y = df[Y_col]\r\n plot_feature_importance(X, Y)\r\n\r\n\r\nif __name__ == \"__main__\":\r\n #score_models()\r\n show_feature_importances()\r\n"
] | [
[
"sklearn.neural_network.MLPClassifier",
"pandas.concat",
"sklearn.naive_bayes.GaussianNB",
"sklearn.dummy.DummyClassifier",
"sklearn.ensemble.RandomForestClassifier",
"sklearn.linear_model.LogisticRegression",
"pandas.DataFrame",
"sklearn.neighbors.KNeighborsClassifier",
"sklearn.tree.DecisionTreeClassifier",
"sklearn.naive_bayes.BernoulliNB",
"sklearn.svm.OneClassSVM",
"sklearn.svm.SVC",
"sklearn.ensemble.GradientBoostingClassifier",
"scipy.io.arff.loadarff",
"pandas.set_option",
"sklearn.linear_model.SGDClassifier"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [
"0.13",
"1.6",
"0.14",
"1.10",
"0.15",
"1.4",
"0.16",
"1.9",
"0.19",
"1.5",
"0.18",
"1.2",
"1.7",
"0.12",
"1.0",
"0.17",
"1.3",
"1.8"
],
"tensorflow": []
}
] |
rs992214/keanu | [
"c75b2a00571a0da93c6b1d5e9f0cbe09aebdde4d",
"c75b2a00571a0da93c6b1d5e9f0cbe09aebdde4d"
] | [
"keanu-python/keanu/infer_type.py",
"keanu-python/tests/test_proposal_distributions.py"
] | [
"from typing import Callable, Dict, Any, Union\n\nimport numpy as np\n\nfrom keanu.vartypes import (numpy_types, tensor_arg_types, runtime_numpy_types, runtime_pandas_types,\n runtime_primitive_types, runtime_bool_types, runtime_int_types, runtime_float_types,\n primitive_types)\nfrom keanu.vertex.base import Vertex\n\n\ndef infer_type_and_execute(value: tensor_arg_types, actions: Dict[type, Callable]) -> Any:\n return actions[get_type_of_value(value)](value)\n\n\ndef get_type_of_value(t: Union[tensor_arg_types, Vertex]) -> type:\n if isinstance(t, Vertex):\n return get_type_of_value(t.get_value())\n if isinstance(t, runtime_numpy_types):\n return __infer_type_from_ndarray(t)\n elif isinstance(t, runtime_pandas_types):\n return __infer_type_from_ndarray(t.values)\n elif isinstance(t, runtime_primitive_types):\n return __infer_type_from_scalar(t)\n else:\n raise NotImplementedError(\n \"Argument t must be either an ndarray or an instance of numbers.Number. Was given {} instead\".format(\n type(t)))\n\n\ndef __infer_type_from_ndarray(ndarray: numpy_types) -> type:\n if np.issubdtype(ndarray.dtype, np.bool_):\n return bool\n elif np.issubdtype(ndarray.dtype, np.integer):\n return int\n elif np.issubdtype(ndarray.dtype, np.floating):\n return float\n else:\n raise NotImplementedError(\"Generic types in an ndarray are not supported. Was given {}\".format(ndarray.dtype))\n\n\ndef __infer_type_from_scalar(scalar: primitive_types) -> type:\n if isinstance(scalar, runtime_bool_types):\n return bool\n elif isinstance(scalar, runtime_int_types):\n return int\n elif isinstance(scalar, runtime_float_types):\n return float\n else:\n raise NotImplementedError(\"Generic types in an ndarray are not supported. Was given {}\".format(type(scalar)))\n",
"import numpy as np\nimport pytest\n\nfrom keanu import BayesNet, Model\nfrom keanu.algorithm._proposal_distribution import ProposalDistribution\nfrom keanu.vertex import Gamma, Gaussian\nfrom keanu.vartypes import tensor_arg_types\n\n\[email protected]\ndef net() -> BayesNet:\n with Model() as m:\n m.gamma = Gamma(1., 1.)\n m.gaussian = Gaussian(0., m.gamma)\n\n return m.to_bayes_net()\n\n\ndef test_you_can_create_a_prior_proposal_distribution(net) -> None:\n ProposalDistribution(\"prior\", latents=list(net.iter_latent_vertices()))\n\n\[email protected](\"sigma\", [1., np.array(1.), [1., 2.], [np.array(1.), np.array(2.)]])\ndef test_you_can_create_a_gaussian_proposal_distribution(sigma: tensor_arg_types, net: BayesNet) -> None:\n ProposalDistribution(\"gaussian\", latents=list(net.iter_latent_vertices()), sigma=sigma)\n\n\ndef test_it_throws_if_you_specify_gaussian_without_a_value_for_sigma(net: BayesNet) -> None:\n with pytest.raises(\n TypeError, match=r\"Gaussian Proposal Distribution requires a sigma or a list of sigmas for each latent\"):\n ProposalDistribution(\"gaussian\", latents=list(net.iter_latent_vertices()))\n\n\ndef test_it_throws_if_you_specify_gaussian_with_not_enough_sigmas_for_each_latent(net: BayesNet) -> None:\n with pytest.raises(\n TypeError, match=r\"Gaussian Proposal Distribution requires a sigma or a list of sigmas for each latent\"):\n ProposalDistribution(\"gaussian\", latents=list(net.iter_latent_vertices()), sigma=[1.])\n\n\ndef test_it_throws_if_you_specify_gaussian_without_values_for_latents() -> None:\n with pytest.raises(TypeError, match=r\"Gaussian Proposal Distribution requires values for latents\"):\n ProposalDistribution(\"gaussian\", sigma=1.)\n\n\ndef test_it_throws_if_you_specify_gaussian_with_empty_list_of_latents(net: BayesNet) -> None:\n with pytest.raises(TypeError, match=r\"Gaussian Proposal Distribution requires values for latents\"):\n ProposalDistribution(\"gaussian\", latents=[], sigma=[])\n\n\ndef test_it_throws_if_you_specify_sigma_but_the_type_isnt_gaussian() -> None:\n with pytest.raises(TypeError, match=r'Parameter sigma is not valid unless type is \"gaussian\"'):\n ProposalDistribution(\"prior\", sigma=1.)\n\n\ndef test_it_throws_if_it_doesnt_recognise_the_type() -> None:\n with pytest.raises(KeyError, match=r\"'foo'\"):\n ProposalDistribution(\"foo\")\n"
] | [
[
"numpy.issubdtype"
],
[
"numpy.array"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
gesa23/ds1hw1 | [
"fe69bcfd311467611a9534bbeaa7705ed95fafdb"
] | [
"main.py"
] | [
"from sklearn.datasets import load_iris\nimport pandas as pd\n\nds = load_iris()\ndf = pd.DataFrame(data= ds[\"data\"], columns=ds[\"feature_names\"])\ntarget_names = [ds.target_names[x] for x in ds.target]\ndf['species'] = target_names\nprint(df)"
] | [
[
"sklearn.datasets.load_iris",
"pandas.DataFrame"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"0.23",
"0.21",
"2.0",
"1.4",
"0.19",
"1.1",
"1.5",
"1.2",
"0.24",
"0.20",
"1.0",
"0.25",
"1.3"
],
"scipy": [],
"tensorflow": []
}
] |
jacke121/MBMD | [
"2daf5edb4fb40ee652baead4f9332ca00fa111a5",
"2daf5edb4fb40ee652baead4f9332ca00fa111a5",
"2daf5edb4fb40ee652baead4f9332ca00fa111a5"
] | [
"core/target_assigner.py",
"siamese_utils.py",
"lib/object_detection/my_train.py"
] | [
"from object_detection.core.target_assigner import TargetAssigner\nimport tensorflow as tf\nfrom object_detection.core import box_list\n\nclass TargetAssignerExtend(TargetAssigner):\n def assign(self, anchors, groundtruth_boxes, groundtruth_labels=None,\n **params):\n \"\"\"Assign classification and regression targets to each anchor.\n The extended version assign 0 weights to negative (0) box regression.\n \n For a given set of anchors and groundtruth detections, match anchors\n to groundtruth_boxes and assign classification and regression targets to\n each anchor as well as weights based on the resulting match (specifying,\n e.g., which anchors should not contribute to training loss).\n \n Anchors that are not matched to anything are given a classification target\n of self._unmatched_cls_target which can be specified via the constructor.\n \n \n Args:\n anchors: a BoxList representing N anchors\n groundtruth_boxes: a BoxList representing M groundtruth boxes\n groundtruth_labels: a tensor of shape [num_gt_boxes, d_1, ... d_k]\n with labels for each of the ground_truth boxes. The subshape\n [d_1, ... d_k] can be empty (corresponding to scalar inputs). When set\n to None, groundtruth_labels assumes a binary problem where all\n ground_truth boxes get a positive label (of 1).\n **params: Additional keyword arguments for specific implementations of\n the Matcher.\n \n Returns:\n cls_targets: a float32 tensor with shape [num_anchors, d_1, d_2 ... d_k],\n where the subshape [d_1, ..., d_k] is compatible with groundtruth_labels\n which has shape [num_gt_boxes, d_1, d_2, ... d_k].\n cls_weights: a float32 tensor with shape [num_anchors]\n reg_targets: a float32 tensor with shape [num_anchors, box_code_dimension]\n reg_weights: a float32 tensor with shape [num_anchors]\n match: a matcher.Match object encoding the match between anchors and\n groundtruth boxes, with rows corresponding to groundtruth boxes\n and columns corresponding to anchors.\n \n Raises:\n ValueError: if anchors or groundtruth_boxes are not of type\n box_list.BoxList\n \"\"\"\n if not isinstance(anchors, box_list.BoxList):\n raise ValueError('anchors must be an BoxList')\n if not isinstance(groundtruth_boxes, box_list.BoxList):\n raise ValueError('groundtruth_boxes must be an BoxList')\n\n if groundtruth_labels is None:\n groundtruth_labels = tf.ones(tf.expand_dims(groundtruth_boxes.num_boxes(),\n 0))\n groundtruth_labels = tf.expand_dims(groundtruth_labels, -1)\n shape_assert = tf.assert_equal(tf.shape(groundtruth_labels)[1:],\n tf.shape(self._unmatched_cls_target))\n\n with tf.control_dependencies([shape_assert]):\n match_quality_matrix = self._similarity_calc.compare(groundtruth_boxes,\n anchors)\n match = self._matcher.match(match_quality_matrix, **params)\n reg_targets = self._create_regression_targets(anchors,\n groundtruth_boxes,\n match)\n cls_targets = self._create_classification_targets(groundtruth_labels,\n match)\n reg_weights = self._create_regression_weights(match, groundtruth_labels)\n cls_weights = self._create_classification_weights(\n match, self._positive_class_weight, self._negative_class_weight)\n\n num_anchors = anchors.num_boxes_static()\n if num_anchors is not None:\n reg_targets = self._reset_target_shape(reg_targets, num_anchors)\n cls_targets = self._reset_target_shape(cls_targets, num_anchors)\n reg_weights = self._reset_target_shape(reg_weights, num_anchors)\n cls_weights = self._reset_target_shape(cls_weights, num_anchors)\n\n return cls_targets, cls_weights, reg_targets, reg_weights, match\n\n def _create_regression_weights(self, match, groundtruth_labels):\n \"\"\"Set regression weight for each anchor.\n \n Only positive anchors are set to contribute to the regression loss, so this\n method returns a weight of 1 for every positive anchor and 0 for every\n negative anchor.\n \n Args:\n match: a matcher.Match object that provides a matching between anchors\n and groundtruth boxes.\n \n Returns:\n reg_weights: a float32 tensor with shape [num_anchors] representing\n regression weights\n \"\"\"\n\n reg_weights = tf.cast(match.matched_column_indicator(), tf.float32)\n\n matched_gt_indices = match.matched_row_indices()\n matched_label = tf.gather(groundtruth_labels, matched_gt_indices)\n matched_is_foreground = tf.cast(matched_label[:,0] <= 0, tf.float32)\n matched_anchor_indices = match.matched_column_indices()\n unmatched_ignored_anchor_indices=match.unmatched_or_ignored_column_indices()\n unmatched_ignored_reg_weights = tf.gather(reg_weights, unmatched_ignored_anchor_indices)\n reg_weights= tf.dynamic_stitch(\n [matched_anchor_indices, unmatched_ignored_anchor_indices],\n [matched_is_foreground, unmatched_ignored_reg_weights])\n return reg_weights\n\n",
"import sys\nimport numpy as np\nimport os\nimport time\nimport matplotlib.pyplot as plt\nimport cv2\nfrom numpy.random import *\nfrom pylab import *\nfrom PIL import Image\nimport tempfile\nimport random\nfrom region_to_bbox import region_to_bbox\nimport tensorflow as tf\n\n\nos.environ['CUDA_VISIBLE_DEVICES'] = '0'\n\ndef getSubWinTracking(img, pos, modelSz, originalSz, avgChans):\n if originalSz is None:\n originalSz = modelSz\n\n sz = originalSz\n im_sz = img.shape\n # make sure the size is not too small\n assert min(im_sz[:2]) > 2, \"the size is too small\"\n c = (np.array(sz) + 1) / 2\n\n # check out-of-bounds coordinates, and set them to black\n context_xmin = round(pos[1] - c[1])\n context_xmax = context_xmin + sz[1] - 1\n context_ymin = round(pos[0] - c[0])\n context_ymax = context_ymin + sz[0] - 1\n left_pad = max(0, int(-context_xmin))\n top_pad = max(0, int(-context_ymin))\n right_pad = max(0, int(context_xmax - im_sz[1] + 1))\n bottom_pad = max(0, int(context_ymax - im_sz[0] + 1))\n\n context_xmin = int(context_xmin + left_pad)\n context_xmax = int(context_xmax + left_pad)\n context_ymin = int(context_ymin + top_pad)\n context_ymax = int(context_ymax + top_pad)\n\n if top_pad or left_pad or bottom_pad or right_pad:\n r = np.pad(img[:, :, 0], ((top_pad, bottom_pad), (left_pad, right_pad)), mode='constant',\n constant_values=avgChans[0])\n g = np.pad(img[:, :, 1], ((top_pad, bottom_pad), (left_pad, right_pad)), mode='constant',\n constant_values=avgChans[1])\n b = np.pad(img[:, :, 2], ((top_pad, bottom_pad), (left_pad, right_pad)), mode='constant',\n constant_values=avgChans[2])\n r = np.expand_dims(r, 2)\n g = np.expand_dims(g, 2)\n b = np.expand_dims(b, 2)\n\n # h, w = r.shape\n # r1 = np.zeros([h, w, 1], dtype=np.float32)\n # r1[:, :, 0] = r\n # g1 = np.zeros([h, w, 1], dtype=np.float32)\n # g1[:, :, 0] = g\n # b1 = np.zeros([h, w, 1], dtype=np.float32)\n # b1[:, :, 0] = b\n\n img = np.concatenate((r, g, b ), axis=2)\n\n im_patch_original = img[context_ymin:context_ymax + 1, context_xmin:context_xmax + 1, :]\n if not np.array_equal(modelSz, originalSz):\n im_patch = cv2.resize(im_patch_original, modelSz)\n # im_patch_original = im_patch_original/255.0\n # im_patch = transform.resize(im_patch_original, modelSz)*255.0\n # im = Image.fromarray(im_patch_original.astype(np.float))\n # im = im.resize(modelSz)\n # im_patch = np.array(im).astype(np.float32)\n else:\n im_patch = im_patch_original\n\n # im_patch = im_patch[:, :, ::-1]\n # im_patch[:, :, 0] = im_patch[:, :, 0] - 103.939\n # im_patch[:, :, 1] = im_patch[:, :, 1] - 116.779\n # im_patch[:, :, 2] = im_patch[:, :, 2] - 123.68\n return im_patch, im_patch_original\n\ndef _update_target_position(pos_x, pos_y, score, final_score_sz, tot_stride, search_sz, response_up, x_sz):\n # find location of score maximizer\n p = np.asarray(np.unravel_index(np.argmax(score), np.shape(score)))\n # displacement from the center in search area final representation ...\n center = float(final_score_sz - 1) / 2\n disp_in_area = p - center\n # displacement from the center in instance crop\n disp_in_xcrop = disp_in_area * float(tot_stride) / response_up\n # displacement from the center in instance crop (in frame coordinates)\n disp_in_frame = disp_in_xcrop * x_sz / search_sz\n # *position* within frame in frame coordinates\n pos_y, pos_x = pos_y + disp_in_frame[0], pos_x + disp_in_frame[1]\n return pos_x, pos_y\n\ndef trackerEval(score, sx, targetPosition, window, hp,design):\n # responseMaps = np.transpose(score[:, :, :, 0], [1, 2, 0])\n responseMaps = score[:,:,:,0]\n upsz = design['score_sz']*hp['response_up']\n # responseMapsUp = np.zeros([opts['scoreSize']*opts['responseUp'], opts['scoreSize']*opts['responseUp'], opts['numScale']])\n responseMapsUP = []\n\n if hp['scale_num'] > 1:\n currentScaleID = int(hp['scale_num']/2)\n bestScale = currentScaleID\n bestPeak = -float('Inf')\n\n for s in range(hp['scale_num']):\n if hp['response_up'] > 1:\n responseMapsUP.append(cv2.resize(responseMaps[s, :, :], (upsz, upsz), interpolation=cv2.INTER_CUBIC))\n else:\n responseMapsUP.append(responseMaps[s, :, :])\n\n thisResponse = responseMapsUP[-1]\n\n if s != currentScaleID:\n thisResponse = thisResponse*hp['scale_penalty']\n\n thisPeak = np.max(thisResponse)\n if thisPeak > bestPeak:\n bestPeak = thisPeak\n bestScale = s\n\n responseMap = responseMapsUP[bestScale]\n else:\n responseMap = cv2.resize(responseMaps[0, :, :], (upsz, upsz), interpolation=cv2.INTER_CUBIC)\n bestScale = 0\n\n responseMap = responseMap - np.min(responseMap)\n responseMap = responseMap/np.sum(responseMap)\n\n responseMap = (1-hp['window_influence'])*responseMap+hp['window_influence']*window\n rMax, cMax = np.unravel_index(responseMap.argmax(), responseMap.shape)\n pCorr = np.array((rMax, cMax))\n dispInstanceFinal = pCorr-int(upsz/2)\n dispInstanceInput = dispInstanceFinal*design['tot_stride']/hp['response_up']\n dispInstanceFrame = dispInstanceInput*sx/design['search_sz']\n newTargetPosition = targetPosition+dispInstanceFrame\n # print(bestScale)\n\n return newTargetPosition, bestScale\n\ndef makeScalePyramid(im, targetPosition, in_side_scaled, out_side, avgChans, numScale):\n \"\"\"\n computes a pyramid of re-scaled copies of the target (centered on TARGETPOSITION)\n and resizes them to OUT_SIDE. If crops exceed image boundaries they are padded with AVGCHANS.\n \"\"\"\n in_side_scaled = np.round(in_side_scaled)\n max_target_side = int(round(in_side_scaled[-1]))\n min_target_side = int(round(in_side_scaled[0]))\n beta = out_side / float(min_target_side)\n # size_in_search_area = beta * size_in_image\n # e.g. out_side = beta * min_target_side\n search_side = int(round(beta * max_target_side))\n search_region, _ = getSubWinTracking(im, targetPosition, (search_side, search_side),\n (max_target_side, max_target_side), avgChans)\n\n assert round(beta * min_target_side) == int(out_side)\n\n tmp_list = []\n tmp_pos = ((search_side - 1) / 2., (search_side - 1) / 2.)\n for s in range(numScale):\n target_side = round(beta * in_side_scaled[s])\n tmp_region, _ = getSubWinTracking(search_region, tmp_pos, (out_side, out_side), (target_side, target_side),\n avgChans)\n tmp_list.append(tmp_region)\n\n pyramid = np.stack(tmp_list)\n\n return pyramid\n\ndef _init_video(video):\n root_dataset = '/home/xiaobai/dataset/OTB/'\n video += '/'\n video_folder = os.path.join(root_dataset, video,'img')\n frame_name_list = [f for f in os.listdir(video_folder) if f.endswith(\".jpg\")]\n frame_name_list = [os.path.join(root_dataset, video,'img', '') + s for s in frame_name_list]\n frame_name_list.sort()\n #with Image.open(frame_name_list[0]) as img:\n img = Image.open(frame_name_list[0])\n frame_sz = np.asarray(img.size)\n frame_sz[1], frame_sz[0] = frame_sz[0], frame_sz[1]\n\n # read the initialization from ground truth\n gt_file = os.path.join(root_dataset,video, 'groundtruth_rect.txt')\n gt = np.genfromtxt(gt_file, delimiter=',')\n if len(gt.shape) < 2:\n gt = np.genfromtxt(gt_file)\n n_frames = len(frame_name_list)\n if n_frames > len(gt):\n frame_name_list = frame_name_list[:len(gt)]\n\n return gt, frame_name_list, frame_sz, n_frames\n\ndef _compile_results(gt, bboxes, dist_threshold):\n l = np.size(bboxes, 0)\n gt4 = np.zeros((l, 4))\n new_distances = np.zeros(l)\n new_ious = np.zeros(l)\n n_thresholds = 50\n precisions_ths = np.zeros(n_thresholds)\n\n for i in range(l):\n gt4[i, :] = region_to_bbox(gt[i, :], center=False)\n new_distances[i] = _compute_distance(bboxes[i, :], gt4[i, :])\n new_ious[i] = _compute_iou(bboxes[i, :], gt4[i, :])\n\n # what's the percentage of frame in which center displacement is inferior to given threshold? (OTB metric)\n precision = sum(new_distances < dist_threshold)/float(np.size(new_distances)) * 100.0\n\n # find above result for many thresholds, then report the AUC\n thresholds = np.linspace(0, 25, n_thresholds+1)\n thresholds = thresholds[-n_thresholds:]\n # reverse it so that higher values of precision goes at the beginning\n thresholds = thresholds[::-1]\n for i in range(n_thresholds):\n precisions_ths[i] = sum(new_distances < thresholds[i])/float(np.size(new_distances))\n\n # integrate over the thresholds\n precision_auc = np.trapz(precisions_ths)\n\n # per frame averaged intersection over union (OTB metric)\n iou = np.mean(new_ious) * 100\n\n return l, precision, precision_auc, iou\n\ndef _compute_distance(boxA, boxB):\n a = np.array((boxA[0]+boxA[2]/2, boxA[1]+boxA[3]/2))\n b = np.array((boxB[0]+boxB[2]/2, boxB[1]+boxB[3]/2))\n dist = np.linalg.norm(a - b)\n\n assert dist >= 0\n assert dist != float('Inf')\n\n return dist\n\n\ndef _compute_iou(boxA, boxB):\n # determine the (x, y)-coordinates of the intersection rectangle\n xA = max(boxA[0], boxB[0])\n yA = max(boxA[1], boxB[1])\n xB = min(boxA[0] + boxA[2], boxB[0] + boxB[2])\n yB = min(boxA[1] + boxA[3], boxB[1] + boxB[3])\n\n if xA < xB and yA < yB:\n # compute the area of intersection rectangle\n interArea = (xB - xA) * (yB - yA)\n # compute the area of both the prediction and ground-truth\n # rectangles\n boxAArea = boxA[2] * boxA[3]\n boxBArea = boxB[2] * boxB[3]\n # compute the intersection over union by taking the intersection\n # area and dividing it by the sum of prediction + ground-truth\n # areas - the intersection area\n iou = interArea / float(boxAArea + boxBArea - interArea)\n else:\n iou = 0\n\n assert iou >= 0\n assert iou <= 1.01\n\n return iou\n\ndef getOpts(opts):\n print(\"config opts...\")\n\n opts['numScale'] = 3\n opts['scaleStep'] = 1.0375\n opts['scalePenalty'] = 0.9745\n # opts['scalePenalty'] = 1/0.9745\n opts['scaleLr'] = 0.59\n opts['responseUp'] = 16\n opts['windowing'] = 'cosine'\n opts['wInfluence'] = 0.176\n opts['exemplarSize'] = 127\n opts['instanceSize'] = 239\n opts['scoreSize'] = 17\n opts['totalStride'] = 8\n opts['contextAmount'] = 0.5\n opts['trainWeightDecay'] = 5e-04\n opts['stddev'] = 0.03\n opts['subMean'] = False\n\n opts['video'] = 'vot15_bag'\n opts['modelPath'] = './models/'\n opts['modelName'] = opts['modelPath']+\"model_tf.ckpt\"\n opts['summaryFile'] = './data_track/'+opts['video']+'_20170518'\n\n return opts\n\n\ndef makeGaussian(size, fwhm=3, center=None):\n \"\"\" Make a square gaussian kernel.\n\n size is the length of a side of the square\n fwhm is full-width-half-maximum, which\n can be thought of as an effective radius.\n \"\"\"\n\n x = np.arange(0, size, 1, float)\n y = x[:, np.newaxis]\n\n if center is None:\n x0 = y0 = size // 2\n else:\n x0 = center[0]\n y0 = center[1]\n\n return np.exp(-4 * np.log(2) * ((x - x0) ** 2 + (y - y0) ** 2) / fwhm ** 2)\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\nr\"\"\"Training executable for detection models.\n\nThis executable is used to train DetectionModels. There are two ways of\nconfiguring the training job:\n\n1) A single pipeline_pb2.TrainEvalPipelineConfig configuration file\ncan be specified by --pipeline_config_path.\n\nExample usage:\n ./train \\\n --logtostderr \\\n --train_dir=path/to/train_dir \\\n --pipeline_config_path=pipeline_config.pbtxt\n\n2) Three configuration files can be provided: a model_pb2.DetectionModel\nconfiguration file to define what type of DetectionModel is being trained, an\ninput_reader_pb2.InputReader file to specify what training data will be used and\na train_pb2.TrainConfig file to configure training parameters.\n\nExample usage:\n ./train \\\n --logtostderr \\\n --train_dir=path/to/train_dir \\\n --model_config_path=model_config.pbtxt \\\n --train_config_path=train_config.pbtxt \\\n --input_config_path=train_input_config.pbtxt\n\"\"\"\n\nimport functools\nimport json\nimport os\nimport tensorflow as tf\n\nfrom google.protobuf import text_format\n\nfrom object_detection import trainer\nfrom object_detection.builders import input_reader_builder\nfrom object_detection.builders import model_builder\nfrom object_detection.protos import input_reader_pb2\nfrom object_detection.protos import model_pb2\nfrom object_detection.protos import pipeline_pb2\nfrom object_detection.protos import train_pb2\n\ntf.logging.set_verbosity(tf.logging.INFO)\n\nflags = tf.app.flags\nflags.DEFINE_string('master', '', 'BNS name of the TensorFlow master to use.')\nflags.DEFINE_integer('task', 0, 'task id')\nflags.DEFINE_integer('num_clones', 1, 'Number of clones to deploy per worker.')\nflags.DEFINE_boolean('clone_on_cpu', False,\n 'Force clones to be deployed on CPU. Note that even if '\n 'set to False (allowing ops to run on gpu), some ops may '\n 'still be run on the CPU if they have no GPU kernel.')\nflags.DEFINE_integer('worker_replicas', 1, 'Number of worker+trainer '\n 'replicas.')\nflags.DEFINE_integer('ps_tasks', 0,\n 'Number of parameter server tasks. If None, does not use '\n 'a parameter server.')\nflags.DEFINE_string('train_dir', '/media/2TB/Research/Code/tensorflow_models/models/object_detection/examples/ssd_mobilenet/model',\n 'Directory to save the checkpoints and training summaries.')\n\nflags.DEFINE_string('pipeline_config_path', '/media/2TB/Research/Code/tensorflow_models/models/object_detection/examples/ssd_mobilenet/ssd_mobilenet_v1_pets.config',\n 'Path to a pipeline_pb2.TrainEvalPipelineConfig config '\n 'file. If provided, other configs are ignored')\n\nflags.DEFINE_string('train_config_path', '',\n 'Path to a train_pb2.TrainConfig config file.')\nflags.DEFINE_string('input_config_path', '',\n 'Path to an input_reader_pb2.InputReader config file.')\nflags.DEFINE_string('model_config_path', '',\n 'Path to a model_pb2.DetectionModel config file.')\n\nFLAGS = flags.FLAGS\n\n\ndef get_configs_from_pipeline_file():\n \"\"\"Reads training configuration from a pipeline_pb2.TrainEvalPipelineConfig.\n\n Reads training config from file specified by pipeline_config_path flag.\n\n Returns:\n model_config: model_pb2.DetectionModel\n train_config: train_pb2.TrainConfig\n input_config: input_reader_pb2.InputReader\n \"\"\"\n pipeline_config = pipeline_pb2.TrainEvalPipelineConfig()\n with tf.gfile.GFile(FLAGS.pipeline_config_path, 'r') as f:\n text_format.Merge(f.read(), pipeline_config)\n\n model_config = pipeline_config.model\n train_config = pipeline_config.train_config\n input_config = pipeline_config.train_input_reader\n\n return model_config, train_config, input_config\n\n\ndef get_configs_from_multiple_files():\n \"\"\"Reads training configuration from multiple config files.\n\n Reads the training config from the following files:\n model_config: Read from --model_config_path\n train_config: Read from --train_config_path\n input_config: Read from --input_config_path\n\n Returns:\n model_config: model_pb2.DetectionModel\n train_config: train_pb2.TrainConfig\n input_config: input_reader_pb2.InputReader\n \"\"\"\n train_config = train_pb2.TrainConfig()\n with tf.gfile.GFile(FLAGS.train_config_path, 'r') as f:\n text_format.Merge(f.read(), train_config)\n\n model_config = model_pb2.DetectionModel()\n with tf.gfile.GFile(FLAGS.model_config_path, 'r') as f:\n text_format.Merge(f.read(), model_config)\n\n input_config = input_reader_pb2.InputReader()\n with tf.gfile.GFile(FLAGS.input_config_path, 'r') as f:\n text_format.Merge(f.read(), input_config)\n\n return model_config, train_config, input_config\n\n\ndef main(_):\n assert FLAGS.train_dir, '`train_dir` is missing.'\n if FLAGS.pipeline_config_path:\n model_config, train_config, input_config = get_configs_from_pipeline_file()\n else:\n model_config, train_config, input_config = get_configs_from_multiple_files()\n\n model_fn = functools.partial(\n model_builder.build,\n model_config=model_config,\n is_training=True)\n\n create_input_dict_fn = functools.partial(\n input_reader_builder.build, input_config)\n\n env = json.loads(os.environ.get('TF_CONFIG', '{}'))\n cluster_data = env.get('cluster', None)\n cluster = tf.train.ClusterSpec(cluster_data) if cluster_data else None\n task_data = env.get('task', None) or {'type': 'master', 'index': 0}\n task_info = type('TaskSpec', (object,), task_data)\n\n # Parameters for a single worker.\n ps_tasks = 0\n worker_replicas = 1\n worker_job_name = 'lonely_worker'\n task = 0\n is_chief = True\n master = ''\n\n if cluster_data and 'worker' in cluster_data:\n # Number of total worker replicas include \"worker\"s and the \"master\".\n worker_replicas = len(cluster_data['worker']) + 1\n if cluster_data and 'ps' in cluster_data:\n ps_tasks = len(cluster_data['ps'])\n\n if worker_replicas > 1 and ps_tasks < 1:\n raise ValueError('At least 1 ps task is needed for distributed training.')\n\n if worker_replicas >= 1 and ps_tasks > 0:\n # Set up distributed training.\n server = tf.train.Server(tf.train.ClusterSpec(cluster), protocol='grpc',\n job_name=task_info.type,\n task_index=task_info.index)\n if task_info.type == 'ps':\n server.join()\n return\n\n worker_job_name = '%s/task:%d' % (task_info.type, task_info.index)\n task = task_info.index\n is_chief = (task_info.type == 'master')\n master = server.target\n\n trainer.train(create_input_dict_fn, model_fn, train_config, master, task,\n FLAGS.num_clones, worker_replicas, FLAGS.clone_on_cpu, ps_tasks,\n worker_job_name, is_chief, FLAGS.train_dir)\n\n\nif __name__ == '__main__':\n tf.app.run()\n"
] | [
[
"tensorflow.control_dependencies",
"tensorflow.shape",
"tensorflow.cast",
"tensorflow.expand_dims",
"tensorflow.gather",
"tensorflow.dynamic_stitch"
],
[
"numpy.expand_dims",
"numpy.linspace",
"numpy.asarray",
"numpy.round",
"numpy.concatenate",
"numpy.max",
"numpy.mean",
"numpy.trapz",
"numpy.pad",
"numpy.arange",
"numpy.stack",
"numpy.size",
"numpy.argmax",
"numpy.zeros",
"numpy.log",
"numpy.min",
"numpy.genfromtxt",
"numpy.array",
"numpy.sum",
"numpy.array_equal",
"numpy.linalg.norm",
"numpy.shape"
],
[
"tensorflow.gfile.GFile",
"tensorflow.train.ClusterSpec",
"tensorflow.logging.set_verbosity",
"tensorflow.app.run"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"1.10",
"1.12",
"1.4",
"1.13",
"1.5",
"1.7",
"0.12",
"1.0",
"1.2"
]
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"1.10"
]
}
] |
marklr/vqgan-clip-app | [
"23edb7ae6234ab177a91865c02be160151fcf566"
] | [
"diffusion_logic.py"
] | [
"import clip\nimport sys\nimport torch\nfrom torchvision import transforms\nfrom torchvision.transforms import functional as TF\nfrom kornia import augmentation, filters\nfrom torch import nn\nfrom torch.nn import functional as F\nimport math\nimport lpips\nfrom PIL import Image\n\nsys.path.append(\"./guided-diffusion\")\n\nfrom guided_diffusion.script_util import (\n create_model_and_diffusion,\n model_and_diffusion_defaults,\n)\n\nDIFFUSION_METHODS_AND_WEIGHTS = {\n # \"CLIP Guided Diffusion 256x256\",\n \"256x256 HQ Uncond\": \"256x256_diffusion_uncond.pt\",\n \"512x512 HQ Cond\": \"512x512_diffusion.pt\",\n \"512x512 HQ Uncond\": \"512x512_diffusion_uncond_finetune_008100.pt\",\n}\n\n\ndef spherical_dist_loss(x, y):\n x = F.normalize(x, dim=-1)\n y = F.normalize(y, dim=-1)\n return (x - y).norm(dim=-1).div(2).arcsin().pow(2).mul(2)\n\n\ndef parse_prompt(prompt):\n vals = prompt.rsplit(\":\", 1)\n vals = vals + [\"\", \"1\"][len(vals) :]\n return vals[0], float(vals[1])\n\n\nclass MakeCutouts(nn.Module):\n def __init__(self, cut_size, cutn, cut_pow=1.0):\n super().__init__()\n self.cut_size = cut_size\n self.cutn = cutn\n self.cut_pow = cut_pow\n\n def forward(self, input):\n sideY, sideX = input.shape[2:4]\n max_size = min(sideX, sideY)\n min_size = min(sideX, sideY, self.cut_size)\n cutouts = []\n for _ in range(self.cutn):\n size = int(\n torch.rand([]) ** self.cut_pow * (max_size - min_size) + min_size\n )\n offsetx = torch.randint(0, sideX - size + 1, ())\n offsety = torch.randint(0, sideY - size + 1, ())\n cutout = input[:, :, offsety : offsety + size, offsetx : offsetx + size]\n cutouts.append(F.adaptive_avg_pool2d(cutout, self.cut_size))\n return torch.cat(cutouts)\n\n\ndef tv_loss(input):\n \"\"\"L2 total variation loss, as in Mahendran et al.\"\"\"\n input = F.pad(input, (0, 1, 0, 1), \"replicate\")\n x_diff = input[..., :-1, 1:] - input[..., :-1, :-1]\n y_diff = input[..., 1:, :-1] - input[..., :-1, :-1]\n return (x_diff ** 2 + y_diff ** 2).mean([1, 2, 3])\n\n\ndef range_loss(input):\n return (input - input.clamp(-1, 1)).pow(2).mean([1, 2, 3])\n\n\nclass CLIPGuidedDiffusion:\n def __init__(\n self,\n prompt: str,\n ckpt: str,\n batch_size: int = 1,\n clip_guidance_scale: float = 1000,\n seed: int = 0,\n num_steps: int = 1000,\n continue_prev_run: bool = True,\n skip_timesteps: int = 0,\n ) -> None:\n\n assert ckpt in DIFFUSION_METHODS_AND_WEIGHTS.keys()\n self.ckpt = ckpt\n print(self.ckpt)\n\n # Default config\n self.model_config = model_and_diffusion_defaults()\n self.model_config.update(\n {\n \"attention_resolutions\": \"32, 16, 8\",\n \"class_cond\": True if ckpt == \"512x512 HQ Cond\" else False,\n \"diffusion_steps\": num_steps,\n \"rescale_timesteps\": True,\n \"timestep_respacing\": str(\n num_steps\n ), # modify this to decrease timesteps\n \"image_size\": 512 if ckpt.startswith(\"512\") else 256,\n \"learn_sigma\": True,\n \"noise_schedule\": \"linear\",\n \"num_channels\": 256,\n \"num_head_channels\": 64,\n \"num_res_blocks\": 2,\n \"resblock_updown\": True,\n \"use_checkpoint\": False,\n \"use_fp16\": True,\n \"use_scale_shift_norm\": True,\n }\n )\n # Split text by \"|\" symbol\n self.prompts = [phrase.strip() for phrase in prompt.split(\"|\")]\n if self.prompts == [\"\"]:\n self.prompts = []\n\n self.image_prompts = [] # TODO\n self.batch_size = batch_size\n\n # Controls how much the image should look like the prompt.\n self.clip_guidance_scale = clip_guidance_scale\n\n # Controls the smoothness of the final output.\n self.tv_scale = 150 # TODO add control widget\n\n # Controls how far out of range RGB values are allowed to be.\n self.range_scale = 50 # TODO add control widget\n\n self.cutn = 32 # TODO add control widget\n self.cutn_batches = 2 # TODO add control widget\n self.cut_pow = 0.5 # TODO add control widget\n\n # Removed, repeat batches by triggering a new run\n # self.n_batches = 1\n\n # This enhances the effect of the init image, a good value is 1000.\n self.init_scale = 1000 # TODO add control widget\n\n # This needs to be between approx. 200 and 500 when using an init image.\n # Higher values make the output look more like the init.\n self.skip_timesteps = skip_timesteps # TODO add control widget\n\n self.seed = seed\n self.continue_prev_run = continue_prev_run\n\n self.device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n print(\"Using device:\", self.device)\n\n def load_model(\n self,\n model_file_loc=\"assets/256x256_diffusion_uncond.pt\",\n prev_model=None,\n prev_diffusion=None,\n prev_clip_model=None,\n ) -> None:\n if (\n self.continue_prev_run is True\n and prev_model is not None\n and prev_diffusion is not None\n and prev_clip_model is not None\n ):\n self.model = prev_model\n self.diffusion = prev_diffusion\n self.clip_model = prev_clip_model\n\n self.clip_size = self.clip_model.visual.input_resolution\n self.normalize = transforms.Normalize(\n mean=[0.48145466, 0.4578275, 0.40821073],\n std=[0.26862954, 0.26130258, 0.27577711],\n )\n\n else:\n self.model, self.diffusion = create_model_and_diffusion(**self.model_config)\n self.model.load_state_dict(torch.load(model_file_loc, map_location=\"cpu\"))\n self.model.eval().requires_grad_(False).to(self.device)\n\n if self.ckpt == \"512x512 HQ Cond\":\n for name, param in self.model.named_parameters():\n if \"qkv\" in name or \"norm\" in name or \"proj\" in name:\n param.requires_grad_()\n\n if self.model_config[\"use_fp16\"]:\n self.model.convert_to_fp16()\n\n self.clip_model = (\n clip.load(\"ViT-B/16\", jit=False)[0]\n .eval()\n .requires_grad_(False)\n .to(self.device)\n )\n\n self.clip_size = self.clip_model.visual.input_resolution\n self.normalize = transforms.Normalize(\n mean=[0.48145466, 0.4578275, 0.40821073],\n std=[0.26862954, 0.26130258, 0.27577711],\n )\n\n return self.model, self.diffusion, self.clip_model\n\n def cond_fn_conditional(self, x, t, y=None):\n # From 512 HQ notebook using OpenAI's conditional 512x512 model\n # TODO: Merge with cond_fn's cutn_batches\n with torch.enable_grad():\n x = x.detach().requires_grad_()\n n = x.shape[0]\n my_t = torch.ones([n], device=self.device, dtype=torch.long) * self.cur_t\n out = self.diffusion.p_mean_variance(\n self.model, x, my_t, clip_denoised=False, model_kwargs={\"y\": y}\n )\n fac = self.diffusion.sqrt_one_minus_alphas_cumprod[self.cur_t]\n x_in = out[\"pred_xstart\"] * fac + x * (1 - fac)\n clip_in = self.normalize(self.make_cutouts(x_in.add(1).div(2)))\n image_embeds = (\n self.clip_model.encode_image(clip_in).float().view([self.cutn, n, -1])\n )\n dists = spherical_dist_loss(image_embeds, self.target_embeds.unsqueeze(0))\n losses = dists.mean(0)\n tv_losses = tv_loss(x_in)\n loss = (\n losses.sum() * self.clip_guidance_scale\n + tv_losses.sum() * self.tv_scale\n )\n # TODO: Implement init image\n return -torch.autograd.grad(loss, x)[0]\n\n def cond_fn(self, x, t, out, y=None):\n n = x.shape[0]\n fac = self.diffusion.sqrt_one_minus_alphas_cumprod[self.cur_t]\n x_in = out[\"pred_xstart\"] * fac + x * (1 - fac)\n x_in_grad = torch.zeros_like(x_in)\n for i in range(self.cutn_batches):\n clip_in = self.normalize(self.make_cutouts(x_in.add(1).div(2)))\n image_embeds = self.clip_model.encode_image(clip_in).float()\n dists = spherical_dist_loss(\n image_embeds.unsqueeze(1), self.target_embeds.unsqueeze(0)\n )\n dists = dists.view([self.cutn, n, -1])\n losses = dists.mul(self.weights).sum(2).mean(0)\n x_in_grad += (\n torch.autograd.grad(losses.sum() * self.clip_guidance_scale, x_in)[0]\n / self.cutn_batches\n )\n tv_losses = tv_loss(x_in)\n range_losses = range_loss(out[\"pred_xstart\"])\n loss = tv_losses.sum() * self.tv_scale + range_losses.sum() * self.range_scale\n if self.init is not None and self.init_scale:\n init_losses = self.lpips_model(x_in, self.init)\n loss = loss + init_losses.sum() * self.init_scale\n x_in_grad += torch.autograd.grad(loss, x_in)[0]\n grad = -torch.autograd.grad(x_in, x, x_in_grad)[0]\n return grad\n\n def model_init(self, init_image: Image.Image = None) -> None:\n if self.seed is not None:\n torch.manual_seed(self.seed)\n\n self.make_cutouts = MakeCutouts(self.clip_size, self.cutn, self.cut_pow)\n self.side_x = self.side_y = self.model_config[\"image_size\"]\n\n self.target_embeds, self.weights = [], []\n\n for prompt in self.prompts:\n txt, weight = parse_prompt(prompt)\n self.target_embeds.append(\n self.clip_model.encode_text(clip.tokenize(txt).to(self.device)).float()\n )\n self.weights.append(weight)\n\n # TODO: Implement image prompt parsing\n # for prompt in self.image_prompts:\n # path, weight = parse_prompt(prompt)\n # img = Image.open(fetch(path)).convert('RGB')\n # img = TF.resize(img, min(side_x, side_y, *img.size), transforms.InterpolationMode.LANCZOS)\n # batch = make_cutouts(TF.to_tensor(img).unsqueeze(0).to(device))\n # embed = clip_model.encode_image(normalize(batch)).float()\n # target_embeds.append(embed)\n # weights.extend([weight / cutn] * cutn)\n\n self.target_embeds = torch.cat(self.target_embeds)\n self.weights = torch.tensor(self.weights, device=self.device)\n if self.weights.sum().abs() < 1e-3:\n raise RuntimeError(\"The weights must not sum to 0.\")\n self.weights /= self.weights.sum().abs()\n\n self.init = None\n if init_image is not None:\n self.init = init_image.resize((self.side_x, self.side_y), Image.LANCZOS)\n self.init = (\n TF.to_tensor(self.init).to(self.device).unsqueeze(0).mul(2).sub(1)\n )\n\n # LPIPS not required if init_image not used!\n if self.init is None:\n self.lpips_model = None\n else:\n self.lpips_model = lpips.LPIPS(net=\"vgg\").to(self.device)\n\n if self.model_config[\"timestep_respacing\"].startswith(\"ddim\"):\n sample_fn = self.diffusion.ddim_sample_loop_progressive\n else:\n sample_fn = self.diffusion.p_sample_loop_progressive\n\n self.cur_t = self.diffusion.num_timesteps - self.skip_timesteps - 1\n\n if self.ckpt == \"512x512 HQ Cond\":\n print(\"Using conditional sampling fn\")\n self.samples = sample_fn(\n self.model,\n (self.batch_size, 3, self.side_y, self.side_x),\n clip_denoised=False,\n model_kwargs={\n \"y\": torch.zeros(\n [self.batch_size], device=self.device, dtype=torch.long\n )\n },\n cond_fn=self.cond_fn_conditional,\n progress=True,\n skip_timesteps=self.skip_timesteps,\n init_image=self.init,\n randomize_class=True,\n )\n else:\n print(\"Using unconditional sampling fn\")\n self.samples = sample_fn(\n self.model,\n (self.batch_size, 3, self.side_y, self.side_x),\n clip_denoised=False,\n model_kwargs={},\n cond_fn=self.cond_fn,\n progress=True,\n skip_timesteps=self.skip_timesteps,\n init_image=self.init,\n randomize_class=True,\n cond_fn_with_grad=True,\n )\n\n self.samplesgen = enumerate(self.samples)\n\n def iterate(self):\n self.cur_t -= 1\n _, sample = next(self.samplesgen)\n\n ims = []\n for _, image in enumerate(sample[\"pred_xstart\"]):\n im = TF.to_pil_image(image.add(1).div(2).clamp(0, 1))\n ims.append(im)\n\n return ims\n"
] | [
[
"torch.nn.functional.normalize",
"torch.randint",
"torch.enable_grad",
"torch.ones",
"torch.cat",
"torch.load",
"torch.manual_seed",
"torch.zeros",
"torch.zeros_like",
"torch.tensor",
"torch.nn.functional.adaptive_avg_pool2d",
"torch.rand",
"torch.cuda.is_available",
"torch.autograd.grad",
"torch.nn.functional.pad"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
jurreht/cic | [
"95a5e32eeb26da8d18642add2259f164426e1a25",
"95a5e32eeb26da8d18642add2259f164426e1a25"
] | [
"tests/cic_test.py",
"cic/cic.py"
] | [
"import os\n\nimport numpy as np\nfrom numpy.testing import assert_allclose\nimport pytest\nimport scipy.io\nimport scipy.stats\n\nimport cic\n\n\ndef cases():\n \"\"\"\n Loads all filenames of the pre-calculated test cases.\n \"\"\"\n case_dir = os.path.join(\n os.path.dirname(os.path.realpath(__file__)),\n 'cases'\n )\n cases = []\n for dir_path, _, files in os.walk(case_dir):\n cases = cases + [os.path.join(dir_path, f) for f in files]\n return cases\n\n\[email protected]('inpath', cases())\n# Run both serially and in parallel\[email protected]('n_jobs', [None, -1])\ndef test_cic(inpath, n_jobs):\n np.random.seed(323490)\n\n # Load the case\n objs = scipy.io.loadmat(inpath)\n\n y00 = objs['y00'][:, 0]\n y01 = objs['y01'][:, 0]\n y10 = objs['y10'][:, 0]\n y11 = objs['y11'][:, 0]\n\n est_qte, se_qte, est_ate, se_ate = cic.calculate_cic(\n y00, y01, y10, y11, n_bootstraps=499, n_draws=10000,\n moments=[np.mean],\n n_jobs=n_jobs,\n # The original code uses some small (in my view unneccessary)\n # numerical corrections when calculating cdf's and inverse cdf's.\n # Without using them here also there will always be some test\n # cases slightly off.\n use_corrections=True\n )\n est_test = objs['est'][0, 1:10]\n se_test = objs['se'][1, 1:10]\n\n # Test quantile treatment effects\n assert_allclose(est_qte, est_test)\n assert_allclose(se_qte, se_test, atol=5e-2, rtol=1e-3)\n\n # Test average treatment effect\n # It is possible to get closer than an atol of 5e-3 by increasing n_draws\n # above, at the cost of slower tests\n assert_allclose(est_ate[0], objs['est'][0, 0], atol=5e-3)\n assert_allclose(se_ate[0], objs['se'][1, 0], atol=5e-2, rtol=1e-3)\n\n\[email protected](\n 'inpath',\n # exp8 and exp10 don't pass without use_corrections, which is only\n # supported for the simple case.\n [c for c in cases() if not ('exp8' in c or 'exp10' in c)])\ndef test_multiple_cic_from_simple_case(inpath):\n np.random.seed(442342234)\n\n # Load the case\n objs = scipy.io.loadmat(inpath)\n\n y00 = objs['y00'][:, 0]\n y01 = objs['y01'][:, 0]\n y10 = objs['y10'][:, 0]\n y11 = objs['y11'][:, 0]\n\n y = np.concatenate([y00, y01, y10, y11])\n g = np.concatenate([np.zeros(y00.shape[0] + y01.shape[0], dtype=np.int_),\n np.ones(y10.shape[0] + y11.shape[0], dtype=np.int_)])\n t = np.concatenate([np.zeros(y00.shape[0], dtype=np.int_),\n np.ones(y01.shape[0], dtype=np.int_),\n np.zeros(y10.shape[0], dtype=np.int_),\n np.ones(y11.shape[0], dtype=np.int_)])\n treat = np.array([[0, 0], [0, 1]], dtype=np.bool_)\n\n model = cic.CICModel(y, g, t, treat, n_bootstraps=499, moments=[np.mean],\n n_draws=10000)\n\n assert np.all(model.treatment_for == np.array([[1, 1]], dtype=np.int_))\n\n est_test = objs['est'][0, 1:10]\n se_test = objs['se'][1, 1:10]\n\n assert_allclose(model.quantile_effect[0], est_test)\n assert_allclose(model.quantile_se[0], se_test, atol=5e-2, rtol=1e-3)\n # Test average treatment effect\n # It is possible to get closer than an atol of 5e-3 by increasing n_draws\n # above, at the cost of slower tests\n assert_allclose(model.moment_effect[0], objs['est'][0, 0], atol=5e-3)\n assert_allclose(model.moment_se[0], objs['se'][1, 0], atol=5e-2, rtol=1e-3)\n\n\ndef test_cic_model_no_effect():\n \"\"\"\n Test a 3x3 CIC model where none of the treatments have any effect.\n The test is done by simulating and estimating the model many times\n and checking the coverage of the confidence intervals.\n \"\"\"\n np.random.seed(45354354)\n\n treat = np.array([\n [0, 0, 0],\n [0, 0, 1],\n [0, 1, 1]\n ], dtype=np.bool)\n\n n_trials = 250\n n_obs = 1000\n quantiles = np.array([0.1, .3, .5, .7, .9])\n effect_in_ci = np.zeros((3, quantiles.shape[0]), dtype=np.int_)\n for trial_ind in range(n_trials):\n g, t, y = generate_sample(n_obs)\n model = cic.CICModel(y, g, t, treat, quantiles)\n effect_in_ci += (\n (model.quantile_effect - 1.96 * model.quantile_se <= 0) &\n (model.quantile_effect + 1.96 * model.quantile_se >= 0))\n\n coverage = effect_in_ci / n_trials\n assert_allclose(coverage, np.ones_like(coverage) * .95, rtol=5e-2)\n\n\ndef test_cic_model_shift_effect():\n \"\"\"\n Test a 3x3 CIC model where the treatments are linear shifts, but\n different for different groups and times.\n The test is done by simulating and estimating the model many times\n and checking the coverage of the confidence intervals.\n \"\"\"\n np.random.seed(45354354)\n\n treat = np.array([\n [0, 0, 0],\n [0, 0, 1],\n [0, 1, 1]\n ], dtype=np.bool)\n\n n_trials = 250\n n_obs = 1000\n quantiles = np.array([.25, .5, .75])\n moments = [np.mean, np.std]\n quantile_in_ci = np.zeros((3, 3, 3), dtype=np.int_)\n moment_in_ci = np.zeros((3, 3, 2), dtype=np.int_)\n for trial_ind in range(n_trials):\n g, t, y = generate_sample(n_obs)\n y[(g == 1) & (t == 2)] += 1\n y[(g == 2) & (t == 1)] -= 1\n y[(g == 2) & (t == 2)] -= 2\n model = cic.CICModel(y, g, t, treat, quantiles, moments)\n\n mean, se = model.treatment_quantile(1, 2)\n quantile_in_ci[:, 0] += ((mean - 1.96 * se <= 1) &\n (mean + 1.96 * se >= 1))\n mean, se = model.treatment_quantile(2, 1)\n quantile_in_ci[:, 1] += ((mean - 1.96 * se <= -1) &\n (mean + 1.96 * se >= -1))\n mean, se = model.treatment_quantile(2, 2)\n quantile_in_ci[:, 2] += ((mean - 1.96 * se <= -2) &\n (mean + 1.96 * se >= -2))\n\n mean, se = model.treatment_moment(1, 2)\n moment_in_ci[:, 0, 0] += ((mean[0] - 1.96 * se[0] <= 1) &\n (mean[0] + 1.96 * se[0] >= 1))\n moment_in_ci[:, 0, 1] += ((mean[1] - 1.96 * se[1] <= 0) &\n (mean[1] + 1.96 * se[1] >= 0))\n mean, se = model.treatment_moment(2, 1)\n moment_in_ci[:, 1, 0] += ((mean[0] - 1.96 * se[0] <= -1) &\n (mean[0] + 1.96 * se[0] >= -1))\n moment_in_ci[:, 1, 1] += ((mean[1] - 1.96 * se[1] <= 0) &\n (mean[1] + 1.96 * se[1] >= 0))\n mean, se = model.treatment_moment(2, 2)\n moment_in_ci[:, 2, 0] += ((mean[0] - 1.96 * se[0] <= -2) &\n (mean[0] + 1.96 * se[0] >= -2))\n moment_in_ci[:, 2, 1] += ((mean[1] - 1.96 * se[1] <= 0) &\n (mean[1] + 1.96 * se[1] >= 0))\n\n quantile_coverage = quantile_in_ci / n_trials\n assert_allclose(quantile_coverage,\n np.ones_like(quantile_coverage) * .95,\n rtol=5e-2)\n moment_coverage = moment_in_ci / n_trials\n assert_allclose(moment_coverage,\n np.ones_like(moment_in_ci) * .95,\n rtol=5e-2)\n\n\ndef test_cic_model_dispersion_effect():\n \"\"\"\n Test a 3x3 CIC model where treatments are multiplying the distribution\n by some number, which differs by group and time.\n The test is done by simulating and estimating the model many times\n and checking the coverage of the confidence intervals.\n \"\"\"\n np.random.seed(45354354)\n\n treat = np.array([\n [0, 0, 0],\n [0, 0, 1],\n [0, 1, 1]\n ], dtype=np.bool)\n\n n_trials = 250\n n_obs = 2000\n quantiles = np.array([.5])\n moments = [np.mean, np.std]\n quantile_in_ci = np.zeros((3, 3, 1), dtype=np.int_)\n moment_in_ci = np.zeros((3, 3, 2), dtype=np.int_)\n for trial_ind in range(n_trials):\n g, t, y = generate_sample(n_obs)\n y[(g == 1) & (t == 2)] *= 2\n y[(g == 2) & (t == 1)] *= 3\n y[(g == 2) & (t == 2)] *= .5\n model = cic.CICModel(y, g, t, treat, quantiles, moments)\n\n # Q_{aX}(p) = a Q_X(p) for a quantile function Q and a > 0.\n # The median here is 1000, 2 * 1000 = 2000, hence the QTE is 1000\n mean, se = model.treatment_quantile(1, 2)\n quantile_in_ci[:, 0] += ((mean - 1.96 * se <= 1000) &\n (mean + 1.96 * se >= 1000))\n # The median here is 0, 3 * 0 = 0, hence the QTE is 0\n mean, se = model.treatment_quantile(2, 1)\n quantile_in_ci[:, 1] += ((mean - 1.96 * se <= 0) &\n (mean + 1.96 * se >= 0))\n # The median here is 1000, .5 * 1000 = 500, hence the QTE is -500\n mean, se = model.treatment_quantile(2, 2)\n quantile_in_ci[:, 2] += ((mean - 1.96 * se <= -500) &\n (mean + 1.96 * se >= -500))\n\n mean, se = model.treatment_moment(1, 2)\n # The mean goes from 1000 to 2000 => ATE = 1000\n moment_in_ci[:, 0, 0] += ((mean[0] - 1.96 * se[0] <= 1000) &\n (mean[0] + 1.96 * se[0] >= 1000))\n # The standard deviation goes from 1 to 2 => TE = 1\n moment_in_ci[:, 0, 1] += ((mean[1] - 1.96 * se[1] <= 1) &\n (mean[1] + 1.96 * se[1] >= 1))\n mean, se = model.treatment_moment(2, 1)\n # The mean goes from 0 to 0 => ATE = 0\n moment_in_ci[:, 1, 0] += ((mean[0] - 1.96 * se[0] <= 0) &\n (mean[0] + 1.96 * se[0] >= 0))\n # The standard deviation goes from 1/3 to 1 => TE = 2/3\n moment_in_ci[:, 1, 1] += ((mean[1] - 1.96 * se[1] <= 2 / 3) &\n (mean[1] + 1.96 * se[1] >= 2 / 3))\n mean, se = model.treatment_moment(2, 2)\n # The mean goes from 1000 to 500 => ATE = -500\n moment_in_ci[:, 2, 0] += ((mean[0] - 1.96 * se[0] <= -500) &\n (mean[0] + 1.96 * se[0] >= -500))\n # The standard deviation goes from 1 to .5 => TE = -.5\n moment_in_ci[:, 2, 1] += ((mean[1] - 1.96 * se[1] <= -.5) &\n (mean[1] + 1.96 * se[1] >= -.5))\n\n quantile_coverage = quantile_in_ci / n_trials\n assert_allclose(quantile_coverage,\n np.ones_like(quantile_coverage) * .95,\n rtol=5e-2)\n moment_coverage = moment_in_ci / n_trials\n assert_allclose(moment_coverage,\n np.ones_like(moment_in_ci) * .95,\n rtol=5e-2)\n\n\ndef test_test_model_based_on_quantile_valid():\n np.random.seed(3423482)\n\n treat = np.array([\n [0, 0, 0],\n [0, 0, 1],\n [0, 1, 1]\n ], dtype=np.bool)\n\n n_trials = 100\n n_obs = 500\n quantiles = np.array([.5])\n reject = 0\n for trial_ind in range(n_trials):\n g, t, y = generate_sample(n_obs)\n # y[(g == 1) & (t == 2)] = 2 * y[(g == 1) & (t == 2)] - 3\n # y[(g == 2) & (t == 1)] = np.exp(y[(g == 2) & (t == 1)])\n # y[(g == 1) & (t == 2)] *= 2\n # y[(g == 2) & (t == 1)] -= 3\n # y[(g == 2) & (t == 2)] += 1\n model = cic.CICModel(y, g, t, treat, quantiles)\n\n test_stat, rank_dist = model.test_model_based_on_quantile(0)\n crit_val = scipy.stats.chi2.ppf(.95, rank_dist)\n # import pdb; pdb.set_trace()\n if test_stat > crit_val:\n reject += 1\n\n reject_prob = reject / n_trials\n # Just check that the rejection probability is not too large.\n # To get reject_prob~0.05 increse n_obs above, but this slows\n # down the test too much.\n assert reject_prob <= 0.05\n\n\ndef test_combine_effects():\n np.random.seed(4545543)\n\n treat = np.array([\n [0, 0, 0],\n [0, 1, 1]\n ], dtype=np.bool)\n g = np.concatenate((np.zeros(3000, dtype=np.int_), np.ones(4000, dtype=np.int_)))\n t = np.concatenate((np.full(1000, 0), np.full(1000, 1), np.full(1000, 2),\n np.full(1000, 0), np.full(1000, 1), np.full(2000, 2)))\n y = np.random.randn(7000)\n y[(g == 1) & (t == 1)] += 1\n y[(g == 1) & (t == 2)] += 2\n model = cic.CICModel(y, g, t, treat, np.array([.5, .6]), [np.mean], n_draws=2000)\n qte_effect, _, moment_effect, _ = model.combine_effects([(1, 1), (1, 2)])\n true_effect = 1 / 3 + 2 * 2 / 3\n assert_allclose(qte_effect, true_effect, rtol=5e-2)\n assert_allclose(moment_effect, true_effect, rtol=5e-2)\n\n\ndef generate_sample(n_obs):\n g = np.random.choice(np.arange(3), n_obs)\n t = np.random.choice(np.arange(3), n_obs)\n\n u = np.random.randn(n_obs)\n y = np.empty(n_obs)\n y[t == 0] = u[t == 0]**3\n y[t == 1] = u[t == 1] / 3\n y[t == 2] = u[t == 2] + 1000\n\n return g, t, y\n",
"import functools\nimport itertools\n\nimport joblib\nimport numba\nimport numpy as np\n\n\ndef calculate_cic(\n y00, y01, y10, y11, quantiles=np.linspace(.1, .9, 9), moments=None,\n n_bootstraps=99, n_draws=1000, n_jobs=None, use_corrections=False\n):\n r\"\"\"\n Estimates a model using the Changes-In-Changes estimator.\n\n This function estimates non-linear treatments effects using\n the Athey & Imbens [1]_ changes-in-changes estimator. Only\n the case with continuous data is supported. `calculate_cic`\n calculates quantile treatment effects, as well as treatment\n effects on arbitrary user-specified functions of the distribution.\n The latter are calculated by simulating from the counterfactual\n distribution. Standard errors are computed using the bootstrap.\n\n Parameters\n ----------\n y00 : array_like\n Observations in the untreated group before the intervention.\n y01 : array_like\n Observations in the untreated group after the intervention.\n y10 : array_like\n Observations in the treated group before the intervention.\n y11 : array_like\n Observations in the treated group after the intervention.\n quantiles : array_like, optional\n Quantiles at which quantile treatment effects are calculated.\n Default is {.1, .2, ..., .9}.\n moments : sequence, optional\n A sequence of user-defined functions. These functions can be\n used to calculate the treatment effect on arbitrary \"moments\"\n of the distribution. Every element should take a single argument,\n which is a (simulated or observed) sample for which the\n moment should be calculated, and should return a single number,\n which is the calculated moment.\n n_bootstraps : int, optional\n Number of bootstrap simulations to calculate standard errors.\n Set to 0 to prevent bootstrapping. In this case, calculated\n standard errors will equal zero.\n n_draws : int, optional\n Number of draws from the counterfactual distribution to\n calculate the treatment effect of user-supplied moments. Only\n relevant if ``moments is not None``.\n n_jobs : int, optional\n Number of parallel jobs to use for bootstrapping standard\n errors. When None (the default), bootstrap serially. Otherwise,\n this interpreted in as in joblib.Parallel, i.e. specify a\n positive int to run that many jobs and a negative int to run\n ``num_cpu + 1 + n_jobs`` jobs.\n use_corrections : bool, optional\n Use numerical corrections when calculating CDF's and inverse\n CDF's as in the original code by Athey & Imbens. Set to\n True to obtain quantile treatment effects that are numerically\n equivalent to those calculated using the original codes. In\n general, using this parameter is unnecessary and discouraged,\n see the notes below.\n\n Returns\n -------\n estimated_quantile_effects : array_like\n Estimated quantile treatment effects for every point\n in `quantiles` in order.\n bootstrap_quantile_se : array_like\n Bootstrapped standard errors for every point in\n `quantiles` in order.\n estimated_moment_effects : array_like, optional\n Estimated treatment effects for every function\n specified in `moments`. Only returned when\n ``moments is not None``.\n bootstrap_moment_se : array_like, optional\n Bootstrapped standard errors for every function\n specified in `moments`. Only returned when\n ``moments is not None``.\n\n Notes\n -----\n\n `calculate_cic` calculates the exact counterfactual distribution,\n :math:`\\bar{F}_{11}`, using\n\n .. math:: \\bar{F}_{11}(x) = \\hat{F}_{10}(\\hat{F}_{00}^{-1}(\\hat{F}_{01}(x))),\n\n where :math:`\\hat{F}_{it}` is the empirical cdf of group :math:`i` in\n period :math:`t`.\n\n Quantile treatment effects are calculated using the generalized\n inverse cdf:\n\n .. math:: \\begin{align*}\n F^{-1}(p) &= \\inf\\{x \\in \\mathbb{R} : F(x) \\ge p\\} \\\\\n \\text{qte}(p) &= \\hat{F}_{11}^{-1}(p) - \\bar{F}_{11}^{-1}(p)\n \\end{align*}\n\n Moments are calculated by using a probability integral transform\n to sample from :math:`\\bar{F}_{11}`.\n\n In general, `calculate_cic` does not give numerically equivalent\n results to the original code used by Athey & Imbens [2]_. The\n reason is that their code makes small numerical adjustments when\n calculating cdf's and inverse cdf's. In particular, they calculate\n cdf's as :math:`F(x) = P(X \\le x + 0.00001)` and inverse cdf's as\n :math:`F^{-1}(x) = \\inf\\{x : F(x) \\ge p - 0.000001\\}`. (Not that\n the correction factors differ by a factor 10!) According to the\n comments, this is to \"prevent numerical problems\". Presumably,\n this is because in general floating point comparison is a bad\n idea. However, because during the calculation of counterfactual\n cdf's floats are only copied and not modified, there is no\n reason to be afraid of floating point comparisons in this case.\n Nevertheless, the user can provide the parameter `use_corrections`\n to use the same corrections as the Athey & Imbey codes. In this case,\n the calculated quantile treatment effects will be numerically\n equivalent. This option is included mainly to enable unit testing,\n users are discouraged from using it because it will in general\n lead to slightly wrong results.\n\n References\n ----------\n .. [1] Athey, Susan, and Guido W. Imbens. 2006. \"Identification and\n Inference in nonlinear difference‐in‐differences models.\"\n *Econometrica* 74 (2): 431-497.\n .. [2] Athey, Susan and Guido W. Imbens. 2006. \"CIC Code\".\n Accessed April 11, 2019. https://athey.people.stanford.edu/research.\n \"\"\"\n if use_corrections:\n cdf_corr = 0.00001\n inv_corr = 0.000001\n else:\n cdf_corr = inv_corr = 0\n\n # Use the same draws for calculating moments during effect size\n # calculation as during bootstrapping\n draws = np.random.uniform(size=n_draws)\n\n # Quantiles and draws need to be sorted for get_quantiles()\n quantiles.sort()\n draws.sort()\n\n estimated_quantile_effects, estimated_moment_effects = calculate_effects(\n y00, y01, y10, y11, quantiles, moments, draws, cdf_corr, inv_corr)\n\n # Bootstrap standard errors\n if n_jobs is None:\n # Run sequentially\n bootstrap_quantile_eff, bootstrap_moment_eff = zip(*map(\n lambda _: bootstrap_sample(y00, y01, y10, y11, quantiles, moments,\n draws, cdf_corr, inv_corr),\n range(n_bootstraps)))\n else:\n # Run on multiple cores\n # Use threads a background since most of the time will be\n # spent in NumPy routines, which release the GIL\n ret = joblib.Parallel(n_jobs=n_jobs, prefer='threads')(\n joblib.delayed(bootstrap_sample)(y00, y01, y10, y11, quantiles,\n moments, draws, cdf_corr,\n inv_corr)\n for _ in range(n_bootstraps)\n )\n bootstrap_quantile_eff, bootstrap_moment_eff = zip(*ret)\n # Concatenate into a single numpy array\n bootstrap_quantile_eff = np.concatenate([\n x[np.newaxis] for x in bootstrap_quantile_eff\n ], axis=0)\n bootstrap_moment_eff = np.concatenate([\n x[np.newaxis] for x in bootstrap_moment_eff\n ], axis=0)\n\n if n_bootstraps > 0:\n bootstrap_quantile_se = np.std(bootstrap_quantile_eff, axis=0)\n bootstrap_moment_se = np.std(bootstrap_moment_eff, axis=0)\n else:\n bootstrap_quantile_se = np.zeros(quantiles.shape[0])\n n_moments = len(moments) if moments is not None else 0\n bootstrap_moment_se = np.zeros(n_moments)\n\n if moments is None:\n return estimated_quantile_effects, bootstrap_quantile_se\n else:\n return (estimated_quantile_effects, bootstrap_quantile_se,\n estimated_moment_effects, bootstrap_moment_se)\n\n\nclass CICModel:\n def __init__(\n self, y, g, t, treat, quantiles=np.linspace(.1, .9, 9), moments=None,\n n_draws=1000, n_bootstraps=99, n_jobs=None\n ):\n self.quantiles = quantiles\n n_obs = y.shape[0]\n n_groups = treat.shape[0]\n n_periods = treat.shape[1]\n if t.shape[0] != n_obs:\n raise ValueError('len(y) should equal len(t).')\n if g.shape[0] != n_obs:\n raise ValueError('len(y) should equal len(g).')\n if t.max() >= n_periods:\n raise ValueError('Invalid period provided for some observations.')\n if g.max() >= n_groups:\n raise ValueError('Invalid group provided for some observations.')\n if np.any((~treat[:, 1:]) & (treat[:, 1:] ^ treat[:, :-1])):\n raise ValueError('A group cannot become untreated after becoming'\n ' treated.')\n self.g = g\n self.t = t\n\n # Use the same draws for calculating moments during effect size\n # calculation as during bootstrapping\n draws = np.random.uniform(size=n_draws)\n\n # Quantiles and draws need to be sorted for get_quantiles()\n quantiles.sort()\n draws.sort()\n\n # Calculate the effect using all possible combinations of treatment\n # and control\n possible_combinations = tuple(filter(\n lambda x: valid_combination(treat, *x),\n itertools.product(range(n_groups), range(n_periods), repeat=2)))\n self.effects = calculate_multiple_effects(\n y, g, t, possible_combinations, quantiles, moments, draws)\n\n # Bootstrap the covariance matrix of the treatments effects\n calc_bootstrap = functools.partial(\n self._bootstrap_multiple_effects, y, g, t, treat, quantiles,\n moments, possible_combinations, draws\n )\n if n_jobs is None:\n bootstrap_effects = np.empty((n_bootstraps, self.effects.shape[0],\n self.effects.shape[1]))\n for i in range(n_bootstraps):\n bootstrap_effects[i] = calc_bootstrap()\n else:\n bootstrap_effects = joblib.Parallel(n_jobs, prefer='threads', verbose=11)(\n joblib.delayed(calc_bootstrap)() for _ in range(n_bootstraps)\n )\n # bootstrap_effects is a list of ndarray's, make it a single\n # ndarray\n bootstrap_effects = np.concatenate([\n x[np.newaxis] for x in bootstrap_effects\n ], axis=0)\n\n # Calculate the combined effect\n self.n_treatment_effects = treat.sum()\n self.treatment_for = np.empty((self.n_treatment_effects, 2))\n # The matrix A maps `effects` into the (g, t)-treatment effect\n self.A = np.zeros((len(possible_combinations),\n self.n_treatment_effects))\n i = 0\n for g1, t1 in itertools.product(range(n_groups), range(n_periods)):\n if treat[g1, t1]:\n self.A[:, i] = tuple(map(\n lambda x: x[2] == g1 and x[3] == t1,\n possible_combinations\n ))\n self.treatment_for[i] = g1, t1\n i += 1\n\n effect = np.empty((self.n_treatment_effects, self.effects.shape[1]))\n effect_se = np.empty_like(effect)\n self.cov_inv = np.empty((self.effects.shape[1],\n len(possible_combinations),\n len(possible_combinations)))\n for effect_ind in range(self.effects.shape[1]):\n # TODO: The covariance of the bootstrap sample is not necessarily a\n # good estimator of the covariance matrix! Perhaps try also using\n # the percentile method. See Machado, Jose A.F. and Paulo Parente.\n # 2005. \"Bootstrap estimation of covariance matrices via the\n # percentile method.\" Econometrics Journal 8: 70-78.\n cov = np.cov(bootstrap_effects[:, :, effect_ind], rowvar=False,\n bias=True)\n if self.effects.shape[0] == 1:\n # In this case np.cov() returns a scalar. Invert it and make\n # it a matrix.\n cov_inv = (1 / cov)[np.newaxis, np.newaxis]\n else:\n cov_inv = np.linalg.pinv(cov)\n self.cov_inv[effect_ind] = cov_inv\n\n effect[:, effect_ind] = np.linalg.solve(\n self.A.T @ cov_inv @ self.A,\n self.A.T @ cov_inv @ self.effects[:, effect_ind])\n effect_cov = np.linalg.inv(self.A.T @ cov_inv @ self.A)\n effect_se[:, effect_ind] = np.sqrt(np.diag(effect_cov))\n\n self.all_effect = effect\n self.all_se = effect_se\n self.quantile_effect = effect[:, :quantiles.shape[0]]\n self.quantile_se = effect_se[:, :quantiles.shape[0]]\n if moments is None:\n self.moment_effect = np.empty((self.n_treatment_effects, 0))\n self.moment_se = np.empty_like(self.moment_effect)\n else:\n self.moment_effect = effect[:, quantiles.shape[0]:]\n self.moment_se = effect_se[:, quantiles.shape[0]:]\n\n def treatment_quantile(self, g, t):\n ind = self._treatment_ind(g, t)\n return self.quantile_effect[ind], self.quantile_se[ind]\n\n def treatment_moment(self, g, t):\n ind = self._treatment_ind(g, t)\n return self.moment_effect[ind], self.moment_se[ind]\n\n def _treatment_ind(self, g, t):\n row_match = (self.treatment_for == np.array([g, t])).all(axis=1)\n return np.nonzero(row_match)[0][0]\n\n def test_model_based_on_quantile(self, quantile_ind):\n effects_ind = quantile_ind\n mean_diff = (self.effects[:, effects_ind] -\n self.A @ self.quantile_effect[:, quantile_ind])\n cov_inv = self.cov_inv[effects_ind]\n test_stat = mean_diff.T @ cov_inv @ mean_diff\n # We need the rank of V here, and cov is the psuedo-inverse of V.\n # However, the rank of the pseudo-inverse is the same as of the\n # original matrix so there is no problem here.\n rank_dist = (np.linalg.matrix_rank(cov_inv) -\n self.n_treatment_effects)\n return test_stat, rank_dist\n\n def test_model_based_on_moment(self, moment_ind):\n effects_ind = moment_ind + self.quantiles.shape[0]\n mean_diff = (self.effects[:, effects_ind] -\n self.A @ self.moment_effect[:, moment_ind])\n cov_inv = self.cov_inv[effects_ind]\n test_stat = mean_diff.T @ cov_inv @ mean_diff\n # We need the rank of V here, and cov is the psuedo-inverse of V.\n # However, the rank of the pseudo-inverse is the same as of the\n # original matrix so there is no problem here.\n rank_dist = (np.linalg.matrix_rank(cov_inv) -\n self.n_treatment_effects)\n return test_stat, rank_dist\n\n def combine_effects(self, effects_for, weigh_by='n'):\n n_effects = self.all_effect.shape[1]\n weights = np.zeros((n_effects, self.n_treatment_effects, 1))\n if weigh_by == 'n':\n for i in range(self.n_treatment_effects):\n g, t = self.treatment_for[i]\n if (g, t) in effects_for:\n weights[:, i] = np.sum((self.g == g) & (self.t == t))\n weights /= weights[0].sum()\n elif weigh_by == 'cov':\n target = np.zeros((self.n_treatment_effects, 1),\n dtype=np.bool_)\n for i in range(self.n_treatment_effects):\n g, t = self.treatment_for[i]\n if (g, t) in effects_for:\n target[i] = True\n for effect_ind in range(n_effects):\n weights[effect_ind] = np.linalg.solve(\n target.T @ self.A.T @ self.cov_inv[effect_ind] @ self.A @ target,\n target.T @ self.A.T @ self.cov_inv[effect_ind] @ self.A\n ).T\n else:\n raise ValueError('Invalid value for weigh_by, use n or cov.')\n\n weighed_effects = np.empty(n_effects)\n weighed_se = np.empty_like(weighed_effects)\n for effect_ind in range(n_effects):\n weighed_effects[effect_ind] = (weights[effect_ind].T @\n self.all_effect[:, effect_ind])\n weighed_cov = weights[effect_ind].T @ np.linalg.solve(\n self.A.T @ self.cov_inv[effect_ind] @ self.A,\n weights[effect_ind])\n weighed_se[effect_ind] = np.sqrt(np.diag(weighed_cov))\n\n quantile_combined = weighed_effects[:self.quantiles.shape[0]]\n quantile_combined_se = weighed_se[:self.quantiles.shape[0]]\n moment_combined = weighed_effects[self.quantiles.shape[0]:]\n moment_combined_se = weighed_se[self.quantiles.shape[0]:]\n return (quantile_combined, quantile_combined_se, moment_combined,\n moment_combined_se)\n\n def _bootstrap_multiple_effects(\n self, y, g, t, treat, quantiles, moments, possible_combinations, draws\n ):\n y_resample = np.empty_like(y)\n n_groups = treat.shape[0]\n n_periods = treat.shape[1]\n for j, k in itertools.product(range(n_groups), range(n_periods)):\n target = (g == j) & (t == k)\n y_resample[target] = np.random.choice(y[target], target.sum(),\n replace=True)\n return calculate_multiple_effects(\n y_resample, g, t, possible_combinations, quantiles, moments,\n draws\n )\n\n\ndef calculate_effects(\n y00, y01, y10, y11, quantiles, moments, draws, cdf_corr, inv_corr\n):\n # Calculate quantile treatment effects\n observed_quantiles = get_quantiles(*cdf_support(y11, cdf_corr),\n quantiles, inv_corr)\n cf_cdf, cf_support = calc_cf_cdf(y00, y01, y10, cdf_corr, inv_corr)\n cf_quantiles = get_quantiles(cf_cdf, cf_support, quantiles, inv_corr)\n quantile_effects = observed_quantiles - cf_quantiles\n\n if moments is not None:\n observed_moments = np.array([f(y11) for f in moments])\n cf_draws = sample_from_cdf(cf_cdf, cf_support, draws)\n cf_moments = np.array([f(cf_draws) for f in moments])\n moment_effects = observed_moments - cf_moments\n\n return quantile_effects, moment_effects\n else:\n return quantile_effects, None\n\n\ndef calculate_multiple_effects(\n y, g, t, possible_combinations, quantiles, moments, draws\n):\n n_targets = quantiles.shape[0]\n if moments is not None:\n n_targets += len(moments)\n effects = np.empty((len(possible_combinations), n_targets))\n for i, (g0, t0, g1, t1) in enumerate(possible_combinations):\n y00 = y[(g == g0) & (t == t0)]\n y01 = y[(g == g0) & (t == t1)]\n y10 = y[(g == g1) & (t == t0)]\n y11 = y[(g == g1) & (t == t1)]\n # calculate_effects returns None as second element if moments is None.\n # When moments is not None, we want to concatenate the return elements.\n effects[i] = np.concatenate([\n x for x in\n calculate_effects(y00, y01, y10, y11, quantiles, moments,\n draws, 0, 0)\n if x is not None])\n return effects\n\n\ndef bootstrap_sample(\n y00, y01, y10, y11, quantiles, moments, draws, cdf_corr, inv_corr\n):\n y00_resample = np.random.choice(y00, y00.shape[0], replace=True)\n y01_resample = np.random.choice(y01, y01.shape[0], replace=True)\n y10_resample = np.random.choice(y10, y10.shape[0], replace=True)\n y11_resample = np.random.choice(y11, y11.shape[0], replace=True)\n\n return calculate_effects(\n y00_resample, y01_resample, y10_resample, y11_resample,\n quantiles, moments, draws, cdf_corr, inv_corr\n )\n\n\ndef cdf_support(y, cdf_corr):\n support = np.unique(y)\n if support.shape[0] == y.shape[0] and cdf_corr == 0:\n # In this common case we can achieve a speedup\n cdf = np.arange(1, y.shape[0] + 1) / y.shape[0]\n else:\n cdf = np.mean(y[:, np.newaxis] <= support[np.newaxis] + cdf_corr,\n axis=0)\n return cdf, support\n\n\ndef calc_cf_cdf(y00, y01, y10, cdf_corr, inv_corr):\n cdf, support = cdf_support(y01, cdf_corr)\n # Do not use np.quantile() here because there is no way to make\n # it behave like the generalized inverse cdf (which is what we want).\n cdf = get_quantiles(*cdf_support(y00, cdf_corr), cdf, inv_corr)\n cdf = np.mean(y10[:, np.newaxis] <= cdf[np.newaxis] + cdf_corr, axis=0)\n cdf[-1] = 1\n return cdf, support\n\n\[email protected](nopython=True, cache=True, nogil=True)\ndef get_quantiles(cdf, support, quantiles, inv_corr):\n ret = np.empty(quantiles.shape[0])\n q_ind = 0\n p = quantiles[0] - inv_corr\n for i in range(cdf.shape[0]):\n while cdf[i] >= p:\n ret[q_ind] = support[i]\n q_ind += 1\n if q_ind >= quantiles.shape[0]:\n break\n p = quantiles[q_ind] - inv_corr\n if q_ind >= quantiles.shape[0]:\n break\n return ret\n\n\ndef sample_from_cdf(cdf, support, draws):\n return get_quantiles(cdf, support, draws, 0)\n\n\ndef valid_combination(treat, g0, t0, g1, t1):\n return ((not (treat[g0, t0] or treat[g0, t1] or treat[g1, t0])) and\n treat[g1, t1])\n"
] | [
[
"numpy.ones_like",
"numpy.random.seed",
"numpy.arange",
"numpy.ones",
"numpy.concatenate",
"numpy.full",
"numpy.random.randn",
"numpy.testing.assert_allclose",
"numpy.array",
"numpy.zeros",
"numpy.empty"
],
[
"numpy.diag",
"numpy.linalg.matrix_rank",
"numpy.linspace",
"numpy.concatenate",
"numpy.mean",
"numpy.any",
"numpy.unique",
"numpy.empty_like",
"numpy.arange",
"numpy.std",
"numpy.zeros",
"numpy.nonzero",
"numpy.random.choice",
"numpy.linalg.inv",
"numpy.cov",
"numpy.array",
"numpy.sum",
"numpy.linalg.solve",
"numpy.linalg.pinv",
"numpy.random.uniform",
"numpy.empty"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
hannesdm/shap | [
"ae96bef7879f47978c8a436ebf19c2f2747cd887"
] | [
"shap/explainers/_deep/deep_tf.py"
] | [
"import numpy as np\nimport warnings\nfrom .._explainer import Explainer\nfrom packaging import version\nfrom ..tf_utils import _get_session, _get_graph, _get_model_inputs, _get_model_output\nkeras = None\ntf = None\ntf_ops = None\ntf_backprop = None\ntf_execute = None\ntf_gradients_impl = None\n\ndef custom_record_gradient(op_name, inputs, attrs, results):\n \"\"\" This overrides tensorflow.python.eager.backprop._record_gradient.\n\n We need to override _record_gradient in order to get gradient backprop to\n get called for ResourceGather operations. In order to make this work we\n temporarily \"lie\" about the input type to prevent the node from getting\n pruned from the gradient backprop process. We then reset the type directly\n afterwards back to what it was (an integer type).\n \"\"\"\n reset_input = False\n if op_name == \"ResourceGather\" and inputs[1].dtype == tf.int32:\n inputs[1].__dict__[\"_dtype\"] = tf.float32\n reset_input = True\n\n try:\n out = tf_backprop._record_gradient(\"shap_\"+op_name, inputs, attrs, results) # old TF2.0 versions\n except AttributeError:\n out = tf_backprop.record_gradient(\"shap_\"+op_name, inputs, attrs, results)\n\n if reset_input:\n inputs[1].__dict__[\"_dtype\"] = tf.int32\n\n return out\n\nclass TFDeep(Explainer):\n \"\"\"\n Using tf.gradients to implement the backgropagation was\n inspired by the gradient based implementation approach proposed by Ancona et al, ICLR 2018. Note\n that this package does not currently use the reveal-cancel rule for ReLu units proposed in DeepLIFT.\n \"\"\"\n\n def __init__(self, model, data, session=None, learning_phase_flags=None):\n \"\"\" An explainer object for a deep model using a given background dataset.\n\n Note that the complexity of the method scales linearly with the number of background data\n samples. Passing the entire training dataset as `data` will give very accurate expected\n values, but be unreasonably expensive. The variance of the expectation estimates scale by\n roughly 1/sqrt(N) for N background data samples. So 100 samples will give a good estimate,\n and 1000 samples a very good estimate of the expected values.\n\n Parameters\n ----------\n model : tf.keras.Model or (input : [tf.Operation], output : tf.Operation)\n A keras model object or a pair of TensorFlow operations (or a list and an op) that\n specifies the input and output of the model to be explained. Note that SHAP values\n are specific to a single output value, so you get an explanation for each element of\n the output tensor (which must be a flat rank one vector).\n\n data : [numpy.array] or [pandas.DataFrame] or function\n The background dataset to use for integrating out features. DeepExplainer integrates\n over all these samples for each explanation. The data passed here must match the input\n operations given to the model. If a function is supplied, it must be a function that\n takes a particular input example and generates the background dataset for that example\n session : None or tensorflow.Session\n The TensorFlow session that has the model we are explaining. If None is passed then\n we do our best to find the right session, first looking for a keras session, then\n falling back to the default TensorFlow session.\n\n learning_phase_flags : None or list of tensors\n If you have your own custom learning phase flags pass them here. When explaining a prediction\n we need to ensure we are not in training mode, since this changes the behavior of ops like\n batch norm or dropout. If None is passed then we look for tensors in the graph that look like\n learning phase flags (this works for Keras models). Note that we assume all the flags should\n have a value of False during predictions (and hence explanations).\n\n \"\"\"\n # try and import keras and tensorflow\n global tf, tf_ops, tf_backprop, tf_execute, tf_gradients_impl\n if tf is None:\n from tensorflow.python.framework import ops as tf_ops # pylint: disable=E0611\n from tensorflow.python.ops import gradients_impl as tf_gradients_impl # pylint: disable=E0611\n from tensorflow.python.eager import backprop as tf_backprop\n from tensorflow.python.eager import execute as tf_execute\n if not hasattr(tf_gradients_impl, \"_IsBackpropagatable\"):\n from tensorflow.python.ops import gradients_util as tf_gradients_impl\n import tensorflow as tf\n if version.parse(tf.__version__) < version.parse(\"1.4.0\"):\n warnings.warn(\"Your TensorFlow version is older than 1.4.0 and not supported.\")\n global keras\n if keras is None:\n try:\n import keras\n warnings.warn(\"keras is no longer supported, please use tf.keras instead.\")\n except:\n pass\n \n if version.parse(tf.__version__) >= version.parse(\"2.4.0\"):\n warnings.warn(\"Your TensorFlow version is newer than 2.4.0 and so graph support has been removed in eager mode and some static graphs may not be supported. See PR #1483 for discussion.\")\n\n # determine the model inputs and outputs\n self.model_inputs = _get_model_inputs(model)\n self.model_output = _get_model_output(model)\n assert type(self.model_output) != list, \"The model output to be explained must be a single tensor!\"\n assert len(self.model_output.shape) < 3, \"The model output must be a vector or a single value!\"\n self.multi_output = True\n if len(self.model_output.shape) == 1:\n self.multi_output = False\n\n if tf.executing_eagerly():\n if type(model) is tuple or type(model) is list:\n assert len(model) == 2, \"When a tuple is passed it must be of the form (inputs, outputs)\"\n from tensorflow.keras import Model\n self.model = Model(model[0], model[1])\n else:\n self.model = model\n\n # check if we have multiple inputs\n self.multi_input = True\n if type(self.model_inputs) != list or len(self.model_inputs) == 1:\n self.multi_input = False\n if type(self.model_inputs) != list:\n self.model_inputs = [self.model_inputs]\n if type(data) != list and (hasattr(data, '__call__')==False):\n data = [data]\n self.data = data\n\n self._vinputs = {} # used to track what op inputs depends on the model inputs\n self.orig_grads = {}\n\n if not tf.executing_eagerly():\n self.session = _get_session(session)\n\n self.graph = _get_graph(self)\n\n # if no learning phase flags were given we go looking for them\n # ...this will catch the one that keras uses\n # we need to find them since we want to make sure learning phase flags are set to False\n if learning_phase_flags is None:\n self.learning_phase_ops = []\n for op in self.graph.get_operations():\n if 'learning_phase' in op.name and op.type == \"Const\" and len(op.outputs[0].shape) == 0:\n if op.outputs[0].dtype == tf.bool:\n self.learning_phase_ops.append(op)\n self.learning_phase_flags = [op.outputs[0] for op in self.learning_phase_ops]\n else:\n self.learning_phase_ops = [t.op for t in learning_phase_flags]\n\n # save the expected output of the model\n # if self.data is a function, set self.expected_value to None\n if (hasattr(self.data, '__call__')):\n self.expected_value = None\n else:\n if self.data[0].shape[0] > 5000:\n warnings.warn(\"You have provided over 5k background samples! For better performance consider using smaller random sample.\")\n if not tf.executing_eagerly():\n self.expected_value = self.run(self.model_output, self.model_inputs, self.data).mean(0)\n else:\n if type(self.model)is tuple:\n sel.fModel(cnn.inputs, cnn.get_layer(theNameYouWant).outputs)\n self.expected_value = tf.reduce_mean(self.model(self.data), 0)\n\n if not tf.executing_eagerly():\n self._init_between_tensors(self.model_output.op, self.model_inputs)\n\n # make a blank array that will get lazily filled in with the SHAP value computation\n # graphs for each output. Lazy is important since if there are 1000 outputs and we\n # only explain the top 5 it would be a waste to build graphs for the other 995\n if not self.multi_output:\n self.phi_symbolics = [None]\n else:\n noutputs = self.model_output.shape.as_list()[1]\n if noutputs is not None:\n self.phi_symbolics = [None for i in range(noutputs)]\n else:\n raise Exception(\"The model output tensor to be explained cannot have a static shape in dim 1 of None!\")\n\n def _get_model_output(self, model):\n if len(model.layers[-1]._inbound_nodes) == 0:\n if len(model.outputs) > 1:\n warnings.warn(\"Only one model output supported.\")\n return model.outputs[0]\n else:\n return model.layers[-1].output\n\n def _init_between_tensors(self, out_op, model_inputs):\n # find all the operations in the graph between our inputs and outputs\n tensor_blacklist = tensors_blocked_by_false(self.learning_phase_ops) # don't follow learning phase branches\n dependence_breakers = [k for k in op_handlers if op_handlers[k] == break_dependence]\n back_ops = backward_walk_ops(\n [out_op], tensor_blacklist,\n dependence_breakers\n )\n start_ops = []\n for minput in model_inputs:\n for op in minput.consumers():\n start_ops.append(op)\n self.between_ops = forward_walk_ops(\n start_ops,\n tensor_blacklist, dependence_breakers,\n within_ops=back_ops\n )\n\n # note all the tensors that are on the path between the inputs and the output\n self.between_tensors = {}\n for op in self.between_ops:\n for t in op.outputs:\n self.between_tensors[t.name] = True\n for t in model_inputs:\n self.between_tensors[t.name] = True\n\n # save what types are being used\n self.used_types = {}\n for op in self.between_ops:\n self.used_types[op.type] = True\n\n def _variable_inputs(self, op):\n \"\"\" Return which inputs of this operation are variable (i.e. depend on the model inputs).\n \"\"\"\n if op not in self._vinputs:\n out = np.zeros(len(op.inputs), dtype=np.bool)\n for i,t in enumerate(op.inputs):\n out[i] = t.name in self.between_tensors\n self._vinputs[op] = out\n return self._vinputs[op]\n\n def phi_symbolic(self, i):\n \"\"\" Get the SHAP value computation graph for a given model output.\n \"\"\"\n if self.phi_symbolics[i] is None:\n\n if not tf.executing_eagerly():\n def anon():\n out = self.model_output[:,i] if self.multi_output else self.model_output\n return tf.gradients(out, self.model_inputs)\n\n self.phi_symbolics[i] = self.execute_with_overridden_gradients(anon)\n else:\n @tf.function\n def grad_graph(shap_rAnD):\n phase = tf.keras.backend.learning_phase()\n tf.keras.backend.set_learning_phase(0)\n\n with tf.GradientTape(watch_accessed_variables=False) as tape:\n tape.watch(shap_rAnD)\n out = self.model(shap_rAnD)\n if self.multi_output:\n out = out[:,i]\n\n self._init_between_tensors(out.op, shap_rAnD)\n x_grad = tape.gradient(out, shap_rAnD)\n tf.keras.backend.set_learning_phase(phase)\n return x_grad\n\n self.phi_symbolics[i] = grad_graph\n\n return self.phi_symbolics[i]\n\n def shap_values(self, X, ranked_outputs=None, output_rank_order=\"max\", check_additivity=True):\n # check if we have multiple inputs\n if not self.multi_input:\n if type(X) == list and len(X) != 1:\n assert False, \"Expected a single tensor as model input!\"\n elif type(X) != list:\n X = [X]\n else:\n assert type(X) == list, \"Expected a list of model inputs!\"\n assert len(self.model_inputs) == len(X), \"Number of model inputs (%d) does not match the number given (%d)!\" % (len(self.model_inputs), len(X))\n\n # rank and determine the model outputs that we will explain\n if ranked_outputs is not None and self.multi_output:\n if not tf.executing_eagerly():\n model_output_values = self.run(self.model_output, self.model_inputs, X)\n else:\n model_output_values = self.model(X)\n\n if output_rank_order == \"max\":\n model_output_ranks = np.argsort(-model_output_values)\n elif output_rank_order == \"min\":\n model_output_ranks = np.argsort(model_output_values)\n elif output_rank_order == \"max_abs\":\n model_output_ranks = np.argsort(np.abs(model_output_values))\n else:\n assert False, \"output_rank_order must be max, min, or max_abs!\"\n model_output_ranks = model_output_ranks[:,:ranked_outputs]\n else:\n model_output_ranks = np.tile(np.arange(len(self.phi_symbolics)), (X[0].shape[0], 1))\n\n # compute the attributions\n output_phis = []\n for i in range(model_output_ranks.shape[1]):\n phis = []\n for k in range(len(X)):\n phis.append(np.zeros(X[k].shape))\n for j in range(X[0].shape[0]):\n if (hasattr(self.data, '__call__')):\n bg_data = self.data([X[l][j] for l in range(len(X))])\n if type(bg_data) != list:\n bg_data = [bg_data]\n else:\n bg_data = self.data\n\n # tile the inputs to line up with the background data samples\n tiled_X = [np.tile(X[l][j:j+1], (bg_data[l].shape[0],) + tuple([1 for k in range(len(X[l].shape)-1)])) for l in range(len(X))]\n\n # we use the first sample for the current sample and the rest for the references\n joint_input = [np.concatenate([tiled_X[l], bg_data[l]], 0) for l in range(len(X))]\n\n # run attribution computation graph\n feature_ind = model_output_ranks[j,i]\n sample_phis = self.run(self.phi_symbolic(feature_ind), self.model_inputs, joint_input)\n\n # assign the attributions to the right part of the output arrays\n for l in range(len(X)):\n phis[l][j] = (sample_phis[l][bg_data[l].shape[0]:] * (X[l][j] - bg_data[l])).mean(0)\n\n output_phis.append(phis[0] if not self.multi_input else phis)\n\n # check that the SHAP values sum up to the model output\n if check_additivity:\n if not tf.executing_eagerly():\n model_output = self.run(self.model_output, self.model_inputs, X)\n else:\n model_output = self.model(X)\n for l in range(len(self.expected_value)):\n if not self.multi_input:\n diffs = model_output[:, l] - self.expected_value[l] - output_phis[l].sum(axis=tuple(range(1, output_phis[l].ndim)))\n else:\n diffs = model_output[:, l] - self.expected_value[l]\n for i in range(len(output_phis[l])):\n diffs -= output_phis[l][i].sum(axis=tuple(range(1, output_phis[l][i].ndim)))\n assert np.abs(diffs).max() < 1e-2, \"The SHAP explanations do not sum up to the model's output! This is either because of a \" \\\n \"rounding error or because an operator in your computation graph was not fully supported. If \" \\\n \"the sum difference of %f is significant compared the scale of your model outputs please post \" \\\n \"as a github issue, with a reproducable example if possible so we can debug it.\" % np.abs(diffs).max()\n\n if not self.multi_output:\n return output_phis[0]\n elif ranked_outputs is not None:\n return output_phis, model_output_ranks\n else:\n return output_phis\n\n def run(self, out, model_inputs, X):\n \"\"\" Runs the model while also setting the learning phase flags to False.\n \"\"\"\n if not tf.executing_eagerly():\n feed_dict = dict(zip(model_inputs, X))\n for t in self.learning_phase_flags:\n feed_dict[t] = False\n return self.session.run(out, feed_dict)\n else:\n def anon():\n tf_execute.record_gradient = custom_record_gradient\n\n # build inputs that are correctly shaped, typed, and tf-wrapped\n inputs = []\n for i in range(len(X)):\n shape = list(self.model_inputs[i].shape)\n shape[0] = -1\n data = X[i].reshape(shape)\n v = tf.constant(data, dtype=self.model_inputs[i].dtype)\n inputs.append(v)\n final_out = out(inputs)\n try:\n tf_execute.record_gradient = tf_backprop._record_gradient # old TF2 versions\n except AttributeError:\n tf_execute.record_gradient = tf_backprop.record_gradient\n\n\n return final_out\n return self.execute_with_overridden_gradients(anon)\n\n def custom_grad(self, op, *grads):\n \"\"\" Passes a gradient op creation request to the correct handler.\n \"\"\"\n type_name = op.type[5:] if op.type.startswith(\"shap_\") else op.type\n out = op_handlers[type_name](self, op, *grads) # we cut off the shap_ prefex before the lookup\n return out\n\n def execute_with_overridden_gradients(self, f):\n # replace the gradients for all the non-linear activations\n # we do this by hacking our way into the registry (TODO: find a public API for this if it exists)\n reg = tf_ops._gradient_registry._registry\n ops_not_in_registry = ['TensorListReserve']\n # NOTE: location_tag taken from tensorflow source for None type ops\n location_tag = (\"UNKNOWN\", \"UNKNOWN\", \"UNKNOWN\", \"UNKNOWN\", \"UNKNOWN\")\n # TODO: unclear why some ops are not in the registry with TF 2.0 like TensorListReserve\n for non_reg_ops in ops_not_in_registry:\n reg[non_reg_ops] = {'type': None, 'location': location_tag}\n for n in op_handlers:\n if n in reg:\n self.orig_grads[n] = reg[n][\"type\"]\n reg[\"shap_\"+n] = {\n \"type\": self.custom_grad,\n \"location\": reg[n][\"location\"]\n }\n reg[n][\"type\"] = self.custom_grad\n\n # In TensorFlow 1.10 they started pruning out nodes that they think can't be backpropped\n # unfortunately that includes the index of embedding layers so we disable that check here\n if hasattr(tf_gradients_impl, \"_IsBackpropagatable\"):\n orig_IsBackpropagatable = tf_gradients_impl._IsBackpropagatable\n tf_gradients_impl._IsBackpropagatable = lambda tensor: True\n\n # define the computation graph for the attribution values using a custom gradient-like computation\n try:\n out = f()\n finally:\n # reinstate the backpropagatable check\n if hasattr(tf_gradients_impl, \"_IsBackpropagatable\"):\n tf_gradients_impl._IsBackpropagatable = orig_IsBackpropagatable\n\n # restore the original gradient definitions\n for n in op_handlers:\n if n in reg:\n del reg[\"shap_\"+n]\n reg[n][\"type\"] = self.orig_grads[n]\n for non_reg_ops in ops_not_in_registry:\n del reg[non_reg_ops]\n if not tf.executing_eagerly():\n return out\n else:\n return [v.numpy() for v in out]\n\ndef tensors_blocked_by_false(ops):\n \"\"\" Follows a set of ops assuming their value is False and find blocked Switch paths.\n\n This is used to prune away parts of the model graph that are only used during the training\n phase (like dropout, batch norm, etc.).\n \"\"\"\n blocked = []\n def recurse(op):\n if op.type == \"Switch\":\n blocked.append(op.outputs[1]) # the true path is blocked since we assume the ops we trace are False\n else:\n for out in op.outputs:\n for c in out.consumers():\n recurse(c)\n for op in ops:\n recurse(op)\n\n return blocked\n\ndef backward_walk_ops(start_ops, tensor_blacklist, op_type_blacklist):\n found_ops = []\n op_stack = [op for op in start_ops]\n while len(op_stack) > 0:\n op = op_stack.pop()\n if op.type not in op_type_blacklist and op not in found_ops:\n found_ops.append(op)\n for input in op.inputs:\n if input not in tensor_blacklist:\n op_stack.append(input.op)\n return found_ops\n\ndef forward_walk_ops(start_ops, tensor_blacklist, op_type_blacklist, within_ops):\n found_ops = []\n op_stack = [op for op in start_ops]\n while len(op_stack) > 0:\n op = op_stack.pop()\n if op.type not in op_type_blacklist and op in within_ops and op not in found_ops:\n found_ops.append(op)\n for out in op.outputs:\n if out not in tensor_blacklist:\n for c in out.consumers():\n op_stack.append(c)\n return found_ops\n\n\ndef softmax(explainer, op, *grads):\n \"\"\" Just decompose softmax into its components and recurse, we can handle all of them :)\n\n We assume the 'axis' is the last dimension because the TF codebase swaps the 'axis' to\n the last dimension before the softmax op if 'axis' is not already the last dimension.\n We also don't subtract the max before tf.exp for numerical stability since that might\n mess up the attributions and it seems like TensorFlow doesn't define softmax that way\n (according to the docs)\n \"\"\"\n in0 = op.inputs[0]\n in0_max = tf.reduce_max(in0, axis=-1, keepdims=True, name=\"in0_max\")\n in0_centered = in0 - in0_max\n evals = tf.exp(in0_centered, name=\"custom_exp\")\n rsum = tf.reduce_sum(evals, axis=-1, keepdims=True)\n div = evals / rsum\n\n # mark these as in-between the inputs and outputs\n for op in [evals.op, rsum.op, div.op, in0_centered.op]:\n for t in op.outputs:\n if t.name not in explainer.between_tensors:\n explainer.between_tensors[t.name] = False\n\n out = tf.gradients(div, in0_centered, grad_ys=grads[0])[0]\n\n # remove the names we just added\n for op in [evals.op, rsum.op, div.op, in0_centered.op]:\n for t in op.outputs:\n if explainer.between_tensors[t.name] is False:\n del explainer.between_tensors[t.name]\n\n # rescale to account for our shift by in0_max (which we did for numerical stability)\n xin0,rin0 = tf.split(in0, 2)\n xin0_centered,rin0_centered = tf.split(in0_centered, 2)\n delta_in0 = xin0 - rin0\n dup0 = [2] + [1 for i in delta_in0.shape[1:]]\n return tf.where(\n tf.tile(tf.abs(delta_in0), dup0) < 1e-6,\n out,\n out * tf.tile((xin0_centered - rin0_centered) / delta_in0, dup0)\n )\n\ndef maxpool(explainer, op, *grads):\n xin0,rin0 = tf.split(op.inputs[0], 2)\n xout,rout = tf.split(op.outputs[0], 2)\n delta_in0 = xin0 - rin0\n dup0 = [2] + [1 for i in delta_in0.shape[1:]]\n cross_max = tf.maximum(xout, rout)\n diffs = tf.concat([cross_max - rout, xout - cross_max], 0)\n if op.type.startswith(\"shap_\"):\n op.type = op.type[5:]\n xmax_pos,rmax_pos = tf.split(explainer.orig_grads[op.type](op, grads[0] * diffs), 2)\n return tf.tile(tf.where(\n tf.abs(delta_in0) < 1e-7,\n tf.zeros_like(delta_in0),\n (xmax_pos + rmax_pos) / delta_in0\n ), dup0)\n\ndef gather(explainer, op, *grads):\n #params = op.inputs[0]\n indices = op.inputs[1]\n #axis = op.inputs[2]\n var = explainer._variable_inputs(op)\n if var[1] and not var[0]:\n assert len(indices.shape) == 2, \"Only scalar indices supported right now in GatherV2!\"\n\n xin1,rin1 = tf.split(tf.cast(op.inputs[1], tf.float32), 2)\n xout,rout = tf.split(op.outputs[0], 2)\n dup_in1 = [2] + [1 for i in xin1.shape[1:]]\n dup_out = [2] + [1 for i in xout.shape[1:]]\n delta_in1_t = tf.tile(xin1 - rin1, dup_in1)\n out_sum = tf.reduce_sum(grads[0] * tf.tile(xout - rout, dup_out), list(range(len(indices.shape), len(grads[0].shape))))\n if op.type == \"ResourceGather\":\n return [None, tf.where(\n tf.abs(delta_in1_t) < 1e-6,\n tf.zeros_like(delta_in1_t),\n out_sum / delta_in1_t\n )]\n return [None, tf.where(\n tf.abs(delta_in1_t) < 1e-6,\n tf.zeros_like(delta_in1_t),\n out_sum / delta_in1_t\n ), None]\n elif var[0] and not var[1]:\n if op.type.startswith(\"shap_\"):\n op.type = op.type[5:]\n return [explainer.orig_grads[op.type](op, grads[0]), None] # linear in this case\n else:\n assert False, \"Axis not yet supported to be varying for gather op!\"\n\ndef linearity_1d_nonlinearity_2d(input_ind0, input_ind1, op_func):\n def handler(explainer, op, *grads):\n var = explainer._variable_inputs(op)\n if var[input_ind0] and not var[input_ind1]:\n return linearity_1d_handler(input_ind0, explainer, op, *grads)\n elif var[input_ind1] and not var[input_ind0]:\n return linearity_1d_handler(input_ind1, explainer, op, *grads)\n elif var[input_ind0] and var[input_ind1]:\n return nonlinearity_2d_handler(input_ind0, input_ind1, op_func, explainer, op, *grads)\n else:\n return [None for _ in op.inputs] # no inputs vary, we must be hidden by a switch function\n return handler\n\ndef nonlinearity_1d_nonlinearity_2d(input_ind0, input_ind1, op_func):\n def handler(explainer, op, *grads):\n var = explainer._variable_inputs(op)\n if var[input_ind0] and not var[input_ind1]:\n return nonlinearity_1d_handler(input_ind0, explainer, op, *grads)\n elif var[input_ind1] and not var[input_ind0]:\n return nonlinearity_1d_handler(input_ind1, explainer, op, *grads)\n elif var[input_ind0] and var[input_ind1]:\n return nonlinearity_2d_handler(input_ind0, input_ind1, op_func, explainer, op, *grads)\n else:\n return [None for _ in op.inputs] # no inputs vary, we must be hidden by a switch function\n return handler\n\ndef nonlinearity_1d(input_ind):\n def handler(explainer, op, *grads):\n return nonlinearity_1d_handler(input_ind, explainer, op, *grads)\n return handler\n\ndef nonlinearity_1d_handler(input_ind, explainer, op, *grads):\n # make sure only the given input varies\n op_inputs = op.inputs\n if op_inputs is None:\n op_inputs = op.outputs[0].op.inputs\n\n for i in range(len(op_inputs)):\n if i != input_ind:\n assert not explainer._variable_inputs(op)[i], str(i) + \"th input to \" + op.name + \" cannot vary!\"\n\n xin0, rin0 = tf.split(op_inputs[input_ind], 2)\n xout, rout = tf.split(op.outputs[input_ind], 2)\n delta_in0 = xin0 - rin0\n if delta_in0.shape is None:\n dup0 = [2, 1]\n else:\n dup0 = [2] + [1 for i in delta_in0.shape[1:]]\n out = [None for _ in op_inputs]\n if op.type.startswith(\"shap_\"):\n op.type = op.type[5:]\n orig_grad = explainer.orig_grads[op.type](op, grads[0])\n out[input_ind] = tf.where(\n tf.tile(tf.abs(delta_in0), dup0) < 1e-6,\n orig_grad[input_ind] if len(op_inputs) > 1 else orig_grad,\n grads[0] * tf.tile((xout - rout) / delta_in0, dup0)\n )\n return out\n\ndef nonlinearity_2d_handler(input_ind0, input_ind1, op_func, explainer, op, *grads):\n assert input_ind0 == 0 and input_ind1 == 1, \"TODO: Can't yet handle double inputs that are not first!\"\n xout,rout = tf.split(op.outputs[0], 2)\n in0 = op.inputs[input_ind0]\n in1 = op.inputs[input_ind1]\n xin0,rin0 = tf.split(in0, 2)\n xin1,rin1 = tf.split(in1, 2)\n delta_in0 = xin0 - rin0\n delta_in1 = xin1 - rin1\n dup0 = [2] + [1 for i in delta_in0.shape[1:]]\n out10 = op_func(xin0, rin1)\n out01 = op_func(rin0, xin1)\n out11,out00 = xout,rout\n out0 = 0.5 * (out11 - out01 + out10 - out00)\n out0 = grads[0] * tf.tile(out0 / delta_in0, dup0)\n out1 = 0.5 * (out11 - out10 + out01 - out00)\n out1 = grads[0] * tf.tile(out1 / delta_in1, dup0)\n\n # Avoid divide by zero nans\n out0 = tf.where(tf.abs(tf.tile(delta_in0, dup0)) < 1e-7, tf.zeros_like(out0), out0)\n out1 = tf.where(tf.abs(tf.tile(delta_in1, dup0)) < 1e-7, tf.zeros_like(out1), out1)\n\n # see if due to broadcasting our gradient shapes don't match our input shapes\n if (np.any(np.array(out1.shape) != np.array(in1.shape))):\n broadcast_index = np.where(np.array(out1.shape) != np.array(in1.shape))[0][0]\n out1 = tf.reduce_sum(out1, axis=broadcast_index, keepdims=True)\n elif (np.any(np.array(out0.shape) != np.array(in0.shape))):\n broadcast_index = np.where(np.array(out0.shape) != np.array(in0.shape))[0][0]\n out0 = tf.reduce_sum(out0, axis=broadcast_index, keepdims=True)\n\n return [out0, out1]\n\ndef linearity_1d(input_ind):\n def handler(explainer, op, *grads):\n return linearity_1d_handler(input_ind, explainer, op, *grads)\n return handler\n\ndef linearity_1d_handler(input_ind, explainer, op, *grads):\n # make sure only the given input varies (negative means only that input cannot vary, and is measured from the end of the list)\n for i in range(len(op.inputs)):\n if i != input_ind:\n assert not explainer._variable_inputs(op)[i], str(i) + \"th input to \" + op.name + \" cannot vary!\"\n if op.type.startswith(\"shap_\"):\n op.type = op.type[5:]\n return explainer.orig_grads[op.type](op, *grads)\n\ndef linearity_with_excluded(input_inds):\n def handler(explainer, op, *grads):\n return linearity_with_excluded_handler(input_inds, explainer, op, *grads)\n return handler\n\ndef linearity_with_excluded_handler(input_inds, explainer, op, *grads):\n # make sure the given inputs don't vary (negative is measured from the end of the list)\n for i in range(len(op.inputs)):\n if i in input_inds or i - len(op.inputs) in input_inds:\n assert not explainer._variable_inputs(op)[i], str(i) + \"th input to \" + op.name + \" cannot vary!\"\n if op.type.startswith(\"shap_\"):\n op.type = op.type[5:]\n return explainer.orig_grads[op.type](op, *grads)\n\ndef passthrough(explainer, op, *grads):\n if op.type.startswith(\"shap_\"):\n op.type = op.type[5:]\n return explainer.orig_grads[op.type](op, *grads)\n\ndef break_dependence(explainer, op, *grads):\n \"\"\" This function name is used to break attribution dependence in the graph traversal.\n\n These operation types may be connected above input data values in the graph but their outputs\n don't depend on the input values (for example they just depend on the shape).\n \"\"\"\n return [None for _ in op.inputs]\n\n\nop_handlers = {}\n\n# ops that are always linear\nop_handlers[\"Identity\"] = passthrough\nop_handlers[\"StridedSlice\"] = passthrough\nop_handlers[\"Squeeze\"] = passthrough\nop_handlers[\"ExpandDims\"] = passthrough\nop_handlers[\"Pack\"] = passthrough\nop_handlers[\"BiasAdd\"] = passthrough\nop_handlers[\"Unpack\"] = passthrough\nop_handlers[\"Add\"] = passthrough\nop_handlers[\"Sub\"] = passthrough\nop_handlers[\"Merge\"] = passthrough\nop_handlers[\"Sum\"] = passthrough\nop_handlers[\"Mean\"] = passthrough\nop_handlers[\"Cast\"] = passthrough\nop_handlers[\"Transpose\"] = passthrough\nop_handlers[\"Enter\"] = passthrough\nop_handlers[\"Exit\"] = passthrough\nop_handlers[\"NextIteration\"] = passthrough\nop_handlers[\"Tile\"] = passthrough\nop_handlers[\"TensorArrayScatterV3\"] = passthrough\nop_handlers[\"TensorArrayReadV3\"] = passthrough\nop_handlers[\"TensorArrayWriteV3\"] = passthrough\n\n# NEW\nop_handlers[\"AddV2\"] = passthrough\nop_handlers[\"StatelessWhile\"] = passthrough\nop_handlers[\"TensorListStack\"] = passthrough\nop_handlers[\"StatelessWhile\"] = passthrough\nop_handlers[\"TensorListFromTensor\"] = passthrough\n\n\n# ops that don't pass any attributions to their inputs\nop_handlers[\"Shape\"] = break_dependence\nop_handlers[\"RandomUniform\"] = break_dependence\nop_handlers[\"ZerosLike\"] = break_dependence\n#op_handlers[\"StopGradient\"] = break_dependence # this allows us to stop attributions when we want to (like softmax re-centering)\n\n# ops that are linear and only allow a single input to vary\nop_handlers[\"Reshape\"] = linearity_1d(0)\nop_handlers[\"Pad\"] = linearity_1d(0)\nop_handlers[\"ReverseV2\"] = linearity_1d(0)\nop_handlers[\"ConcatV2\"] = linearity_with_excluded([-1])\nop_handlers[\"Conv2D\"] = linearity_1d(0)\nop_handlers[\"Switch\"] = linearity_1d(0)\nop_handlers[\"AvgPool\"] = linearity_1d(0)\nop_handlers[\"FusedBatchNorm\"] = linearity_1d(0)\n\n# ops that are nonlinear and only allow a single input to vary\nop_handlers[\"Relu\"] = nonlinearity_1d(0)\nop_handlers[\"Elu\"] = nonlinearity_1d(0)\nop_handlers[\"Sigmoid\"] = nonlinearity_1d(0)\nop_handlers[\"Tanh\"] = nonlinearity_1d(0)\nop_handlers[\"Softplus\"] = nonlinearity_1d(0)\nop_handlers[\"Exp\"] = nonlinearity_1d(0)\nop_handlers[\"ClipByValue\"] = nonlinearity_1d(0)\nop_handlers[\"Rsqrt\"] = nonlinearity_1d(0)\nop_handlers[\"Square\"] = nonlinearity_1d(0)\nop_handlers[\"Max\"] = nonlinearity_1d(0)\n\n# NEW\nop_handlers[\"Sin\"] = nonlinearity_1d(0)\n\n# ops that are nonlinear and allow two inputs to vary\nop_handlers[\"SquaredDifference\"] = nonlinearity_1d_nonlinearity_2d(0, 1, lambda x, y: (x - y) * (x - y))\nop_handlers[\"Minimum\"] = nonlinearity_1d_nonlinearity_2d(0, 1, lambda x, y: tf.minimum(x, y))\nop_handlers[\"Maximum\"] = nonlinearity_1d_nonlinearity_2d(0, 1, lambda x, y: tf.maximum(x, y))\n\n# ops that allow up to two inputs to vary are are linear when only one input varies\nop_handlers[\"Mul\"] = linearity_1d_nonlinearity_2d(0, 1, lambda x, y: x * y)\nop_handlers[\"RealDiv\"] = linearity_1d_nonlinearity_2d(0, 1, lambda x, y: x / y)\nop_handlers[\"MatMul\"] = linearity_1d_nonlinearity_2d(0, 1, lambda x, y: tf.matmul(x, y))\n\n# ops that need their own custom attribution functions\nop_handlers[\"GatherV2\"] = gather\nop_handlers[\"ResourceGather\"] = gather\nop_handlers[\"MaxPool\"] = maxpool\nop_handlers[\"Softmax\"] = softmax\n\n\n# TODO items\n# TensorArrayGatherV3\n# Max\n# TensorArraySizeV3\n# Range\n"
] | [
[
"tensorflow.concat",
"tensorflow.reduce_sum",
"tensorflow.minimum",
"tensorflow.cast",
"numpy.concatenate",
"tensorflow.python.eager.backprop.record_gradient",
"tensorflow.keras.backend.learning_phase",
"tensorflow.gradients",
"tensorflow.keras.backend.set_learning_phase",
"numpy.zeros",
"tensorflow.tile",
"tensorflow.matmul",
"tensorflow.executing_eagerly",
"tensorflow.python.eager.backprop._record_gradient",
"tensorflow.exp",
"tensorflow.keras.Model",
"tensorflow.zeros_like",
"numpy.argsort",
"tensorflow.split",
"numpy.array",
"tensorflow.GradientTape",
"tensorflow.reduce_max",
"tensorflow.constant",
"numpy.abs",
"tensorflow.maximum",
"tensorflow.abs"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"2.8",
"1.10",
"1.12",
"2.7",
"2.6",
"2.3",
"2.4",
"2.9",
"2.5",
"2.2",
"2.10"
]
}
] |
HustQBW/Single-Object-Localization | [
"3a6bd87cd75543f55eb3eed12b6d09475f05b8fd",
"3a6bd87cd75543f55eb3eed12b6d09475f05b8fd"
] | [
"train.py",
"resnet50_anchor_net.py"
] | [
"from dataset import tiny_dataset\nfrom bbox_codec import bbox_encode\nfrom resnet50_base import Localization_net2\nfrom torch.utils.data import DataLoader,random_split\nimport torch as t\nimport tqdm\nfrom torch.utils.tensorboard import SummaryWriter\nimport torch.nn as nn\nimport torch.optim as optim\nimport argparse\nfrom loss import Loss_for_localization\nfrom evaluate import compute_three_acc\nimport os\ndef parser():\n parser = argparse.ArgumentParser()\n parser.add_argument('--lr',help='learning rate',type=float,default=1e-2,dest='lr')\n parser.add_argument('--batch-size',help='batchsize',type=int,default=32,dest='batch_size')\n parser.add_argument('--lr-decay',help='the decay of lr',type=float,default=0.1,dest='lr_decay')\n parser.add_argument('--root',help='root directory of dataset',type=str,\n default=r'E:\\BS_learning\\4_1\\CV_basis\\experiment\\2\\tiny_vid',dest='root')\n parser.add_argument('--weight-decay',help='weight decay of optimizer',type=float,\n default=1e-5,dest='weight_decay')\n parser.add_argument('--epochs',help='set the num of epochs',type=int,default=100)\n parser.add_argument('--log-dir',help='tensorboard log dir',type=str,required=True)\n parser.add_argument('--save-file-name', help='the pth file name', type=str,required=True)\n parser.add_argument('--class-weight',help='the weight of classification of the loss',default=1,type=int)\n parser.add_argument('--regre-weight', help='the weight of regression of the loss', default=2,type=int)\n return parser\n\ndef weight_init(net):\n for name,child in net.named_children():\n if name == 'feature_extraction':\n continue\n\n if isinstance(child,nn.Conv2d):\n nn.init.kaiming_normal_(child.weight)\n if child.bias != None:\n nn.init.zeros_(child.bias)\n\n elif isinstance(child,nn.Linear):\n nn.init.kaiming_normal_(child.weight)\n if child.bias != None:\n nn.init.zeros_(child.bias)\n return net\n\ndef train():\n args = parser().parse_args()\n t.manual_seed(777)\n t.cuda.manual_seed(777)\n\n dataset = tiny_dataset(root=args.root)\n train_set,val_set = random_split(dataset=dataset,lengths=[150*5,30*5],\n generator=t.Generator().manual_seed(777))\n\n train_loader = DataLoader(dataset=train_set,batch_size=args.batch_size,shuffle=True,num_workers=2)\n\n val_loader = DataLoader(dataset=val_set,batch_size=1,shuffle=False,num_workers=0)\n\n print('establish the net ...')\n net = Localization_net2(class_num=5).cuda()\n\n print('initialize the net')\n net = weight_init(net=net)\n high_lr_list = []\n low_lr_list = []\n for name,param in net.named_parameters():\n if 'feature_extraction' in name:\n low_lr_list.append(param)\n else:\n high_lr_list.append(param)\n\n optimizer = optim.SGD([{'params':low_lr_list,'lr':0.1*args.lr},{'params':high_lr_list}],\n lr=args.lr,weight_decay=args.weight_decay,momentum=0.9)\n # scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer=optimizer,\n # mode='min', patience=2,factor=args.lr_decay)\n\n\n writer = SummaryWriter(log_dir=args.log_dir,comment='curves_log')\n criterion = Loss_for_localization().cuda()\n\n for i in tqdm.tqdm(range(args.epochs)):\n t_loss = 0.\n tc_acc = 0.\n tr_acc = 0.\n t_acc = 0.\n\n v_loss = 0.\n vc_acc = 0.\n vr_acc = 0.\n v_acc = 0.\n\n print('\\n%dth epoch'%(i+1))\n\n\n if i+1 == args.epochs//4:\n optimizer.param_groups[0]['lr'] *= args.lr_decay\n optimizer.param_groups[1]['lr'] *= args.lr_decay\n\n if i+1 == args.epochs//2:\n optimizer.param_groups[0]['lr'] *= args.lr_decay\n optimizer.param_groups[1]['lr'] *= args.lr_decay\n\n if i+1 == 3*args.epochs//4:\n optimizer.param_groups[0]['lr'] *= args.lr_decay\n optimizer.param_groups[1]['lr'] *= args.lr_decay\n\n for item in train_loader:\n tc_acc_num = 0\n tr_acc_num = 0\n t_acc_num = 0\n net.train()\n img = item['img'].cuda()\n label = item['label'].cuda()\n bbox = item['bbox'].cuda()\n objects, scores, locs = net(img)\n\n\n gt = bbox_encode(bbox=bbox,feature_map_size=(4,4),img_size=(128,128)).cuda()\n\n loss = criterion(objects,scores,locs,label,gt,args.regre_weight,0.5,args.class_weight)\n\n t_loss += loss.item()\n optimizer.zero_grad()\n loss.backward()\n optimizer.step()\n\n\n for j in range(img.size()[0]):\n a,b,c = compute_three_acc(objects=objects[j].view(1,*objects[j].size()),\n score=scores[j].view(1,*scores[j].size()), loc=locs[j].view(1,*locs[j].size()),\n label=label[j].view(1,*label[j].size()), bbox=bbox[j].view(1,*bbox[j].size()))\n tc_acc_num += a\n tr_acc_num += b\n t_acc_num += c\n\n tc_acc += tc_acc_num/float(img.size()[0])\n tr_acc += tr_acc_num / float(img.size()[0])\n t_acc += t_acc_num / float(img.size()[0])\n\n\n\n\n net.eval()\n with t.no_grad():\n for item2 in val_loader:\n img = item2['img'].cuda()\n label = item2['label'].cuda()\n bbox = item2['bbox'].cuda()\n objects, scores, locs = net(img)\n class_acc,regression_acc,acc = compute_three_acc(objects=objects,score=scores,\n loc=locs,label=label,bbox=bbox)\n gt = bbox_encode(bbox=bbox, feature_map_size=(4, 4), img_size=(128, 128)).cuda()\n\n vc_acc += class_acc\n vr_acc += regression_acc\n v_acc += acc\n\n loss = criterion(objects, scores, locs,label, gt,args.regre_weight,0.5,args.class_weight)\n v_loss +=loss.item()\n\n v_loss /= len(val_loader)\n vc_acc /= len(val_loader)\n vr_acc /= len(val_loader)\n v_acc /= len(val_loader)\n\n # scheduler.step(v_loss)\n\n print('train_loss: %.5f val_loss : %.5f' % (t_loss/len(train_loader),v_loss))\n\n writer.add_scalar('low_lr_curve', optimizer.param_groups[0][\"lr\"], i + 1)\n writer.add_scalar('high_lr_curve', optimizer.param_groups[1][\"lr\"], i + 1)\n writer.add_scalars('loss', {'Train':t_loss / len(train_loader)}, i+1)\n writer.add_scalars('loss', {'Val':v_loss}, i+1)\n writer.add_scalars('train_acc', {'class_acc': tc_acc/ len(train_loader)}, i + 1)\n writer.add_scalars('train_acc', {'regression_acc': tr_acc/ len(train_loader)}, i + 1)\n writer.add_scalars('train_acc', {'two_task_acc': t_acc/ len(train_loader)}, i + 1)\n writer.add_scalars('val_acc',{'class_acc':vc_acc},i+1)\n writer.add_scalars('val_acc', {'regression_acc': vr_acc}, i + 1)\n writer.add_scalars('val_acc', {'two_task_acc': v_acc}, i + 1)\n\n if optimizer.param_groups[0]['lr'] <= 1e-8:\n break\n t.save(net,os.path.join(args.log_dir,args.save_file_name + 'epoch%d.pth'%i))\n\n\n\n\nif __name__ == '__main__':\n train()",
"import torch as t\nimport torch.nn as nn\nfrom torchvision import models\nimport torch.nn.functional as F\nfrom torchsummary import summary\nclass Localization_anchor_net(nn.Module):\n def __init__(self,class_num=5,pretrained=True,anchor_num_per_cell=3): # without the background\n self.class_num = class_num\n self.anchor_num_per_cell = anchor_num_per_cell\n\n super(Localization_anchor_net,self).__init__()\n resnet50 = models.resnet50(pretrained=pretrained)\n self.feature_extraction = nn.Sequential()\n for name,each in resnet50.named_children():\n if (not isinstance(each, nn.AdaptiveAvgPool2d)) and (not isinstance(each, nn.Linear)):\n self.feature_extraction.add_module(name=name,module=each)\n\n self.sliding_window = nn.Conv2d(2048,2048,3,1,1,bias=False)\n self.out1 = nn.Conv2d(2048,(4+1)*self.anchor_num_per_cell, 1, 1, 0, bias=True)\n\n self.classi_conv = nn.Conv2d(2048, 512, 1, 1, 0, bias=False)\n self.gap = nn.AdaptiveAvgPool2d((1,1))\n self.out2 = nn.Linear(512,self.class_num,bias=True)\n\n self.dropout0 = nn.Dropout2d(0.5)\n\n self.dropout1 = nn.Dropout2d(0.5)\n self.dropout2 = nn.Dropout2d(0.65)\n\n\n def forward(self,x):\n self.features = self.feature_extraction(x) # 2048 4 4\n\n self.features = self.dropout0(self.features)\n\n self.sw = F.relu(self.sliding_window(self.features))\n\n self.sw = self.dropout1(self.sw)\n self.output1 = self.out1(self.sw)\n self.output1 = self.output1.view(self.output1.size()[0],self.anchor_num_per_cell,5,4,4)\n\n self.class_features = F.relu(self.classi_conv(self.features))\n self.class_features = self.dropout2(self.class_features)\n self.output2 = self.out2(self.gap(self.class_features).view(-1,512))\n\n\n # self.locs = t.sigmoid(self.output1[:,:,1:5,:,:])\n self.locs = self.output1[:, :, 1:5, :, :]\n\n self.object = t.sigmoid(self.output1[:,:,0,:,:])\n\n self.scores = self.output2\n\n return self.object,self.scores,self.locs\n\n\n\n\n\n\n\nif __name__ == '__main__':\n import time\n\n input = t.zeros((1,3,128,128)).cpu()\n net = Localization_anchor_net(class_num=5,pretrained=True,anchor_num_per_cell=3).cpu()\n start = time.time()\n object,score,loc = net(input)\n end = time.time()\n print(object.size())\n print(score.size())\n print(loc.size())\n print(end-start)\n \n print(summary(net,input_size=(3,128,128),device='cpu'))"
] | [
[
"torch.Generator",
"torch.cuda.manual_seed",
"torch.manual_seed",
"torch.utils.data.DataLoader",
"torch.no_grad",
"torch.utils.tensorboard.SummaryWriter",
"torch.optim.SGD",
"torch.nn.init.zeros_",
"torch.nn.init.kaiming_normal_"
],
[
"torch.nn.Sequential",
"torch.sigmoid",
"torch.nn.Dropout2d",
"torch.zeros",
"torch.nn.Conv2d",
"torch.nn.Linear",
"torch.nn.AdaptiveAvgPool2d"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
Geodan/building-boundary | [
"d0eb88d99743af917568131e8609f481b10e4520"
] | [
"building_boundary/footprint.py"
] | [
"# -*- coding: utf-8 -*-\n\"\"\"\n\n@author: Chris Lucas\n\"\"\"\n\nimport math\n\nimport numpy as np\nfrom shapely.geometry import (\n Polygon, MultiPolygon, LineString, MultiLineString, LinearRing\n)\nfrom shapely import wkt\n\nfrom building_boundary import utils\n\n\ndef line_orientations(lines):\n \"\"\"\n Computes the orientations of the lines.\n\n Parameters\n ----------\n lines : list of (2x2) array\n The lines defined by the coordinates two points.\n\n Returns\n -------\n orientations : list of float\n The orientations of the lines in radians from\n 0 to pi (east to west counterclockwise)\n 0 to -pi (east to west clockwise)\n \"\"\"\n orientations = []\n for l in lines:\n dx, dy = l[0] - l[1]\n orientation = math.atan2(dy, dx)\n if not any([np.isclose(orientation, o) for o in orientations]):\n orientations.append(orientation)\n return orientations\n\n\ndef geometry_orientations(geom):\n \"\"\"\n Computes the orientations of the lines of a geometry (Polygon,\n MultiPolygon, LineString, MultiLineString, or LinearRing).\n\n Parameters\n ----------\n geom : Polygon, MultiPolygon, LineString, MultiLineString, or LinearRing\n The geometry\n\n Returns\n -------\n orientations : list of float\n The orientations of the lines of the geometry in radians from\n 0 to pi (east to west counterclockwise)\n 0 to -pi (east to west clockwise)\n \"\"\"\n orientations = []\n if type(geom) == Polygon:\n lines = utils.create_pairs(geom.exterior.coords[:-1])\n orientations = line_orientations(lines)\n elif type(geom) == MultiPolygon:\n for p in geom:\n lines = utils.create_pairs(p.exterior.coords[:-1])\n orientations.extend(line_orientations(lines))\n elif type(geom) == LineString:\n if geom.coords[0] == geom.coords[-1]:\n lines = utils.create_pairs(geom.coords[:-1])\n else:\n lines = list(utils.create_pairs(geom.coords))[:-1]\n orientations = line_orientations(lines)\n elif type(geom) == MultiLineString:\n for l in geom:\n if l.coords[0] == l.coords[-1]:\n lines = utils.create_pairs(l.coords[:-1])\n else:\n lines = list(utils.create_pairs(l.coords))[:-1]\n orientations.extend(line_orientations(lines))\n elif type(geom) == LinearRing:\n lines = utils.create_pairs(geom.coords[:-1])\n orientations = line_orientations(lines)\n else:\n raise TypeError('Invalid geometry type. Expects Polygon, '\n 'MultiPolygon, LineString, MultiLineString, '\n 'or LinearRing.')\n return orientations\n\n\ndef compute_orientations(footprint_wkt):\n \"\"\"\n Computes the orientations of the footprint.\n\n Parameters\n ----------\n footprint_wkt : string\n The footprint geometry defined by a WKT string.\n\n Returns\n -------\n orientations : list of float\n The orientations of the lines of the geometry in radians from\n 0 to pi (east to west counterclockwise)\n 0 to -pi (east to west clockwise)\n \"\"\"\n footprint_geom = wkt.loads(footprint_wkt)\n orientations = geometry_orientations(footprint_geom)\n return orientations\n"
] | [
[
"numpy.isclose"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
mangoyuan/Unifed-Seg3d | [
"74c82464dbe901cf18e38afb0e1b74cc159a8850",
"74c82464dbe901cf18e38afb0e1b74cc159a8850"
] | [
"nnunet/training/network_training/network_trainer.py",
"nnunet/inference/predict.py"
] | [
"from _warnings import warn\nimport matplotlib\nfrom batchgenerators.utilities.file_and_folder_operations import *\nfrom sklearn.model_selection import KFold\nmatplotlib.use(\"agg\")\nfrom time import time, sleep\nimport torch\nimport numpy as np\nfrom torch.optim import lr_scheduler\nimport matplotlib.pyplot as plt\nimport sys\nfrom collections import OrderedDict\nfrom datetime import datetime\nimport torch.backends.cudnn as cudnn\nfrom abc import abstractmethod\nfrom datetime import datetime\n\n\ntry:\n from apex import amp\nexcept ImportError:\n amp = None\n\n\nclass NetworkTrainer(object):\n def __init__(self, deterministic=True, fp16=False):\n \"\"\"\n A generic class that can train almost any neural network (RNNs excluded). It provides basic functionality such\n as the training loop, tracking of training and validation losses (and the target metric if you implement it)\n Training can be terminated early if the validation loss (or the target metric if implemented) do not improve\n anymore. This is based on a moving average (MA) of the loss/metric instead of the raw values to get more smooth\n results.\n\n What you need to override:\n - __init__\n - initialize\n - run_online_evaluation (optional)\n - finish_online_evaluation (optional)\n - validate\n - predict_test_case\n \"\"\"\n np.random.seed(12345)\n torch.manual_seed(12345)\n torch.cuda.manual_seed_all(12345)\n self.fp16 = fp16\n\n if deterministic:\n cudnn.deterministic = True\n torch.backends.cudnn.benchmark = False\n else:\n cudnn.deterministic = False\n torch.backends.cudnn.benchmark = True\n\n ################# SET THESE IN self.initialize() ###################################\n self.network = None\n self.optimizer = None\n self.lr_scheduler = None\n self.tr_gen = self.val_gen = None\n self.was_initialized = False\n\n ################# SET THESE IN INIT ################################################\n self.output_folder = None\n self.fold = None\n self.loss = None\n self.dataset_directory = None\n\n ################# SET THESE IN LOAD_DATASET OR DO_SPLIT ############################\n self.dataset = None # these can be None for inference mode\n self.dataset_tr = self.dataset_val = None # do not need to be used, they just appear if you are using the suggested load_dataset_and_do_split\n\n ################# THESE DO NOT NECESSARILY NEED TO BE MODIFIED #####################\n self.patience = 50\n self.val_eval_criterion_alpha = 0.9 # alpha * old + (1-alpha) * new\n # if this is too low then the moving average will be too noisy and the training may terminate early. If it is\n # too high the training will take forever\n self.train_loss_MA_alpha = 0.93 # alpha * old + (1-alpha) * new\n self.train_loss_MA_eps = 5e-4 # new MA must be at least this much better (smaller)\n self.save_every = 50\n self.save_latest_only = True\n self.max_num_epochs = 1000\n self.num_batches_per_epoch = 250\n self.num_val_batches_per_epoch = 50\n self.also_val_in_tr_mode = False\n self.lr_threshold = 1e-6 # the network will not terminate training if the lr is still above this threshold\n\n ################# LEAVE THESE ALONE ################################################\n self.val_eval_criterion_MA = None\n self.train_loss_MA = None\n self.best_val_eval_criterion_MA = None\n self.best_MA_tr_loss_for_patience = None\n self.best_epoch_based_on_MA_tr_loss = None\n self.all_tr_losses = []\n self.all_val_losses = []\n self.all_val_losses_tr_mode = []\n self.all_val_eval_metrics = [] # does not have to be used\n self.epoch = 0\n self.log_file = None\n self.deterministic = deterministic\n\n\n @abstractmethod\n def initialize(self, training=True):\n \"\"\"\n create self.output_folder\n\n modify self.output_folder if you are doing cross-validation (one folder per fold)\n\n set self.tr_gen and self.val_gen\n \n set self.network, self.optimizer and self.lr_scheduler\n \n finally set self.was_initialized to True\n :param training:\n :return:\n \"\"\"\n\n @abstractmethod\n def load_dataset(self):\n pass\n\n def do_split(self):\n \"\"\"\n This is a suggestion for if your dataset is a dictionary (my personal standard)\n :return:\n \"\"\"\n splits_file = join(self.dataset_directory, \"splits_final.pkl\")\n\n if not isfile(splits_file):\n self.print_to_log_file(\"Creating new split...\")\n splits = []\n all_keys_sorted = np.sort(list(self.dataset.keys()))\n kfold = KFold(n_splits=5, shuffle=True, random_state=12345)\n for i, (train_idx, test_idx) in enumerate(kfold.split(all_keys_sorted)):\n train_keys = np.array(all_keys_sorted)[train_idx]\n test_keys = np.array(all_keys_sorted)[test_idx]\n splits.append(OrderedDict())\n splits[-1]['train'] = train_keys\n splits[-1]['val'] = test_keys\n save_pickle(splits, splits_file)\n\n splits = load_pickle(splits_file)\n\n if self.fold == \"all\":\n tr_keys = val_keys = list(self.dataset.keys())\n else:\n tr_keys = splits[self.fold]['train']\n val_keys = splits[self.fold]['val']\n\n tr_keys.sort()\n val_keys.sort()\n\n self.dataset_tr = OrderedDict()\n for i in tr_keys:\n self.dataset_tr[i] = self.dataset[i]\n\n self.dataset_val = OrderedDict()\n for i in val_keys:\n self.dataset_val[i] = self.dataset[i]\n\n def plot_progress(self):\n \"\"\"\n Should probably by improved\n :return:\n \"\"\"\n try:\n font = {'weight': 'normal',\n 'size': 18}\n\n matplotlib.rc('font', **font)\n\n fig = plt.figure(figsize=(30, 24))\n ax = fig.add_subplot(111)\n ax2 = ax.twinx()\n\n x_values = list(range(self.epoch + 1))\n\n ax.plot(x_values, self.all_tr_losses, color='b', ls='-', label=\"loss_tr\")\n\n ax.plot(x_values, self.all_val_losses, color='r', ls='-', label=\"loss_val, train=False\")\n\n if len(self.all_val_losses_tr_mode) > 0:\n ax.plot(x_values, self.all_val_losses_tr_mode, color='g', ls='-', label=\"loss_val, train=True\")\n if len(self.all_val_eval_metrics) == len(self.all_val_losses):\n ax2.plot(x_values, self.all_val_eval_metrics, color='g', ls='--', label=\"evaluation metric\")\n\n ax.set_xlabel(\"epoch\")\n ax.set_ylabel(\"loss\")\n ax2.set_ylabel(\"evaluation metric\")\n ax.legend()\n ax2.legend(loc=9)\n\n fig.savefig(join(self.output_folder, \"progress.png\"))\n plt.close()\n except IOError:\n self.print_to_log_file(\"failed to plot: \", sys.exc_info())\n\n def print_to_log_file(self, *args, also_print_to_console=True, add_timestamp=True):\n\n timestamp = time()\n dt_object = datetime.fromtimestamp(timestamp)\n\n if add_timestamp:\n args = (\"%s:\" % dt_object, *args)\n\n if self.log_file is None:\n maybe_mkdir_p(self.output_folder)\n timestamp = datetime.now()\n self.log_file = join(self.output_folder, \"training_log_%d_%d_%d_%02.0d_%02.0d_%02.0d.txt\" %\n (timestamp.year, timestamp.month, timestamp.day, timestamp.hour, timestamp.minute, timestamp.second))\n with open(self.log_file, 'w') as f:\n f.write(\"Starting... \\n\")\n successful = False\n max_attempts = 5\n ctr = 0\n while not successful and ctr < max_attempts:\n try:\n with open(self.log_file, 'a+') as f:\n for a in args:\n f.write(str(a))\n f.write(\" \")\n f.write(\"\\n\")\n successful = True\n except IOError:\n print(\"%s: failed to log: \" % datetime.fromtimestamp(timestamp), sys.exc_info())\n sleep(0.5)\n ctr += 1\n if also_print_to_console:\n print(*args)\n\n def save_checkpoint(self, fname, save_optimizer=True):\n start_time = time()\n state_dict = self.network.state_dict()\n for key in state_dict.keys():\n state_dict[key] = state_dict[key].cpu()\n lr_sched_state_dct = None\n if self.lr_scheduler is not None and not isinstance(self.lr_scheduler, lr_scheduler.ReduceLROnPlateau):\n lr_sched_state_dct = self.lr_scheduler.state_dict()\n for key in lr_sched_state_dct.keys():\n lr_sched_state_dct[key] = lr_sched_state_dct[key]\n if save_optimizer:\n optimizer_state_dict = self.optimizer.state_dict()\n else:\n optimizer_state_dict = None\n\n self.print_to_log_file(\"saving checkpoint...\")\n torch.save({\n 'epoch': self.epoch + 1,\n 'state_dict': state_dict,\n 'optimizer_state_dict': optimizer_state_dict,\n 'lr_scheduler_state_dict': lr_sched_state_dct,\n 'plot_stuff': (self.all_tr_losses, self.all_val_losses, self.all_val_losses_tr_mode,\n self.all_val_eval_metrics)},\n fname)\n self.print_to_log_file(\"done, saving took %.2f seconds\" % (time() - start_time))\n\n def load_best_checkpoint(self, train=True):\n if self.fold is None:\n raise RuntimeError(\"Cannot load best checkpoint if self.fold is None\")\n self.load_checkpoint(join(self.output_folder, \"model_best.model\"), train=train)\n\n def load_latest_checkpoint(self, train=True):\n if isfile(join(self.output_folder, \"model_final_checkpoint.model\")):\n return self.load_checkpoint(join(self.output_folder, \"model_final_checkpoint.model\"), train=train)\n if isfile(join(self.output_folder, \"model_latest.model\")):\n return self.load_checkpoint(join(self.output_folder, \"model_latest.model\"), train=train)\n all_checkpoints = [i for i in os.listdir(self.output_folder) if i.endswith(\".model\") and i.find(\"_ep_\") != -1]\n if len(all_checkpoints) == 0:\n return self.load_best_checkpoint(train=train)\n corresponding_epochs = [int(i.split(\"_\")[-1].split(\".\")[0]) for i in all_checkpoints]\n checkpoint = all_checkpoints[np.argmax(corresponding_epochs)]\n self.load_checkpoint(join(self.output_folder, checkpoint), train=train)\n\n def load_checkpoint(self, fname, train=True):\n self.print_to_log_file(\"loading checkpoint\", fname, \"train=\", train)\n if not self.was_initialized:\n self.initialize(train)\n saved_model = torch.load(fname, map_location=torch.device('cuda', torch.cuda.current_device()))\n self.load_checkpoint_ram(saved_model, train)\n\n def load_checkpoint_ram(self, saved_model, train=True):\n \"\"\"\n used for if the checkpoint is already in ram\n :param saved_model:\n :param train:\n :return:\n \"\"\"\n if not self.was_initialized:\n self.initialize(train)\n\n new_state_dict = OrderedDict()\n curr_state_dict_keys = list(self.network.state_dict().keys())\n # if state dict comes form nn.DataParallel but we use non-parallel model here then the state dict keys do not\n # match. Use heuristic to make it match\n for k, value in saved_model['state_dict'].items():\n key = k\n if key not in curr_state_dict_keys:\n key = key[7:]\n new_state_dict[key] = value\n self.network.load_state_dict(new_state_dict)\n self.epoch = saved_model['epoch']\n if train:\n optimizer_state_dict = saved_model['optimizer_state_dict']\n if optimizer_state_dict is not None:\n self.optimizer.load_state_dict(optimizer_state_dict)\n if self.lr_scheduler is not None and not isinstance(self.lr_scheduler, lr_scheduler.ReduceLROnPlateau):\n self.lr_scheduler.load_state_dict(saved_model['lr_scheduler_state_dict'])\n\n self.all_tr_losses, self.all_val_losses, self.all_val_losses_tr_mode, self.all_val_eval_metrics = saved_model['plot_stuff']\n\n def _maybe_init_amp(self):\n # we use fp16 for training only, not inference\n if self.fp16:\n if amp is not None:\n self.network, self.optimizer = amp.initialize(self.network, self.optimizer, opt_level=\"O1\")\n else:\n self.print_to_log_file(\"WARNING: FP16 training was requested but nvidia apex is not installed. \"\n \"Install it from https://github.com/NVIDIA/apex\")\n\n def run_training(self):\n torch.cuda.empty_cache()\n\n self._maybe_init_amp()\n\n if cudnn.benchmark and cudnn.deterministic:\n warn(\"torch.backends.cudnn.deterministic is True indicating a deterministic training is desired. \"\n \"But torch.backends.cudnn.benchmark is True as well and this will prevent deterministic training! \"\n \"If you want deterministic then set benchmark=False\")\n\n maybe_mkdir_p(self.output_folder)\n\n if not self.was_initialized:\n self.initialize(True)\n\n while self.epoch < self.max_num_epochs:\n self.print_to_log_file(\"\\nepoch: \", self.epoch)\n epoch_start_time = time()\n train_losses_epoch = []\n\n # train one epoch\n self.network.train()\n for b in range(self.num_batches_per_epoch):\n l = self.run_iteration(self.tr_gen, True)\n train_losses_epoch.append(l)\n\n self.all_tr_losses.append(np.mean(train_losses_epoch))\n self.print_to_log_file(\"train loss : %.4f\" % self.all_tr_losses[-1])\n\n with torch.no_grad():\n # validation with train=False\n self.network.eval()\n val_losses = []\n for b in range(self.num_val_batches_per_epoch):\n l = self.run_iteration(self.val_gen, False, True)\n val_losses.append(l)\n self.all_val_losses.append(np.mean(val_losses))\n self.print_to_log_file(\"val loss (train=False): %.4f\" % self.all_val_losses[-1])\n\n if self.also_val_in_tr_mode:\n self.network.train()\n # validation with train=True\n val_losses = []\n for b in range(self.num_val_batches_per_epoch):\n l = self.run_iteration(self.val_gen, False)\n val_losses.append(l)\n self.all_val_losses_tr_mode.append(np.mean(val_losses))\n self.print_to_log_file(\"val loss (train=True): %.4f\" % self.all_val_losses_tr_mode[-1])\n\n epoch_end_time = time()\n\n self.update_train_loss_MA() # needed for lr scheduler and stopping of training\n\n continue_training = self.on_epoch_end()\n if not continue_training:\n # allows for early stopping\n break\n\n self.epoch += 1\n self.print_to_log_file(\"This epoch took %f s\\n\" % (epoch_end_time-epoch_start_time))\n\n self.save_checkpoint(join(self.output_folder, \"model_final_checkpoint.model\"))\n # now we can delete latest as it will be identical with final\n if isfile(join(self.output_folder, \"model_latest.model\")):\n os.remove(join(self.output_folder, \"model_latest.model\"))\n if isfile(join(self.output_folder, \"model_latest.model.pkl\")):\n os.remove(join(self.output_folder, \"model_latest.model.pkl\"))\n\n def maybe_update_lr(self):\n # maybe update learning rate\n if self.lr_scheduler is not None:\n assert isinstance(self.lr_scheduler, (lr_scheduler.ReduceLROnPlateau, lr_scheduler._LRScheduler))\n\n if isinstance(self.lr_scheduler, lr_scheduler.ReduceLROnPlateau):\n # lr scheduler is updated with moving average val loss. should be more robust\n self.lr_scheduler.step(self.train_loss_MA)\n else:\n self.lr_scheduler.step(self.epoch + 1)\n self.print_to_log_file(\"lr is now (scheduler) %s\" % str(self.optimizer.param_groups[0]['lr']))\n\n def maybe_save_checkpoint(self):\n \"\"\"\n Saves a checkpoint every save_ever epochs.\n :return:\n \"\"\"\n if self.epoch % self.save_every == (self.save_every - 1):\n self.print_to_log_file(\"saving scheduled checkpoint file...\")\n if not self.save_latest_only:\n self.save_checkpoint(join(self.output_folder, \"model_ep_%03.0d.model\" % (self.epoch + 1)))\n self.save_checkpoint(join(self.output_folder, \"model_latest.model\"))\n self.print_to_log_file(\"done\")\n\n def update_eval_criterion_MA(self):\n \"\"\"\n If self.all_val_eval_metrics is unused (len=0) then we fall back to using -self.all_val_losses for the MA to determine early stopping\n (not a minimization, but a maximization of a metric and therefore the - in the latter case)\n :return:\n \"\"\"\n if self.val_eval_criterion_MA is None:\n if len(self.all_val_eval_metrics) == 0:\n self.val_eval_criterion_MA = - self.all_val_losses[-1]\n else:\n self.val_eval_criterion_MA = self.all_val_eval_metrics[-1]\n else:\n if len(self.all_val_eval_metrics) == 0:\n \"\"\"\n We here use alpha * old - (1 - alpha) * new because new in this case is the vlaidation loss and lower \n is better, so we need to negate it. \n \"\"\"\n self.val_eval_criterion_MA = self.val_eval_criterion_alpha * self.val_eval_criterion_MA - (\n 1 - self.val_eval_criterion_alpha) * \\\n self.all_val_losses[-1]\n else:\n self.val_eval_criterion_MA = self.val_eval_criterion_alpha * self.val_eval_criterion_MA + (\n 1 - self.val_eval_criterion_alpha) * \\\n self.all_val_eval_metrics[-1]\n\n def manage_patience(self):\n # update patience\n continue_training = True\n if self.patience is not None:\n # if best_MA_tr_loss_for_patience and best_epoch_based_on_MA_tr_loss were not yet initialized,\n # initialize them\n if self.best_MA_tr_loss_for_patience is None:\n self.best_MA_tr_loss_for_patience = self.train_loss_MA\n\n if self.best_epoch_based_on_MA_tr_loss is None:\n self.best_epoch_based_on_MA_tr_loss = self.epoch\n\n if self.best_val_eval_criterion_MA is None:\n self.best_val_eval_criterion_MA = self.val_eval_criterion_MA\n\n # check if the current epoch is the best one according to moving average of validation criterion. If so\n # then save 'best' model\n # Do not use this for validation. This is intended for test set prediction only.\n self.print_to_log_file(\"current best_val_eval_criterion_MA is %.4f0\" % self.best_val_eval_criterion_MA)\n self.print_to_log_file(\"current val_eval_criterion_MA is %.4f\" % self.val_eval_criterion_MA)\n\n if self.val_eval_criterion_MA > self.best_val_eval_criterion_MA:\n self.best_val_eval_criterion_MA = self.val_eval_criterion_MA\n self.print_to_log_file(\"saving best epoch checkpoint...\")\n self.save_checkpoint(join(self.output_folder, \"model_best.model\"))\n\n # Now see if the moving average of the train loss has improved. If yes then reset patience, else\n # increase patience\n if self.train_loss_MA + self.train_loss_MA_eps < self.best_MA_tr_loss_for_patience:\n self.best_MA_tr_loss_for_patience = self.train_loss_MA\n self.best_epoch_based_on_MA_tr_loss = self.epoch\n self.print_to_log_file(\"New best epoch (train loss MA): %03.4f\" % self.best_MA_tr_loss_for_patience)\n else:\n self.print_to_log_file(\"No improvement: current train MA %03.4f, best: %03.4f, eps is %03.4f\" %\n (self.train_loss_MA, self.best_MA_tr_loss_for_patience, self.train_loss_MA_eps))\n\n # if patience has reached its maximum then finish training (provided lr is low enough)\n if self.epoch - self.best_epoch_based_on_MA_tr_loss > self.patience:\n if self.optimizer.param_groups[0]['lr'] > self.lr_threshold:\n self.print_to_log_file(\"My patience ended, but I believe I need more time (lr > 1e-6)\")\n self.best_epoch_based_on_MA_tr_loss = self.epoch - self.patience // 2\n else:\n self.print_to_log_file(\"My patience ended\")\n continue_training = False\n else:\n self.print_to_log_file(\n \"Patience: %d/%d\" % (self.epoch - self.best_epoch_based_on_MA_tr_loss, self.patience))\n\n return continue_training\n\n def on_epoch_end(self):\n self.finish_online_evaluation() # does not have to do anything, but can be used to update self.all_val_eval_\n # metrics\n\n self.plot_progress()\n\n self.maybe_update_lr()\n\n self.maybe_save_checkpoint()\n\n self.update_eval_criterion_MA()\n\n continue_training = self.manage_patience()\n continue_training = True\n return continue_training\n\n def update_train_loss_MA(self):\n if self.train_loss_MA is None:\n self.train_loss_MA = self.all_tr_losses[-1]\n else:\n self.train_loss_MA = self.train_loss_MA_alpha * self.train_loss_MA + (1 - self.train_loss_MA_alpha) * \\\n self.all_tr_losses[-1]\n\n def run_iteration(self, data_generator, do_backprop=True, run_online_evaluation=False):\n data_dict = next(data_generator)\n data = data_dict['data']\n target = data_dict['target']\n\n if not isinstance(data, torch.Tensor):\n data = torch.from_numpy(data).float()\n if not isinstance(target, torch.Tensor):\n target = torch.from_numpy(target).float()\n\n data = data.cuda(non_blocking=True)\n target = target.cuda(non_blocking=True)\n\n self.optimizer.zero_grad()\n\n output = self.network(data)\n del data\n l = self.loss(output, target)\n\n if run_online_evaluation:\n self.run_online_evaluation(output, target)\n\n del target\n\n if do_backprop:\n if not self.fp16 or amp is None:\n l.backward()\n else:\n with amp.scale_loss(l, self.optimizer) as scaled_loss:\n scaled_loss.backward()\n self.optimizer.step()\n\n return l.detach().cpu().numpy()\n\n def run_online_evaluation(self, *args, **kwargs):\n \"\"\"\n Can be implemented, does not have to\n :param output_torch:\n :param target_npy:\n :return:\n \"\"\"\n pass\n\n def finish_online_evaluation(self):\n \"\"\"\n Can be implemented, does not have to\n :return:\n \"\"\"\n pass\n\n @abstractmethod\n def validate(self, *args, **kwargs):\n pass\n\n def find_lr(self, num_iters=1000, init_value=1e-6, final_value=10., beta=0.98):\n \"\"\"\n stolen and adapted from here: https://sgugger.github.io/how-do-you-find-a-good-learning-rate.html\n :param num_iters:\n :param init_value:\n :param final_value:\n :param beta:\n :return:\n \"\"\"\n import math\n self._maybe_init_amp()\n mult = (final_value / init_value) ** (1/num_iters)\n lr = init_value\n self.optimizer.param_groups[0]['lr'] = lr\n avg_loss = 0.\n best_loss = 0.\n losses = []\n log_lrs = []\n\n for batch_num in range(1, num_iters + 1):\n # +1 because this one here is not designed to have negative loss...\n loss = self.run_iteration(self.tr_gen, do_backprop=True, run_online_evaluation=False).data.item() + 1\n\n # Compute the smoothed loss\n avg_loss = beta * avg_loss + (1-beta) * loss\n smoothed_loss = avg_loss / (1 - beta**batch_num)\n\n # Stop if the loss is exploding\n if batch_num > 1 and smoothed_loss > 4 * best_loss:\n break\n\n # Record the best loss\n if smoothed_loss < best_loss or batch_num==1:\n best_loss = smoothed_loss\n\n # Store the values\n losses.append(smoothed_loss)\n log_lrs.append(math.log10(lr))\n\n # Update the lr for the next step\n lr *= mult\n self.optimizer.param_groups[0]['lr'] = lr\n\n import matplotlib.pyplot as plt\n lrs = [10 ** i for i in log_lrs]\n fig = plt.figure()\n plt.xscale('log')\n plt.plot(lrs[10:-5], losses[10:-5])\n plt.savefig(join(self.output_folder, \"lr_finder.png\"))\n plt.close()\n return log_lrs, losses\n",
"# Copyright 2019 Division of Medical Image Computing, German Cancer Research Center (DKFZ), Heidelberg, Germany\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 numpy as np\nfrom batchgenerators.augmentations.utils import resize_segmentation\nfrom nnunet.experiment_planning.plan_and_preprocess_task import get_caseIDs_from_splitted_dataset_folder\nfrom nnunet.inference.segmentation_export import save_segmentation_nifti_from_softmax\nfrom batchgenerators.utilities.file_and_folder_operations import *\nfrom multiprocessing import Process, Queue\nimport torch\nimport SimpleITK as sitk\nimport shutil\nfrom multiprocessing import Pool\n\nfrom nnunet.training.model_restore import load_model_and_checkpoint_files\nfrom nnunet.training.network_training.nnUNetTrainer import nnUNetTrainer\nfrom nnunet.utilities.one_hot_encoding import to_one_hot\n\n\ndef predict_save_to_queue(preprocess_fn, q, list_of_lists, output_files, segs_from_prev_stage, classes):\n errors_in = []\n for i, l in enumerate(list_of_lists):\n try:\n output_file = output_files[i]\n print(\"preprocessing\", output_file)\n d, _, dct = preprocess_fn(l)\n print(output_file, dct)\n if segs_from_prev_stage[i] is not None:\n assert isfile(segs_from_prev_stage[i]) and segs_from_prev_stage[i].endswith(\".nii.gz\"), \"segs_from_prev_stage\" \\\n \" must point to a \" \\\n \"segmentation file\"\n seg_prev = sitk.GetArrayFromImage(sitk.ReadImage(segs_from_prev_stage[i]))\n # check to see if shapes match\n img = sitk.GetArrayFromImage(sitk.ReadImage(l[0]))\n assert all([i == j for i, j in zip(seg_prev.shape, img.shape)]), \"image and segmentation from previous \" \\\n \"stage don't have the same pixel array \" \\\n \"shape! image: %s, seg_prev: %s\" % \\\n (l[0], segs_from_prev_stage[i])\n seg_reshaped = resize_segmentation(seg_prev, d.shape[1:], order=1, cval=0)\n seg_reshaped = to_one_hot(seg_reshaped, classes)\n d = np.vstack((d, seg_reshaped)).astype(np.float32)\n \"\"\"There is a problem with python process communication that prevents us from communicating obejcts \n larger than 2 GB between processes (basically when the length of the pickle string that will be sent is \n communicated by the multiprocessing.Pipe object then the placeholder (\\%i I think) does not allow for long \n enough strings (lol). This could be fixed by changing i to l (for long) but that would require manually \n patching system python code. We circumvent that problem here by saving softmax_pred to a npy file that will \n then be read (and finally deleted) by the Process. save_segmentation_nifti_from_softmax can take either \n filename or np.ndarray and will handle this automatically\"\"\"\n print(d.shape)\n if np.prod(d.shape) > (2e9 / 4 * 0.9): # *0.9 just to be save, 4 because float32 is 4 bytes\n print(\n \"This output is too large for python process-process communication. \"\n \"Saving output temporarily to disk\")\n np.save(output_file[:-7] + \".npy\", d)\n d = output_file[:-7] + \".npy\"\n q.put((output_file, (d, dct)))\n except KeyboardInterrupt:\n raise KeyboardInterrupt\n except Exception as e:\n print(\"error in\", l)\n print(e)\n q.put(\"end\")\n if len(errors_in) > 0:\n print(\"There were some errors in the following cases:\", errors_in)\n print(\"These cases were ignored.\")\n else:\n print(\"This worker has ended successfully, no errors to report\")\n\n\ndef preprocess_multithreaded(trainer, list_of_lists, output_files, num_processes=2, segs_from_prev_stage=None):\n if segs_from_prev_stage is None:\n segs_from_prev_stage = [None] * len(list_of_lists)\n\n classes = list(range(1, trainer.num_classes))\n # assert isinstance(trainer, nnUNetTrainer)\n q = Queue(1)\n processes = []\n print(num_processes)\n for i in range(num_processes):\n pr = Process(target=predict_save_to_queue, args=(trainer.preprocess_patient, q,\n list_of_lists[i::num_processes],\n output_files[i::num_processes],\n segs_from_prev_stage[i::num_processes],\n classes))\n pr.start()\n processes.append(pr)\n\n try:\n end_ctr = 0\n while end_ctr != num_processes:\n item = q.get()\n if item == \"end\":\n end_ctr += 1\n continue\n else:\n yield item\n\n finally:\n for p in processes:\n if p.is_alive():\n p.terminate() # this should not happen but better safe than sorry right\n p.join()\n\n q.close()\n\n\ndef predict_cases(model, list_of_lists, output_filenames, folds, save_npz, num_threads_preprocessing,\n num_threads_nifti_save, segs_from_prev_stage=None, do_tta=True,\n overwrite_existing=False):\n\n assert len(list_of_lists) == len(output_filenames)\n if segs_from_prev_stage is not None: assert len(segs_from_prev_stage) == len(output_filenames)\n\n prman = Pool(num_threads_nifti_save)\n results = []\n\n cleaned_output_files = []\n for o in output_filenames:\n dr, f = os.path.split(o)\n if len(dr) > 0:\n maybe_mkdir_p(dr)\n if not f.endswith(\".nii.gz\"):\n f, _ = os.path.splitext(f)\n f = f + \".nii.gz\"\n cleaned_output_files.append(join(dr, f))\n\n if not overwrite_existing:\n print(\"number of cases:\", len(list_of_lists))\n not_done_idx = [i for i, j in enumerate(cleaned_output_files) if not isfile(j)]\n\n cleaned_output_files = [cleaned_output_files[i] for i in not_done_idx]\n list_of_lists = [list_of_lists[i] for i in not_done_idx]\n if segs_from_prev_stage is not None:\n segs_from_prev_stage = [segs_from_prev_stage[i] for i in not_done_idx]\n\n print(\"number of cases that still need to be predicted:\", len(cleaned_output_files))\n\n print(\"emptying cuda cache\")\n torch.cuda.empty_cache()\n\n print(\"loading parameters for folds,\", folds)\n trainer, params = load_model_and_checkpoint_files(model, folds)\n\n print(\"starting preprocessing generator\")\n preprocessing = preprocess_multithreaded(trainer, list_of_lists, cleaned_output_files, num_threads_preprocessing, segs_from_prev_stage)\n print(\"starting prediction...\")\n for preprocessed in preprocessing:\n output_filename, (d, dct) = preprocessed\n if isinstance(d, str):\n data = np.load(d)\n os.remove(d)\n d = data\n\n print(\"predicting\", output_filename)\n\n softmax = []\n for p in params:\n trainer.load_checkpoint_ram(p, False)\n softmax.append(trainer.predict_preprocessed_data_return_softmax(d, do_tta, 1, False, 1,\n trainer.data_aug_params['mirror_axes'],\n True, True, 2, trainer.patch_size, True)[None])\n\n softmax = np.vstack(softmax)\n softmax_mean = np.mean(softmax, 0)\n\n transpose_forward = trainer.plans.get('transpose_forward')\n if transpose_forward is not None:\n transpose_backward = trainer.plans.get('transpose_backward')\n softmax_mean = softmax_mean.transpose([0] + [i + 1 for i in transpose_backward])\n\n if save_npz:\n npz_file = output_filename[:-7] + \".npz\"\n else:\n npz_file = None\n\n \"\"\"There is a problem with python process communication that prevents us from communicating obejcts \n larger than 2 GB between processes (basically when the length of the pickle string that will be sent is \n communicated by the multiprocessing.Pipe object then the placeholder (\\%i I think) does not allow for long \n enough strings (lol). This could be fixed by changing i to l (for long) but that would require manually \n patching system python code. We circumvent that problem here by saving softmax_pred to a npy file that will \n then be read (and finally deleted) by the Process. save_segmentation_nifti_from_softmax can take either \n filename or np.ndarray and will handle this automatically\"\"\"\n if np.prod(softmax_mean.shape) > (2e9 / 4 * 0.9): # *0.9 just to be save\n print(\"This output is too large for python process-process communication. Saving output temporarily to disk\")\n np.save(output_filename[:-7] + \".npy\", softmax_mean)\n softmax_mean = output_filename[:-7] + \".npy\"\n\n results.append(prman.starmap_async(save_segmentation_nifti_from_softmax,\n ((softmax_mean, output_filename, dct, 1, None, None, None, npz_file), )\n ))\n\n _ = [i.get() for i in results]\n\n\ndef predict_from_folder(model, input_folder, output_folder, folds, save_npz, num_threads_preprocessing,\n num_threads_nifti_save, lowres_segmentations, part_id, num_parts, tta,\n overwrite_existing=True):\n \"\"\"\n here we use the standard naming scheme to generate list_of_lists and output_files needed by predict_cases\n :param model:\n :param input_folder:\n :param output_folder:\n :param folds:\n :param save_npz:\n :param num_threads_preprocessing:\n :param num_threads_nifti_save:\n :param lowres_segmentations:\n :param part_id:\n :param num_parts:\n :param tta:\n :return:\n \"\"\"\n maybe_mkdir_p(output_folder)\n shutil.copy(join(model, 'plans.pkl'), output_folder)\n\n case_ids = get_caseIDs_from_splitted_dataset_folder(input_folder)\n output_files = [join(output_folder, i + \".nii.gz\") for i in case_ids]\n all_files = subfiles(input_folder, suffix=\".nii.gz\", join=False, sort=True)\n list_of_lists = [[join(input_folder, i) for i in all_files if i[:len(j)].startswith(j) and\n len(i) == (len(j) + 12)] for j in case_ids]\n\n if lowres_segmentations is not None:\n assert isdir(lowres_segmentations), \"if lowres_segmentations is not None then it must point to a directory\"\n lowres_segmentations = [join(lowres_segmentations, i + \".nii.gz\") for i in case_ids]\n assert all([isfile(i) for i in lowres_segmentations]), \"not all lowres_segmentations files are present. \" \\\n \"(I was searching for case_id.nii.gz in that folder)\"\n lowres_segmentations = lowres_segmentations[part_id::num_parts]\n else:\n lowres_segmentations = None\n return predict_cases(model, list_of_lists[part_id::num_parts], output_files[part_id::num_parts], folds, save_npz,\n num_threads_preprocessing, num_threads_nifti_save, lowres_segmentations,\n tta, overwrite_existing=overwrite_existing)\n\n\nif __name__ == \"__main__\":\n parser = argparse.ArgumentParser()\n parser.add_argument(\"-i\", '--input_folder', help=\"Must contain all modalities for each patient in the correct\"\n \" order (same as training). Files must be named \"\n \"CASENAME_XXXX.nii.gz where XXXX is the modality \"\n \"identifier (0000, 0001, etc)\", required=True)\n parser.add_argument('-o', \"--output_folder\", required=True, help=\"folder for saving predictions\")\n parser.add_argument('-m', '--model_output_folder', help='model output folder. Will automatically discover the folds '\n 'that were '\n 'run and use those as an ensemble', required=True)\n parser.add_argument('-f', '--folds', nargs='+', default='None', help=\"folds to use for prediction. Default is None \"\n \"which means that folds will be detected \"\n \"automatically in the model output folder\")\n parser.add_argument('-z', '--save_npz', required=False, action='store_true', help=\"use this if you want to ensemble\"\n \" these predictions with those of\"\n \" other models. Softmax \"\n \"probabilities will be saved as \"\n \"compresed numpy arrays in \"\n \"output_folder and can be merged \"\n \"between output_folders with \"\n \"merge_predictions.py\")\n parser.add_argument('-l', '--lowres_segmentations', required=False, default='None', help=\"if model is the highres \"\n \"stage of the cascade then you need to use -l to specify where the segmentations of the \"\n \"corresponding lowres unet are. Here they are required to do a prediction\")\n parser.add_argument(\"--part_id\", type=int, required=False, default=0, help=\"Used to parallelize the prediction of \"\n \"the folder over several GPUs. If you \"\n \"want to use n GPUs to predict this \"\n \"folder you need to run this command \"\n \"n times with --part_id=0, ... n-1 and \"\n \"--num_parts=n (each with a different \"\n \"GPU (for example via \"\n \"CUDA_VISIBLE_DEVICES=X)\")\n parser.add_argument(\"--num_parts\", type=int, required=False, default=1, help=\"Used to parallelize the prediction of \"\n \"the folder over several GPUs. If you \"\n \"want to use n GPUs to predict this \"\n \"folder you need to run this command \"\n \"n times with --part_id=0, ... n-1 and \"\n \"--num_parts=n (each with a different \"\n \"GPU (via \"\n \"CUDA_VISIBLE_DEVICES=X)\")\n parser.add_argument(\"--num_threads_preprocessing\", required=False, default=6, type=int, help=\n \"Determines many background processes will be used for data preprocessing. Reduce this if you \"\n \"run into out of memory (RAM) problems. Default: 6\")\n parser.add_argument(\"--num_threads_nifti_save\", required=False, default=2, type=int, help=\n \"Determines many background processes will be used for segmentation export. Reduce this if you \"\n \"run into out of memory (RAM) problems. Default: 2\")\n parser.add_argument(\"--tta\", required=False, type=int, default=1, help=\"Set to 0 to disable test time data \"\n \"augmentation (speedup of factor \"\n \"4(2D)/8(3D)), \"\n \"lower quality segmentations\")\n parser.add_argument(\"--overwrite_existing\", required=False, type=int, default=1, help=\"Set this to 0 if you need \"\n \"to resume a previous \"\n \"prediction. Default: 1 \"\n \"(=existing segmentations \"\n \"in output_folder will be \"\n \"overwritten)\")\n\n args = parser.parse_args()\n input_folder = args.input_folder\n output_folder = args.output_folder\n part_id = args.part_id\n num_parts = args.num_parts\n model = args.model_output_folder\n folds = args.folds\n save_npz = args.save_npz\n lowres_segmentations = args.lowres_segmentations\n num_threads_preprocessing = args.num_threads_preprocessing\n num_threads_nifti_save = args.num_threads_nifti_save\n tta = args.tta\n overwrite = args.overwrite_existing\n\n if lowres_segmentations == \"None\":\n lowres_segmentations = None\n\n if isinstance(folds, list):\n if folds[0] == 'all' and len(folds) == 1:\n pass\n else:\n folds = [int(i) for i in folds]\n elif folds == \"None\":\n folds = None\n else:\n raise ValueError(\"Unexpected value for argument folds\")\n\n if tta == 0:\n tta = False\n elif tta == 1:\n tta = True\n else:\n raise ValueError(\"Unexpected value for tta, Use 1 or 0\")\n\n if overwrite == 0:\n overwrite = False\n elif overwrite == 1:\n overwrite = True\n else:\n raise ValueError(\"Unexpected value for overwrite, Use 1 or 0\")\n\n predict_from_folder(model, input_folder, output_folder, folds, save_npz, num_threads_preprocessing,\n num_threads_nifti_save, lowres_segmentations, part_id, num_parts, tta,\n overwrite_existing=overwrite)\n\n"
] | [
[
"numpy.random.seed",
"torch.cuda.current_device",
"matplotlib.use",
"torch.manual_seed",
"matplotlib.pyplot.figure",
"torch.cuda.empty_cache",
"sklearn.model_selection.KFold",
"torch.from_numpy",
"matplotlib.pyplot.plot",
"numpy.argmax",
"numpy.mean",
"torch.no_grad",
"torch.cuda.manual_seed_all",
"matplotlib.pyplot.close",
"matplotlib.pyplot.xscale",
"numpy.array",
"matplotlib.rc",
"torch.save"
],
[
"torch.cuda.empty_cache",
"numpy.save",
"numpy.mean",
"numpy.prod",
"numpy.load",
"numpy.vstack"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
Pradeep-Gopal/yolo_deer_people_final_project | [
"2337e8cbb88f467a6d19ab9cdb14abbf2ba04bc2",
"2337e8cbb88f467a6d19ab9cdb14abbf2ba04bc2"
] | [
"yolov3_tiny_deer_detection/evaluate_mAP.py",
"yolov3_tiny_deer_detection/yolov3/yolov3.py"
] | [
"\nimport os\nos.environ['CUDA_VISIBLE_DEVICES'] = '0'\nimport cv2\nimport numpy as np\nimport tensorflow as tf\nfrom tensorflow.python.saved_model import tag_constants\nfrom yolov3.dataset import Dataset\nfrom yolov3.yolov4 import Create_Yolo\nfrom yolov3.utils import load_yolo_weights, detect_image, image_preprocess, postprocess_boxes, nms, read_class_names\nfrom yolov3.configs import *\nimport shutil\nimport json\nimport time\n\ngpus = tf.config.experimental.list_physical_devices('GPU')\nif len(gpus) > 0:\n try: tf.config.experimental.set_memory_growth(gpus[0], True)\n except RuntimeError: print(\"RuntimeError in tf.config.experimental.list_physical_devices('GPU')\")\n\n\ndef voc_ap(rec, prec):\n \"\"\"\n --- Official matlab code VOC2012---\n mrec=[0 ; rec ; 1];\n mpre=[0 ; prec ; 0];\n for i=numel(mpre)-1:-1:1\n mpre(i)=max(mpre(i),mpre(i+1));\n end\n i=find(mrec(2:end)~=mrec(1:end-1))+1;\n ap=sum((mrec(i)-mrec(i-1)).*mpre(i));\n \"\"\"\n rec.insert(0, 0.0) # insert 0.0 at begining of list\n rec.append(1.0) # insert 1.0 at end of list\n mrec = rec[:]\n prec.insert(0, 0.0) # insert 0.0 at begining of list\n prec.append(0.0) # insert 0.0 at end of list\n mpre = prec[:]\n \"\"\"\n This part makes the precision monotonically decreasing\n (goes from the end to the beginning)\n matlab: for i=numel(mpre)-1:-1:1\n mpre(i)=max(mpre(i),mpre(i+1));\n \"\"\"\n # matlab indexes start in 1 but python in 0, so I have to do:\n # range(start=(len(mpre) - 2), end=0, step=-1)\n # also the python function range excludes the end, resulting in:\n # range(start=(len(mpre) - 2), end=-1, step=-1)\n for i in range(len(mpre)-2, -1, -1):\n mpre[i] = max(mpre[i], mpre[i+1])\n \"\"\"\n This part creates a list of indexes where the recall changes\n matlab: i=find(mrec(2:end)~=mrec(1:end-1))+1;\n \"\"\"\n i_list = []\n for i in range(1, len(mrec)):\n if mrec[i] != mrec[i-1]:\n i_list.append(i) # if it was matlab would be i + 1\n \"\"\"\n The Average Precision (AP) is the area under the curve\n (numerical integration)\n matlab: ap=sum((mrec(i)-mrec(i-1)).*mpre(i));\n \"\"\"\n ap = 0.0\n for i in i_list:\n ap += ((mrec[i]-mrec[i-1])*mpre[i])\n return ap, mrec, mpre\n\n\ndef get_mAP(Yolo, dataset, score_threshold=0.25, iou_threshold=0.50, TEST_INPUT_SIZE=TEST_INPUT_SIZE):\n MINOVERLAP = 0.5 # default value (defined in the PASCAL VOC2012 challenge)\n NUM_CLASS = read_class_names(TRAIN_CLASSES)\n\n ground_truth_dir_path = 'mAP/ground-truth'\n if os.path.exists(ground_truth_dir_path): shutil.rmtree(ground_truth_dir_path)\n\n if not os.path.exists('mAP'): os.mkdir('mAP')\n os.mkdir(ground_truth_dir_path)\n\n print(f'\\ncalculating mAP{int(iou_threshold*100)}...\\n')\n\n gt_counter_per_class = {}\n for index in range(dataset.num_samples):\n ann_dataset = dataset.annotations[index]\n\n original_image, bbox_data_gt = dataset.parse_annotation(ann_dataset, True)\n\n if len(bbox_data_gt) == 0:\n bboxes_gt = []\n classes_gt = []\n else:\n bboxes_gt, classes_gt = bbox_data_gt[:, :4], bbox_data_gt[:, 4]\n ground_truth_path = os.path.join(ground_truth_dir_path, str(index) + '.txt')\n num_bbox_gt = len(bboxes_gt)\n\n bounding_boxes = []\n for i in range(num_bbox_gt):\n class_name = NUM_CLASS[classes_gt[i]]\n xmin, ymin, xmax, ymax = list(map(str, bboxes_gt[i]))\n bbox = xmin + \" \" + ymin + \" \" + xmax + \" \" +ymax\n bounding_boxes.append({\"class_name\":class_name, \"bbox\":bbox, \"used\":False})\n\n # count that object\n if class_name in gt_counter_per_class:\n gt_counter_per_class[class_name] += 1\n else:\n # if class didn't exist yet\n gt_counter_per_class[class_name] = 1\n bbox_mess = ' '.join([class_name, xmin, ymin, xmax, ymax]) + '\\n'\n with open(f'{ground_truth_dir_path}/{str(index)}_ground_truth.json', 'w') as outfile:\n json.dump(bounding_boxes, outfile)\n\n gt_classes = list(gt_counter_per_class.keys())\n # sort the classes alphabetically\n gt_classes = sorted(gt_classes)\n n_classes = len(gt_classes)\n\n times = []\n json_pred = [[] for i in range(n_classes)]\n for index in range(dataset.num_samples):\n ann_dataset = dataset.annotations[index]\n\n image_name = ann_dataset[0].split('/')[-1]\n original_image, bbox_data_gt = dataset.parse_annotation(ann_dataset, True)\n \n image = image_preprocess(np.copy(original_image), [TEST_INPUT_SIZE, TEST_INPUT_SIZE])\n image_data = image[np.newaxis, ...].astype(np.float32)\n\n t1 = time.time()\n if YOLO_FRAMEWORK == \"tf\":\n pred_bbox = Yolo.predict(image_data)\n elif YOLO_FRAMEWORK == \"trt\":\n batched_input = tf.constant(image_data)\n result = Yolo(batched_input)\n pred_bbox = []\n for key, value in result.items():\n value = value.numpy()\n pred_bbox.append(value)\n \n t2 = time.time()\n \n times.append(t2-t1)\n \n pred_bbox = [tf.reshape(x, (-1, tf.shape(x)[-1])) for x in pred_bbox]\n pred_bbox = tf.concat(pred_bbox, axis=0)\n\n bboxes = postprocess_boxes(pred_bbox, original_image, TEST_INPUT_SIZE, score_threshold)\n bboxes = nms(bboxes, iou_threshold, method='nms')\n\n for bbox in bboxes:\n coor = np.array(bbox[:4], dtype=np.int32)\n score = bbox[4]\n class_ind = int(bbox[5])\n class_name = NUM_CLASS[class_ind]\n score = '%.4f' % score\n xmin, ymin, xmax, ymax = list(map(str, coor))\n bbox = xmin + \" \" + ymin + \" \" + xmax + \" \" +ymax\n json_pred[gt_classes.index(class_name)].append({\"confidence\": str(score), \"file_id\": str(index), \"bbox\": str(bbox)})\n\n ms = sum(times)/len(times)*1000\n fps = 1000 / ms\n\n for class_name in gt_classes:\n json_pred[gt_classes.index(class_name)].sort(key=lambda x:float(x['confidence']), reverse=True)\n with open(f'{ground_truth_dir_path}/{class_name}_predictions.json', 'w') as outfile:\n json.dump(json_pred[gt_classes.index(class_name)], outfile)\n\n # Calculate the AP for each class\n sum_AP = 0.0\n ap_dictionary = {}\n # open file to store the results\n with open(\"mAP/results.txt\", 'w') as results_file:\n results_file.write(\"# AP and precision/recall per class\\n\")\n count_true_positives = {}\n for class_index, class_name in enumerate(gt_classes):\n count_true_positives[class_name] = 0\n # Load predictions of that class\n predictions_file = f'{ground_truth_dir_path}/{class_name}_predictions.json'\n predictions_data = json.load(open(predictions_file))\n\n # Assign predictions to ground truth objects\n nd = len(predictions_data)\n tp = [0] * nd # creates an array of zeros of size nd\n fp = [0] * nd\n for idx, prediction in enumerate(predictions_data):\n file_id = prediction[\"file_id\"]\n # assign prediction to ground truth object if any\n # open ground-truth with that file_id\n gt_file = f'{ground_truth_dir_path}/{str(file_id)}_ground_truth.json'\n ground_truth_data = json.load(open(gt_file))\n ovmax = -1\n gt_match = -1\n # load prediction bounding-box\n bb = [ float(x) for x in prediction[\"bbox\"].split() ] # bounding box of prediction\n for obj in ground_truth_data:\n # look for a class_name match\n if obj[\"class_name\"] == class_name:\n bbgt = [ float(x) for x in obj[\"bbox\"].split() ] # bounding box of ground truth\n bi = [max(bb[0],bbgt[0]), max(bb[1],bbgt[1]), min(bb[2],bbgt[2]), min(bb[3],bbgt[3])]\n iw = bi[2] - bi[0] + 1\n ih = bi[3] - bi[1] + 1\n if iw > 0 and ih > 0:\n # compute overlap (IoU) = area of intersection / area of union\n ua = (bb[2] - bb[0] + 1) * (bb[3] - bb[1] + 1) + (bbgt[2] - bbgt[0]\n + 1) * (bbgt[3] - bbgt[1] + 1) - iw * ih\n ov = iw * ih / ua\n if ov > ovmax:\n ovmax = ov\n gt_match = obj\n\n # assign prediction as true positive/don't care/false positive\n if ovmax >= MINOVERLAP:# if ovmax > minimum overlap\n if not bool(gt_match[\"used\"]):\n # true positive\n tp[idx] = 1\n gt_match[\"used\"] = True\n count_true_positives[class_name] += 1\n # update the \".json\" file\n with open(gt_file, 'w') as f:\n f.write(json.dumps(ground_truth_data))\n else:\n # false positive (multiple detection)\n fp[idx] = 1\n else:\n # false positive\n fp[idx] = 1\n\n # compute precision/recall\n cumsum = 0\n for idx, val in enumerate(fp):\n fp[idx] += cumsum\n cumsum += val\n cumsum = 0\n for idx, val in enumerate(tp):\n tp[idx] += cumsum\n cumsum += val\n #print(tp)\n rec = tp[:]\n for idx, val in enumerate(tp):\n rec[idx] = float(tp[idx]) / gt_counter_per_class[class_name]\n #print(rec)\n prec = tp[:]\n for idx, val in enumerate(tp):\n prec[idx] = float(tp[idx]) / (fp[idx] + tp[idx])\n #print(prec)\n\n ap, mrec, mprec = voc_ap(rec, prec)\n sum_AP += ap\n text = \"{0:.3f}%\".format(ap*100) + \" = \" + class_name + \" AP \" #class_name + \" AP = {0:.2f}%\".format(ap*100)\n\n rounded_prec = [ '%.3f' % elem for elem in prec ]\n rounded_rec = [ '%.3f' % elem for elem in rec ]\n # Write to results.txt\n results_file.write(text + \"\\n Precision: \" + str(rounded_prec) + \"\\n Recall :\" + str(rounded_rec) + \"\\n\\n\")\n\n print(text)\n ap_dictionary[class_name] = ap\n\n results_file.write(\"\\n# mAP of all classes\\n\")\n mAP = sum_AP / n_classes\n\n text = \"mAP = {:.3f}%, {:.2f} FPS\".format(mAP*100, fps)\n results_file.write(text + \"\\n\")\n print(text)\n \n return mAP*100\n\nif __name__ == '__main__': \n if YOLO_FRAMEWORK == \"tf\": # TensorFlow detection\n if YOLO_TYPE == \"yolov4\":\n Darknet_weights = YOLO_V4_TINY_WEIGHTS if TRAIN_YOLO_TINY else YOLO_V4_WEIGHTS\n if YOLO_TYPE == \"yolov3\":\n Darknet_weights = YOLO_V3_TINY_WEIGHTS if TRAIN_YOLO_TINY else YOLO_V3_WEIGHTS\n\n if YOLO_CUSTOM_WEIGHTS == False:\n yolo = Create_Yolo(input_size=YOLO_INPUT_SIZE, CLASSES=YOLO_COCO_CLASSES)\n load_yolo_weights(yolo, Darknet_weights) # use Darknet weights\n else:\n yolo = Create_Yolo(input_size=YOLO_INPUT_SIZE, CLASSES=TRAIN_CLASSES)\n yolo.load_weights(f\"./checkpoints/{TRAIN_MODEL_NAME}\") # use custom weights\n \n elif YOLO_FRAMEWORK == \"trt\": # TensorRT detection\n saved_model_loaded = tf.saved_model.load(f\"./checkpoints/{TRAIN_MODEL_NAME}\", tags=[tag_constants.SERVING])\n signature_keys = list(saved_model_loaded.signatures.keys())\n yolo = saved_model_loaded.signatures['serving_default']\n\n testset = Dataset('test', TEST_INPUT_SIZE=YOLO_INPUT_SIZE)\n get_mAP(yolo, testset, score_threshold=0.05, iou_threshold=0.50, TEST_INPUT_SIZE=YOLO_INPUT_SIZE)\n",
"\nimport numpy as np\nimport tensorflow as tf\nfrom tensorflow.keras.layers import Conv2D, Input, LeakyReLU, ZeroPadding2D, BatchNormalization, MaxPool2D\nfrom tensorflow.keras.regularizers import l2\nfrom yolov3.utils import read_class_names\nfrom yolov3.configs import *\n\nSTRIDES = np.array(YOLO_STRIDES)\nANCHORS = (np.array(YOLO_ANCHORS).T/STRIDES).T\n\nclass BatchNormalization(BatchNormalization):\n # \"Frozen state\" and \"inference mode\" are two separate concepts.\n # `layer.trainable = False` is to freeze the layer, so the layer will use\n # stored moving `var` and `mean` in the \"inference mode\", and both `gama`\n # and `beta` will not be updated !\n def call(self, x, training=False):\n if not training:\n training = tf.constant(False)\n training = tf.logical_and(training, self.trainable)\n return super().call(x, training)\n\ndef convolutional(input_layer, filters_shape, downsample=False, activate=True, bn=True):\n if downsample:\n input_layer = ZeroPadding2D(((1, 0), (1, 0)))(input_layer)\n padding = 'valid'\n strides = 2\n else:\n strides = 1\n padding = 'same'\n\n conv = Conv2D(filters=filters_shape[-1], kernel_size = filters_shape[0], strides=strides,\n padding=padding, use_bias=not bn, kernel_regularizer=l2(0.0005),\n kernel_initializer=tf.random_normal_initializer(stddev=0.01),\n bias_initializer=tf.constant_initializer(0.))(input_layer)\n if bn:\n conv = BatchNormalization()(conv)\n if activate == True:\n conv = LeakyReLU(alpha=0.1)(conv)\n\n return conv\n\ndef residual_block(input_layer, input_channel, filter_num1, filter_num2):\n short_cut = input_layer\n conv = convolutional(input_layer, filters_shape=(1, 1, input_channel, filter_num1))\n conv = convolutional(conv , filters_shape=(3, 3, filter_num1, filter_num2))\n\n residual_output = short_cut + conv\n return residual_output\n\ndef upsample(input_layer):\n return tf.image.resize(input_layer, (input_layer.shape[1] * 2, input_layer.shape[2] * 2), method='nearest')\n\n\ndef darknet53(input_data):\n input_data = convolutional(input_data, (3, 3, 3, 32))\n input_data = convolutional(input_data, (3, 3, 32, 64), downsample=True)\n\n for i in range(1):\n input_data = residual_block(input_data, 64, 32, 64)\n\n input_data = convolutional(input_data, (3, 3, 64, 128), downsample=True)\n\n for i in range(2):\n input_data = residual_block(input_data, 128, 64, 128)\n\n input_data = convolutional(input_data, (3, 3, 128, 256), downsample=True)\n\n for i in range(8):\n input_data = residual_block(input_data, 256, 128, 256)\n\n route_1 = input_data\n input_data = convolutional(input_data, (3, 3, 256, 512), downsample=True)\n\n for i in range(8):\n input_data = residual_block(input_data, 512, 256, 512)\n\n route_2 = input_data\n input_data = convolutional(input_data, (3, 3, 512, 1024), downsample=True)\n\n for i in range(4):\n input_data = residual_block(input_data, 1024, 512, 1024)\n\n return route_1, route_2, input_data\n\ndef darknet19_tiny(input_data):\n input_data = convolutional(input_data, (3, 3, 3, 16))\n input_data = MaxPool2D(2, 2, 'same')(input_data)\n input_data = convolutional(input_data, (3, 3, 16, 32))\n input_data = MaxPool2D(2, 2, 'same')(input_data)\n input_data = convolutional(input_data, (3, 3, 32, 64))\n input_data = MaxPool2D(2, 2, 'same')(input_data)\n input_data = convolutional(input_data, (3, 3, 64, 128))\n input_data = MaxPool2D(2, 2, 'same')(input_data)\n input_data = convolutional(input_data, (3, 3, 128, 256))\n route_1 = input_data\n input_data = MaxPool2D(2, 2, 'same')(input_data)\n input_data = convolutional(input_data, (3, 3, 256, 512))\n input_data = MaxPool2D(2, 1, 'same')(input_data)\n input_data = convolutional(input_data, (3, 3, 512, 1024))\n\n return route_1, input_data\n\ndef YOLOv3(input_layer, NUM_CLASS):\n # After the input layer enters the Darknet-53 network, we get three branches\n route_1, route_2, conv = darknet53(input_layer)\n # See the orange module (DBL) in the figure above, a total of 5 Subconvolution operation\n conv = convolutional(conv, (1, 1, 1024, 512))\n conv = convolutional(conv, (3, 3, 512, 1024))\n conv = convolutional(conv, (1, 1, 1024, 512))\n conv = convolutional(conv, (3, 3, 512, 1024))\n conv = convolutional(conv, (1, 1, 1024, 512))\n conv_lobj_branch = convolutional(conv, (3, 3, 512, 1024))\n \n # conv_lbbox is used to predict large-sized objects , Shape = [None, 13, 13, 255] \n conv_lbbox = convolutional(conv_lobj_branch, (1, 1, 1024, 3*(NUM_CLASS + 5)), activate=False, bn=False)\n\n conv = convolutional(conv, (1, 1, 512, 256))\n # upsample here uses the nearest neighbor interpolation method, which has the advantage that the\n # upsampling process does not need to learn, thereby reducing the network parameter \n conv = upsample(conv)\n\n conv = tf.concat([conv, route_2], axis=-1)\n conv = convolutional(conv, (1, 1, 768, 256))\n conv = convolutional(conv, (3, 3, 256, 512))\n conv = convolutional(conv, (1, 1, 512, 256))\n conv = convolutional(conv, (3, 3, 256, 512))\n conv = convolutional(conv, (1, 1, 512, 256))\n conv_mobj_branch = convolutional(conv, (3, 3, 256, 512))\n\n # conv_mbbox is used to predict medium-sized objects, shape = [None, 26, 26, 255]\n conv_mbbox = convolutional(conv_mobj_branch, (1, 1, 512, 3*(NUM_CLASS + 5)), activate=False, bn=False)\n\n conv = convolutional(conv, (1, 1, 256, 128))\n conv = upsample(conv)\n\n conv = tf.concat([conv, route_1], axis=-1)\n conv = convolutional(conv, (1, 1, 384, 128))\n conv = convolutional(conv, (3, 3, 128, 256))\n conv = convolutional(conv, (1, 1, 256, 128))\n conv = convolutional(conv, (3, 3, 128, 256))\n conv = convolutional(conv, (1, 1, 256, 128))\n conv_sobj_branch = convolutional(conv, (3, 3, 128, 256))\n \n # conv_sbbox is used to predict small size objects, shape = [None, 52, 52, 255]\n conv_sbbox = convolutional(conv_sobj_branch, (1, 1, 256, 3*(NUM_CLASS +5)), activate=False, bn=False)\n \n return [conv_sbbox, conv_mbbox, conv_lbbox]\n\ndef YOLOv3_tiny(input_layer, NUM_CLASS):\n # After the input layer enters the Darknet-53 network, we get three branches\n route_1, conv = darknet19_tiny(input_layer)\n\n conv = convolutional(conv, (1, 1, 1024, 256))\n conv_lobj_branch = convolutional(conv, (3, 3, 256, 512))\n \n # conv_lbbox is used to predict large-sized objects , Shape = [None, 26, 26, 255]\n conv_lbbox = convolutional(conv_lobj_branch, (1, 1, 512, 3*(NUM_CLASS + 5)), activate=False, bn=False)\n\n conv = convolutional(conv, (1, 1, 256, 128))\n # upsample here uses the nearest neighbor interpolation method, which has the advantage that the\n # upsampling process does not need to learn, thereby reducing the network parameter \n conv = upsample(conv)\n \n conv = tf.concat([conv, route_1], axis=-1)\n conv_mobj_branch = convolutional(conv, (3, 3, 128, 256))\n # conv_mbbox is used to predict medium size objects, shape = [None, 13, 13, 255]\n conv_mbbox = convolutional(conv_mobj_branch, (1, 1, 256, 3 * (NUM_CLASS + 5)), activate=False, bn=False)\n\n return [conv_mbbox, conv_lbbox]\n\ndef Create_Yolov3(input_size=416, channels=3, training=False, CLASSES=YOLO_COCO_CLASSES):\n NUM_CLASS = len(read_class_names(CLASSES))\n input_layer = Input([input_size, input_size, channels])\n\n if TRAIN_YOLO_TINY:\n conv_tensors = YOLOv3_tiny(input_layer, NUM_CLASS)\n else:\n conv_tensors = YOLOv3(input_layer, NUM_CLASS)\n\n output_tensors = []\n for i, conv_tensor in enumerate(conv_tensors):\n pred_tensor = decode(conv_tensor, NUM_CLASS, i)\n if training: output_tensors.append(conv_tensor)\n output_tensors.append(pred_tensor)\n\n YoloV3 = tf.keras.Model(input_layer, output_tensors)\n return YoloV3\n\ndef decode(conv_output, NUM_CLASS, i=0):\n # where i = 0, 1 or 2 to correspond to the three grid scales \n conv_shape = tf.shape(conv_output)\n batch_size = conv_shape[0]\n output_size = conv_shape[1]\n\n conv_output = tf.reshape(conv_output, (batch_size, output_size, output_size, 3, 5 + NUM_CLASS))\n\n conv_raw_dxdy = conv_output[:, :, :, :, 0:2] # offset of center position \n conv_raw_dwdh = conv_output[:, :, :, :, 2:4] # Prediction box length and width offset\n conv_raw_conf = conv_output[:, :, :, :, 4:5] # confidence of the prediction box\n conv_raw_prob = conv_output[:, :, :, :, 5: ] # category probability of the prediction box \n\n # next need Draw the grid. Where output_size is equal to 13, 26 or 52 \n y = tf.range(output_size, dtype=tf.int32)\n y = tf.expand_dims(y, -1)\n y = tf.tile(y, [1, output_size])\n x = tf.range(output_size,dtype=tf.int32)\n x = tf.expand_dims(x, 0)\n x = tf.tile(x, [output_size, 1])\n\n xy_grid = tf.concat([x[:, :, tf.newaxis], y[:, :, tf.newaxis]], axis=-1)\n xy_grid = tf.tile(xy_grid[tf.newaxis, :, :, tf.newaxis, :], [batch_size, 1, 1, 3, 1])\n xy_grid = tf.cast(xy_grid, tf.float32)\n\n # Calculate the center position of the prediction box:\n pred_xy = (tf.sigmoid(conv_raw_dxdy) + xy_grid) * STRIDES[i]\n # Calculate the length and width of the prediction box:\n pred_wh = (tf.exp(conv_raw_dwdh) * ANCHORS[i]) * STRIDES[i]\n\n pred_xywh = tf.concat([pred_xy, pred_wh], axis=-1)\n pred_conf = tf.sigmoid(conv_raw_conf) # object box calculates the predicted confidence\n pred_prob = tf.sigmoid(conv_raw_prob) # calculating the predicted probability category box object\n\n # calculating the predicted probability category box object\n return tf.concat([pred_xywh, pred_conf, pred_prob], axis=-1)\n\ndef bbox_iou(boxes1, boxes2):\n boxes1_area = boxes1[..., 2] * boxes1[..., 3]\n boxes2_area = boxes2[..., 2] * boxes2[..., 3]\n\n boxes1 = tf.concat([boxes1[..., :2] - boxes1[..., 2:] * 0.5,\n boxes1[..., :2] + boxes1[..., 2:] * 0.5], axis=-1)\n boxes2 = tf.concat([boxes2[..., :2] - boxes2[..., 2:] * 0.5,\n boxes2[..., :2] + boxes2[..., 2:] * 0.5], axis=-1)\n\n left_up = tf.maximum(boxes1[..., :2], boxes2[..., :2])\n right_down = tf.minimum(boxes1[..., 2:], boxes2[..., 2:])\n\n inter_section = tf.maximum(right_down - left_up, 0.0)\n inter_area = inter_section[..., 0] * inter_section[..., 1]\n union_area = boxes1_area + boxes2_area - inter_area\n\n return 1.0 * inter_area / union_area\n\ndef bbox_giou(boxes1, boxes2):\n boxes1 = tf.concat([boxes1[..., :2] - boxes1[..., 2:] * 0.5,\n boxes1[..., :2] + boxes1[..., 2:] * 0.5], axis=-1)\n boxes2 = tf.concat([boxes2[..., :2] - boxes2[..., 2:] * 0.5,\n boxes2[..., :2] + boxes2[..., 2:] * 0.5], axis=-1)\n\n boxes1 = tf.concat([tf.minimum(boxes1[..., :2], boxes1[..., 2:]),\n tf.maximum(boxes1[..., :2], boxes1[..., 2:])], axis=-1)\n boxes2 = tf.concat([tf.minimum(boxes2[..., :2], boxes2[..., 2:]),\n tf.maximum(boxes2[..., :2], boxes2[..., 2:])], axis=-1)\n\n boxes1_area = (boxes1[..., 2] - boxes1[..., 0]) * (boxes1[..., 3] - boxes1[..., 1])\n boxes2_area = (boxes2[..., 2] - boxes2[..., 0]) * (boxes2[..., 3] - boxes2[..., 1])\n\n left_up = tf.maximum(boxes1[..., :2], boxes2[..., :2])\n right_down = tf.minimum(boxes1[..., 2:], boxes2[..., 2:])\n\n inter_section = tf.maximum(right_down - left_up, 0.0)\n inter_area = inter_section[..., 0] * inter_section[..., 1]\n union_area = boxes1_area + boxes2_area - inter_area\n\n # Calculate the iou value between the two bounding boxes\n iou = inter_area / union_area\n\n # Calculate the coordinates of the upper left corner and the lower right corner of the smallest closed convex surface\n enclose_left_up = tf.minimum(boxes1[..., :2], boxes2[..., :2])\n enclose_right_down = tf.maximum(boxes1[..., 2:], boxes2[..., 2:])\n enclose = tf.maximum(enclose_right_down - enclose_left_up, 0.0)\n\n # Calculate the area of the smallest closed convex surface C\n enclose_area = enclose[..., 0] * enclose[..., 1]\n\n # Calculate the GIoU value according to the GioU formula \n giou = iou - 1.0 * (enclose_area - union_area) / enclose_area\n\n return giou\n\n# testing (should be better than giou)\ndef bbox_ciou(boxes1, boxes2):\n boxes1_coor = tf.concat([boxes1[..., :2] - boxes1[..., 2:] * 0.5,\n boxes1[..., :2] + boxes1[..., 2:] * 0.5], axis=-1)\n boxes2_coor = tf.concat([boxes2[..., :2] - boxes2[..., 2:] * 0.5,\n boxes2[..., :2] + boxes2[..., 2:] * 0.5], axis=-1)\n\n left = tf.maximum(boxes1_coor[..., 0], boxes2_coor[..., 0])\n up = tf.maximum(boxes1_coor[..., 1], boxes2_coor[..., 1])\n right = tf.maximum(boxes1_coor[..., 2], boxes2_coor[..., 2])\n down = tf.maximum(boxes1_coor[..., 3], boxes2_coor[..., 3])\n\n c = (right - left) * (right - left) + (up - down) * (up - down)\n iou = bbox_iou(boxes1, boxes2)\n\n u = (boxes1[..., 0] - boxes2[..., 0]) * (boxes1[..., 0] - boxes2[..., 0]) + (boxes1[..., 1] - boxes2[..., 1]) * (boxes1[..., 1] - boxes2[..., 1])\n d = u / c\n\n ar_gt = boxes2[..., 2] / boxes2[..., 3]\n ar_pred = boxes1[..., 2] / boxes1[..., 3]\n\n ar_loss = 4 / (np.pi * np.pi) * (tf.atan(ar_gt) - tf.atan(ar_pred)) * (tf.atan(ar_gt) - tf.atan(ar_pred))\n alpha = ar_loss / (1 - iou + ar_loss + 0.000001)\n ciou_term = d + alpha * ar_loss\n\n return iou - ciou_term\n\n\ndef compute_loss(pred, conv, label, bboxes, i=0, CLASSES=YOLO_COCO_CLASSES):\n NUM_CLASS = len(read_class_names(CLASSES))\n conv_shape = tf.shape(conv)\n batch_size = conv_shape[0]\n output_size = conv_shape[1]\n input_size = STRIDES[i] * output_size\n conv = tf.reshape(conv, (batch_size, output_size, output_size, 3, 5 + NUM_CLASS))\n\n conv_raw_conf = conv[:, :, :, :, 4:5]\n conv_raw_prob = conv[:, :, :, :, 5:]\n\n pred_xywh = pred[:, :, :, :, 0:4]\n pred_conf = pred[:, :, :, :, 4:5]\n\n label_xywh = label[:, :, :, :, 0:4]\n respond_bbox = label[:, :, :, :, 4:5]\n label_prob = label[:, :, :, :, 5:]\n\n giou = tf.expand_dims(bbox_giou(pred_xywh, label_xywh), axis=-1)\n input_size = tf.cast(input_size, tf.float32)\n\n bbox_loss_scale = 2.0 - 1.0 * label_xywh[:, :, :, :, 2:3] * label_xywh[:, :, :, :, 3:4] / (input_size ** 2)\n giou_loss = respond_bbox * bbox_loss_scale * (1 - giou)\n\n iou = bbox_iou(pred_xywh[:, :, :, :, np.newaxis, :], bboxes[:, np.newaxis, np.newaxis, np.newaxis, :, :])\n # Find the value of IoU with the real box The largest prediction box\n max_iou = tf.expand_dims(tf.reduce_max(iou, axis=-1), axis=-1)\n\n # If the largest iou is less than the threshold, it is considered that the prediction box contains no objects, then the background box\n respond_bgd = (1.0 - respond_bbox) * tf.cast( max_iou < YOLO_IOU_LOSS_THRESH, tf.float32 )\n\n conf_focal = tf.pow(respond_bbox - pred_conf, 2)\n\n # Calculate the loss of confidence\n # we hope that if the grid contains objects, then the network output prediction box has a confidence of 1 and 0 when there is no object.\n conf_loss = conf_focal * (\n respond_bbox * tf.nn.sigmoid_cross_entropy_with_logits(labels=respond_bbox, logits=conv_raw_conf)\n +\n respond_bgd * tf.nn.sigmoid_cross_entropy_with_logits(labels=respond_bbox, logits=conv_raw_conf)\n )\n\n prob_loss = respond_bbox * tf.nn.sigmoid_cross_entropy_with_logits(labels=label_prob, logits=conv_raw_prob)\n\n giou_loss = tf.reduce_mean(tf.reduce_sum(giou_loss, axis=[1,2,3,4]))\n conf_loss = tf.reduce_mean(tf.reduce_sum(conf_loss, axis=[1,2,3,4]))\n prob_loss = tf.reduce_mean(tf.reduce_sum(prob_loss, axis=[1,2,3,4]))\n\n return giou_loss, conf_loss, prob_loss\n"
] | [
[
"tensorflow.concat",
"tensorflow.saved_model.load",
"tensorflow.constant",
"tensorflow.config.experimental.set_memory_growth",
"tensorflow.shape",
"tensorflow.config.experimental.list_physical_devices",
"numpy.copy",
"numpy.array"
],
[
"tensorflow.concat",
"tensorflow.reduce_sum",
"tensorflow.cast",
"tensorflow.minimum",
"tensorflow.nn.sigmoid_cross_entropy_with_logits",
"tensorflow.keras.layers.ZeroPadding2D",
"tensorflow.keras.layers.LeakyReLU",
"tensorflow.keras.regularizers.l2",
"tensorflow.random_normal_initializer",
"tensorflow.tile",
"tensorflow.atan",
"tensorflow.shape",
"tensorflow.pow",
"tensorflow.exp",
"tensorflow.keras.Model",
"numpy.array",
"tensorflow.reduce_max",
"tensorflow.keras.layers.Input",
"tensorflow.constant",
"tensorflow.range",
"tensorflow.maximum",
"tensorflow.reshape",
"tensorflow.sigmoid",
"tensorflow.expand_dims",
"tensorflow.keras.layers.MaxPool2D",
"tensorflow.constant_initializer",
"tensorflow.image.resize",
"tensorflow.keras.layers.BatchNormalization",
"tensorflow.logical_and"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"1.10",
"2.7",
"2.6",
"2.4",
"2.3",
"2.5",
"2.2"
]
}
] |
DenisSch/svca | [
"bd029c120ca8310f43311253e4d7ce19bc08350c",
"bd029c120ca8310f43311253e4d7ce19bc08350c",
"bd029c120ca8310f43311253e4d7ce19bc08350c"
] | [
"svca_limix/limix/core/mean/mean.py",
"svca_limix/demos/demo_gp2kronSumLR.py",
"svca_limix/limix/core/covar/zkz.py"
] | [
"import sys\nfrom limix.core.old.cobj import *\nfrom limix.utils.preprocess import regressOut\nimport numpy as np\n\nimport scipy.linalg as LA\nimport copy\n\ndef compute_X1KX2(Y, D, X1, X2, A1=None, A2=None):\n\n R,C = Y.shape\n if A1 is None:\n nW_A1 = Y.shape[1]\n #A1 = np.eye(Y.shape[1])\t#for now this creates A1 and A2\n else:\n nW_A1 = A1.shape[0]\n\n if A2 is None:\n nW_A2 = Y.shape[1]\n #A2 = np.eye(Y.shape[1])\t#for now this creates A1 and A2\n else:\n nW_A2 = A2.shape[0]\n\n\n nW_X1 = X1.shape[1]\n rows_block = nW_A1 * nW_X1\n\n if 0:#independentX2:\n nW_X2 = 1\n else:\n nW_X2 = X2.shape[1]\n cols_block = nW_A2 * nW_X2\n\n block = np.zeros((rows_block,cols_block))\n\n\n if (R>C) or (A1 is None) or (A2 is None):\n for c in range(C):\n X1D = X1 * D[:,c:c+1]\n X1X2 = X1D.T.dot(X2)\n if (A1 is None) and (A2 is None):\n block[c*X1.shape[1]:(c+1)*X1.shape[1], c*X2.shape[1]:(c+1)*X2.shape[1]] += X1X2\n elif (A1 is None):\n block[c*X1.shape[1]:(c+1)*X1.shape[1],:] += np.kron(A2[:,c:c+1].T,X1X2)\n elif (A2 is None):\n block[:,c*X2.shape[1]:(c+1)*X2.shape[1]] += np.kron(A1[:,c:c+1],X1X2)\n else:\n A1A2 = np.outer(A1[:,c],A2[:,c])\n block += np.kron(A1A2,X1X2)\n else:\n for r in range(R):\n A1D = A1 * D[r:r+1,:]\n A1A2 = A1D.dot(A2.T)\n X1X2 = X1[r,:][:,np.newaxis].dot(X2[r,:][np.newaxis,:])\n block += np.kron(A1A2,X1X2)\n\n return block\n\nclass mean(cObject):\n\n def __init__(self,Y, identity_trick=False):\n \"\"\" init data term \"\"\"\n self.Y = Y\n self.identity_trick=identity_trick\n self.clearFixedEffect()\n\n #########################################\n # Properties\n #########################################\n\n @property\n def A(self):\n return self._A\n\n @property\n def B(self):\n return self._B\n\n @property\n def F(self):\n return self._F\n\n @property\n def A_identity(self):\n return self._A_identity\n\n @property\n def REML_term(self):\n return self._REML_term\n\n @property\n def Y(self):\n return self._Y\n\n @property\n def N(self):\n return self._N\n\n @property\n def P(self):\n return self._P\n\n @property\n def n_fixed_effs(self):\n return self._n_fixed_effs\n\n @property\n def n_terms(self):\n return self._n_terms\n\n @property\n def Lr(self):\n return self._Lr\n\n @property\n def Lc(self):\n return self._Lc\n\n @property\n def d(self):\n return self._d\n\n @property\n def D(self):\n return np.reshape(self.d,(self.N,self.P), order='F')\n\n @property\n def LRLdiag(self):\n return self._LRLdiag\n\n @property\n def LCL(self):\n return self._LCL\n\n #########################################\n # Setters\n #########################################\n def use_identity_trick(self,identity_trick=True):\n self.identity_trick=identity_trick\n self.clear_cache('Fstar','Astar','Xstar','Xhat',\n 'Areml','Areml_eigh','Areml_chol','Areml_inv','beta_hat','B_hat',\n 'LRLdiag_Xhat_tens','Areml_grad',\n 'beta_grad','Xstar_beta_grad','Zstar','DLZ')\n\n\n def clearFixedEffect(self):\n \"\"\" erase all fixed effects \"\"\"\n self._A = []\n self._F = []\n self._B = []\n self._A_identity = []\n self._REML_term = []\n self._n_terms = 0\n self._n_fixed_effs = 0\n self._n_fixed_effs_REML = 0\n self.indicator = {'term':np.array([]),\n 'row':np.array([]),\n 'col':np.array([])}\n self.clear_cache('Fstar','Astar','Xstar','Xhat',\n 'Areml','Areml_eigh','Areml_chol','Areml_inv','beta_hat','B_hat',\n 'LRLdiag_Xhat_tens','Areml_grad',\n 'beta_grad','Xstar_beta_grad','Zstar','DLZ')\n\n def addFixedEffect(self,F=None,A=None, REML=True, index=None):\n \"\"\"\n set sample and trait designs\n F: NxK sample design\n A: LxP sample design\n REML: REML for this term?\n index: index of which fixed effect to replace. If None, just append.\n \"\"\"\n if F is None: F = np.ones((self.N,1))\n if A is None:\n A = np.eye(self.P)\n A_identity = True\n elif (A.shape == (self.P,self.P)) & (A==np.eye(self.P)).all():\n A_identity = True\n else:\n A_identity = False\n\n assert F.shape[0]==self.N, \"F dimension mismatch\"\n assert A.shape[1]==self.P, \"A dimension mismatch\"\n if index is None or index==self.n_terms:\n self.F.append(F)\n self.A.append(A)\n self.A_identity.append(A_identity)\n self.REML_term.append(REML)\n # build B matrix and indicator\n self.B.append(np.zeros((F.shape[1],A.shape[0])))\n self._n_terms+=1\n self._update_indicator(F.shape[1],A.shape[0])\n elif index >self.n_terms:\n raise Exception(\"index exceeds max index of terms\")\n else:\n self._n_fixed_effs-=self.F[index].shape[1]*self.A[index].shape[0]\n if self.REML_term[index]:\n self._n_fixed_effs_REML-=self.F[index].shape[1]*self.A[index].shape[0]\n self.F[index] = F\n self.A[index] = A\n self.A_identity[index] = A_identity\n self.REML_term[index]=REML\n self.B[index] = np.zeros((F.shape[1],A.shape[0]))\n self._rebuild_indicator()\n\n self._n_fixed_effs+=F.shape[1]*A.shape[0]\n if REML:\n self._n_fixed_effs_REML+=F.shape[1]*A.shape[0]\n self.clear_cache('Fstar','Astar','Xstar','Xhat',\n 'Areml','Areml_eigh','Areml_chol','Areml_inv','beta_hat','B_hat',\n 'LRLdiag_Xhat_tens','Areml_grad',\n 'beta_grad','Xstar_beta_grad','Zstar','DLZ')\n\n def removeFixedEffect(self, index=None):\n \"\"\"\n set sample and trait designs\n F: NxK sample design\n A: LxP sample design\n REML: REML for this term?\n index: index of which fixed effect to replace. If None, remove last term.\n \"\"\"\n if self._n_terms==0:\n pass\n if index is None or index==(self._n_terms-1):\n\n self._n_terms-=1\n F = self._F.pop() #= self.F[:-1]\n A = self._A.pop() #= self.A[:-1]\n self._A_identity.pop() #= self.A_identity[:-1]\n REML_term = self._REML_term.pop()# = self.REML_term[:-1]\n self._B.pop()# = self.B[:-1]\n self._n_fixed_effs-=F.shape[1]*A.shape[0]\n if REML_term:\n self._n_fixed_effs_REML-=F.shape[1]*A.shape[0]\n\n pass\n elif index >= self.n_terms:\n raise Exception(\"index exceeds max index of terms\")\n else:\n raise NotImplementedError(\"currently only last term can be removed\")\n pass\n self._rebuild_indicator()\n self.clear_cache('Fstar','Astar','Xstar','Xhat',\n 'Areml','Areml_eigh','Areml_chol','Areml_inv','beta_hat','B_hat',\n 'LRLdiag_Xhat_tens','Areml_grad',\n 'beta_grad','Xstar_beta_grad','Zstar','DLZ')\n\n @Y.setter\n def Y(self,value):\n \"\"\" set phenotype \"\"\"\n self._N,self._P = value.shape\n self._Y = value\n self.clear_cache('Ystar1','Ystar','Yhat','LRLdiag_Yhat',\n 'beta_grad','Xstar_beta_grad','Zstar','DLZ')\n\n @Lr.setter\n def Lr(self,value):\n \"\"\" set row rotation \"\"\"\n assert value.shape[0]==self._N, 'dimension mismatch'\n assert value.shape[1]==self._N, 'dimension mismatch'\n self._Lr = value\n self.clear_cache('Fstar','Ystar1','Ystar','Yhat','Xstar','Xhat',\n 'Areml','Areml_eigh','Areml_chol','Areml_inv','beta_hat','B_hat',\n 'LRLdiag_Xhat_tens','LRLdiag_Yhat','Areml_grad',\n 'beta_grad','Xstar_beta_grad',\n 'LRLdiag_Xhat_tens','LRLdiag_Yhat','Areml_grad',\n 'beta_grad','Xstar_beta_grad','Zstar','DLZ')\n\n @Lc.setter\n def Lc(self,value):\n \"\"\" set col rotation \"\"\"\n assert value.shape[0]==self._P, 'Lc dimension mismatch'\n assert value.shape[1]==self._P, 'Lc dimension mismatch'\n self._Lc = value\n self.clear_cache('Astar','Ystar','Yhat','Xstar','Xhat',\n 'Areml','Areml_eigh','Areml_chol','Areml_inv','beta_hat','B_hat',\n 'LRLdiag_Xhat_tens','LRLdiag_Yhat','Areml_grad',\n 'beta_grad','Xstar_beta_grad','Zstar','DLZ')\n\n @d.setter\n def d(self,value):\n \"\"\" set anisotropic scaling \"\"\"\n assert value.shape[0]==self._P*self._N, 'd dimension mismatch'\n self._d = value\n self.clear_cache('Yhat','Xhat','Areml','Areml_eigh','Areml_chol','Areml_inv','beta_hat','B_hat',\n 'LRLdiag_Xhat_tens','LRLdiag_Yhat','Areml_grad',\n 'beta_grad','Xstar_beta_grad','Zstar','DLZ')\n\n @LRLdiag.setter\n def LRLdiag(self,value):\n \"\"\" set anisotropic scaling \"\"\"\n self._LRLdiag = value\n self.clear_cache('LRLdiag_Xhat_tens','LRLdiag_Yhat','Areml_grad',\n 'beta_grad','Xstar_beta_grad')\n\n @LCL.setter\n def LCL(self,value):\n \"\"\" set anisotropic scaling \"\"\"\n self._LCL = value\n self.clear_cache('Areml_grad','beta_grad','Xstar_beta_grad')\n\n #########################################\n # Getters (caching)\n #########################################\n\n @cached\n def Astar(self):\n RV = []\n for term_i in range(self.n_terms):\n RV.append(np.dot(self.A[term_i],self.Lc.T))\n return RV\n\n @cached\n def Fstar(self):\n RV = []\n for term_i in range(self.n_terms):\n RV.append(np.dot(self.Lr,self.F[term_i]))\n return RV\n\n def Ystar1(self):\n return np.dot(self.Lr,self.Y)\n\n @cached\n def Ystar(self):\n return np.dot(self.Ystar1(),self.Lc.T)\n\n @cached\n def Yhat(self):\n return self.D*self.Ystar()\n\n @cached\n def Xstar(self):\n RV = np.zeros((self.N*self.P,self.n_fixed_effs))\n ip = 0\n for i in range(self.n_terms):\n Ki = self.A[i].shape[0]*self.F[i].shape[1]\n RV[:,ip:ip+Ki] = np.kron(self.Astar()[i].T,self.Fstar()[i])\n ip += Ki\n return RV\n\n def var_total(self):\n return (self.Yhat()*self.Ystar()).sum()\n\n\n def var_explained(self):\n XKY = self.compute_XKY(M=self.Yhat())\n beta_hat = self.Areml_solve(XKY)\n return (XKY*beta_hat).sum(), beta_hat\n\n\n @cached\n def Xhat(self):\n RV = self.d[:,np.newaxis]*self.Xstar()\n return RV\n\n @cached\n def Areml(self):\n #A1 = self.XstarT_dot(self.Xhat())\n A2 = self.compute_XKX()\n return A2\n\n @cached\n def Areml_chol(self):\n return LA.cholesky(self.Areml()).T\n\n @cached\n def Areml_REML_chol(self):\n return LA.cholesky(self.Areml()).T\n\n @cached\n def Areml_inv(self):\n return LA.cho_solve((self.Areml_chol(),True),np.eye(self.n_fixed_effs))\n\n #caching bug:\n #@cached\n def beta_hat(self):\n XKY = self.compute_XKY(M=self.Yhat())\n beta_hat = self.Areml_solve(XKY)\n return beta_hat\n\n\n @cached\n def B_hat(self):\n RV = []\n ip = 0\n for term_i in range(self.n_terms):\n RV.append(np.reshape(self.beta_hat()[ip:ip+self.B[term_i].size],self.B[term_i].shape, order='F'))\n ip += self.B[term_i].size\n return RV\n\n @cached\n def LRLdiag_Xhat_tens(self):\n RV = np.reshape(self.Xhat(),(self.N,self.P,self.n_fixed_effs),order='F').copy()\n RV *= self.LRLdiag[:,np.newaxis,np.newaxis]\n return RV\n\n @cached\n def LRLdiag_Yhat(self):\n return self.LRLdiag[:,np.newaxis]*self.Yhat()\n\n @cached\n def Areml_grad(self):\n RV = np.einsum('jpk,lp->jlk',self.LRLdiag_Xhat_tens(),self.LCL)\n RV = RV.reshape((self.N*self.P,self.n_fixed_effs),order='F')\n RV*= self.d[:,np.newaxis]\n RV = -self.XstarT_dot(RV)\n return RV\n\n @cached\n def beta_grad(self):\n RV = np.reshape(np.dot(self.LRLdiag_Yhat(),self.LCL.T),(self.N*self.P),order='F')\n RV *= self.d\n RV = self.XstarT_dot(RV)\n RV += np.dot(self.Areml_grad(),self.beta_hat())\n RV = -np.dot(self.Areml_inv(),RV)\n return RV\n\n @cached\n def Xstar_beta_grad(self):\n RV = np.zeros((self.N,self.P))\n ip = 0\n for term_i in range(self.n_terms):\n _Bgrad = np.reshape(self.beta_grad()[ip:ip+self.B[term_i].size],self.B[term_i].shape, order='F')\n RV+=np.dot(self.Fstar()[term_i],np.dot(_Bgrad,self.Astar()[term_i]))\n ip += self.B[term_i].size\n return RV\n\n\n @cached\n def Zstar(self):\n \"\"\" predict the value of the fixed effect \"\"\"\n RV = self.Ystar().copy()\n for term_i in range(self.n_terms):\n if self.identity_trick and self.A_identity[term_i]:\n RV-=np.dot(self.Fstar()[term_i],self.B_hat()[term_i])\n else:\n RV-=np.dot(self.Fstar()[term_i],np.dot(self.B_hat()[term_i],self.Astar()[term_i]))\n self.clear_cache('DLZ')\n return RV\n\n @cached\n def Areml_eigh(self):\n \"\"\"compute the eigenvalue decomposition of Astar\"\"\"\n s,U = LA.eigh(self.Areml(),lower=True)\n i_pos = (s>1e-10)\n s = s[i_pos]\n U = U[:,i_pos]\n return s,U\n\n @cached\n def DLZ(self):\n return self.Zstar()*np.reshape(self.D,(self.N,self.P), order='F')\n\n ###############################################\n # Other getters with no caching, should not they have caching somehow?\n ###############################################\n\n def Areml_solve(self, b):\n try:\n res = LA.cho_solve((self.Areml_chol(),True),b)\n except LA.LinAlgError:\n\n s,U = self.Areml_eigh()\n res = U.T.dot(b)\n res /= s[:,np.newaxis]\n res = U.dot(res)\n\n return res\n\n\n def compute_XKY(self, M=None):\n if M is None:\n M = self.Yhat()\n assert M.shape==(self.N,self.P)\n XKY = np.zeros((self.n_fixed_effs))\n n_weights = 0\n for term in range(self.n_terms):\n if self.identity_trick and self.A_identity[term]:\n XKY_block = compute_XYA(DY=M, X=self.Fstar()[term], A=None)\n else:\n XKY_block = compute_XYA(DY=M, X=self.Fstar()[term], A=self.Astar()[term])\n XKY[n_weights:n_weights + self.A[term].shape[0] * self.F[term].shape[1]] = XKY_block.ravel(order='F')\n n_weights += self.A[term].shape[0] * self.F[term].shape[1]\n return XKY\n\n def compute_XKX(self):\n #n_weights1 = 0\n #\n #for term1 in xrange(self.n_terms):\n # n_weights1+=self.Astar()[term1].shape[0] * self.Fstar()[term1].shape[1]\n #cov_beta = np.zeros((n_weights1,n_weights1))\n cov_beta = np.zeros((self.n_fixed_effs,self.n_fixed_effs))\n n_weights1 = 0\n for term1 in range(self.n_terms):\n if self.identity_trick and self.A_identity[term1]:\n A_term1 = None\n else:\n A_term1 = self.Astar()[term1]\n n_weights2 = n_weights1\n for term2 in range(term1,self.n_terms):\n if self.identity_trick and self.A_identity[term2]:\n A_term2 = None\n else:\n A_term2 = self.Astar()[term2]\n block = compute_X1KX2(Y=self.Ystar(), D=self.D, X1=self.Fstar()[term1], X2=self.Fstar()[term2], A1=A_term1, A2=A_term2)\n cov_beta[n_weights1:n_weights1 + self.A[term1].shape[0] * self.F[term1].shape[1], n_weights2:n_weights2 + self.A[term2].shape[0] * self.F[term2].shape[1]] = block\n if term1!=term2:\n cov_beta[n_weights2:n_weights2 + self.A[term2].shape[0] * self.F[term2].shape[1], n_weights1:n_weights1 + self.A[term1].shape[0] * self.F[term1].shape[1]] = block.T\n\n n_weights2+=self.A[term2].shape[0] * self.F[term2].shape[1]\n\n n_weights1+=self.A[term1].shape[0] * self.F[term1].shape[1]\n return cov_beta\n\n def predict(self):\n \"\"\" predict the value of the fixed effect \"\"\"\n RV = np.zeros((self.N,self.P))\n for term_i in range(self.n_terms):\n RV+=np.dot(self.Fstar()[term_i],np.dot(self.B()[term_i],self.Astar()[term_i]))\n return RV\n\n def evaluate(self):\n \"\"\" predict the value of \"\"\"\n RV = -self.predict()\n RV += self.Ystar()\n return RV\n\n def getGradient(self,j):\n \"\"\" get rotated gradient for fixed effect i \"\"\"\n i = int(self.indicator['term'][j])\n r = int(self.indicator['row'][j])\n c = int(self.indicator['col'][j])\n rv = -np.kron(self.Fstar()[i][:,[r]],self.Astar()[i][[c],:])\n return rv\n\n def XstarT_dot(self,M):\n \"\"\" get dot product of Xhat and M \"\"\"\n if 0:\n #TODO: implement this properly\n pass\n else:\n RV = np.dot(self.Xstar().T,M)\n return RV\n\n def getResiduals(self):\n \"\"\" regress out fixed effects and results residuals \"\"\"\n X = np.zeros((self.N*self.P,self.n_fixed_effs))\n ip = 0\n for i in range(self.n_terms):\n Ki = self.A[i].shape[0]*self.F[i].shape[1]\n X[:,ip:ip+Ki] = np.kron(self.A[i].T,self.F[i])\n ip += Ki\n y = np.reshape(self.Y,(self.Y.size,1),order='F')\n RV = regressOut(y,X)\n RV = np.reshape(RV,self.Y.shape,order='F')\n return RV\n\n #########################################\n # Params manipulation\n #########################################\n\n def getParams(self):\n \"\"\" get params \"\"\"\n rv = np.array([])\n if self.n_terms>0:\n rv = np.concatenate([np.reshape(self.B[term_i],self.B[term_i].size, order='F') for term_i in range(self.n_terms)])\n return rv\n\n def setParams(self,params):\n \"\"\" set params \"\"\"\n start = 0\n for i in range(self.n_terms):\n n_effects = self.B[i].size\n self.B[i] = np.reshape(params[start:start+n_effects],self.B[i].shape, order='F')\n start += n_effects\n\n #########################################\n # Utility functions\n #########################################\n\n def getDimensions(self):\n \"\"\" get phenotype dimensions \"\"\"\n return self.N,self.P\n\n def _set_toChange(x):\n \"\"\" set variables in list x toChange \"\"\"\n for key in list(x.keys()):\n self.toChange[key] = True\n\n def _update_indicator(self,K,L):\n \"\"\" update the indicator \"\"\"\n _update = {'term': self.n_terms*np.ones((K,L)).T.ravel(),\n 'row': np.kron(np.arange(K)[:,np.newaxis],np.ones((1,L))).T.ravel(),\n 'col': np.kron(np.ones((K,1)),np.arange(L)[np.newaxis,:]).T.ravel()}\n for key in list(_update.keys()):\n self.indicator[key] = np.concatenate([self.indicator[key],_update[key]])\n\n def _rebuild_indicator(self):\n \"\"\" update the indicator \"\"\"\n indicator = {'term':np.array([]),\n 'row':np.array([]),\n 'col':np.array([])}\n\n for term in range(self.n_terms):\n L = self.A[term].shape[0]\n K = self.F[term].shape[1]\n _update = {'term': (term+1)*np.ones((K,L)).T.ravel(),\n 'row': np.kron(np.arange(K)[:,np.newaxis],np.ones((1,L))).T.ravel(),\n 'col': np.kron(np.ones((K,1)),np.arange(L)[np.newaxis,:]).T.ravel()}\n for key in list(_update.keys()):\n indicator[key] = np.concatenate([indicator[key],_update[key]])\n self.indicator = indicator\n",
"import scipy as sp\nfrom limix.core.covar import Cov2KronSumLR\nfrom limix.core.covar import FreeFormCov\nfrom limix.core.gp import GP2KronSumLR\nfrom limix.core.gp import GP\nfrom limix.utils.preprocess import covar_rescale\nimport time\nimport copy\nimport pdb\n\nif __name__=='__main__':\n\n # define row caoriance\n N = 1000\n f = 10\n P = 3\n X = 1.*(sp.rand(N, f)<0.2)\n\n # define col covariances\n Cn = FreeFormCov(P)\n Cn.setRandomParams()\n\n # define fixed effects and pheno\n F = 1.*(sp.rand(N,2)<0.5)\n A = sp.eye(P)\n Y = sp.randn(N, P)\n\n # define gp and optimize\n gp = GP2KronSumLR(Y = Y, F = F, A = A, Cn = Cn, G = X)\n gp.optimize()\n\n",
"import sys\nfrom limix.hcache import cached\nimport scipy as sp\nimport numpy as np\nfrom .covar_base import Covariance\nimport sqexp\n\n\nclass ZKZCov(Covariance):\n \"\"\"\n squared exponential covariance function\n \"\"\"\n def __init__(self, X, Kin, remove_diag=True, interaction_matrix=None, Xstar=None):\n \"\"\"\n X dim x d input matrix\n \"\"\"\n\n super(ZKZCov, self).__init__()\n self.se = sqexp.SQExpCov(X)\n self.X = X\n self.Kin = Kin\n self.rm_diag = remove_diag\n self.interaction_matrix = interaction_matrix\n\n self.Xstar = Xstar\n\n self.penalty_function = None\n\n def get_input_dim(self):\n return self.X.shape[1]\n\n #####################\n # Properties\n #####################\n @property\n def scale(self):\n return self.se.scale\n\n @property\n def length(self):\n return self.se.length\n\n # TODO not true in the general case -> to change\n @property\n def dim(self):\n return self.K().shape[0]\n # return self.se.dim\n\n @property\n def scale_ste(self):\n # if self.getFIinv() is None:\n # R = None\n # else:\n # R = sp.sqrt(self.getFIinv()[0,0])\n # return R\n return self.se.scale_ste\n\n @property\n def length_ste(self):\n # if self.getFIinv() is None:\n # R = None\n # else:\n # R = sp.sqrt(self.getFIinv()[1,1])\n # return R\n return self.se.length_ste\n\n @property\n def X(self):\n return self._X\n\n @property\n def Xstar(self):\n return self._Xstar\n\n #####################\n # Setters\n #####################\n @scale.setter\n def scale(self, value):\n self.se.scale = value\n self.clear_all()\n self._notify()\n\n @length.setter\n def length(self, value):\n self.se.length = value\n self.clear_all()\n self._notify()\n\n # TODO: clear cash, notify etc ?\n @X.setter\n def X(self,value):\n self._X = value\n self.se.X = value\n\n @Xstar.setter\n def Xstar(self,value):\n # two ways of doing prediction:\n # - 1 using the test set as an environment with unknown phenotype\n # - 2 using the test set as an unknown environment and phenotype\n\n # case 1: X star is a list of boolean, whose value is True for the cells to use for validation\n if value is None:\n self._use_to_predict = False\n self._Xstar = None\n return\n else:\n self._use_to_predict = True\n\n if value.dtype == bool:\n assert len(value) == self.X.shape[0], 'boolean Xstar must be of length n_cells'\n assert self.Kin.shape[0] == len(value), 'Kin must contain all the cells, validation set included'\n\n # Case 2: Xstar is a list of positions to use for validation, expression profile X of these positions unknown\n if value.dtype == float:\n self.se.Xstar = value\n\n self._Xstar = value\n\n @Covariance.use_to_predict.setter\n def use_to_predict(self, value):\n if value:\n assert self.Xstar is not None, 'set Xstar!'\n self._use_to_predict = value\n self._notify()\n\n #####################\n # Params handling\n #####################\n def getNumberParams(self):\n return self.se.getNumberParams()\n\n def setParams(self, params):\n self.se.setParams(params)\n self.clear_all()\n\n def getParams(self):\n return self.se.getParams()\n\n def _calcNumberParams(self):\n self.n_params = 2\n\n # TODO decide how to set this. function or parameters of the function ?\n def setPenalty(self, mu, sigma):\n self.penalty_function = np.zeros(2)\n self.penalty_function[0] = mu\n self.penalty_function[1] = sigma\n\n # making initialisation consistent with prior\n self.length = mu\n pass\n\n #####################\n # Activation handling\n #####################\n\n @property\n def act_scale(self):\n return self.se._scale_act\n\n @act_scale.setter\n def act_scale(self, act):\n self.se._scale_act = bool(act)\n self._notify()\n\n @property\n def act_length(self):\n return self.se._length_act\n\n @act_length.setter\n def act_length(self, act):\n self.se._length_act = bool(act)\n self._notify()\n\n #####################\n # Cached\n #####################\n @cached('covar_base')\n def K(self):\n K = self._K()\n\n # if a test set Xstar is given as a boolean, return only the training set * training set covariance\n if self.Xstar is not None and self.Xstar.dtype == bool:\n return K[~self.Xstar, :][:, ~self.Xstar]\n\n return K\n\n # TODO cash ?\n def Kcross(self):\n assert self.Xstar is not None, \"Provide test set\"\n\n # if Xstar is a list of positions (test set does not contribute to environment)\n if self.Xstar.dtype == float:\n Zstar = self.se.Kcross()\n ZT = self.se.K().transpose()\n return Zstar.dot(self.Kin.dot(ZT))\n\n # if Xstar is a list of bool (test set contributes to environment)\n if self.Xstar.dtype == bool:\n # subset the K matrix\n K = self._K()\n return K[self.Xstar, :][:, ~self.Xstar]\n\n @cached('covar_base')\n def K_grad_i(self, i):\n grad_tmp = self.se.K_grad_i(i)\n se_K_tmp = self.se.K()\n if self.rm_diag:\n grad_tmp -= grad_tmp.diagonal() * np.eye(grad_tmp.shape[0])\n se_K_tmp -= se_K_tmp.diagonal() * np.eye(se_K_tmp.shape[0])\n if self.interaction_matrix is not None:\n grad_tmp *= self.interaction_matrix\n se_K_tmp *= self.interaction_matrix\n r = grad_tmp.dot(self.Kin.dot(se_K_tmp.transpose()))\n r += se_K_tmp.dot(self.Kin.dot(grad_tmp.transpose()))\n\n # if a test set Xstar is given as a boolean, return only the training set * training set covariance\n if self.Xstar is not None and self.Xstar.dtype == bool:\n return r[~self.Xstar, :][:, ~self.Xstar]\n return r\n\n @cached('covar_base')\n def _K(self):\n z = self.se.K()\n if self.interaction_matrix is not None:\n z *= self.interaction_matrix\n if self.rm_diag:\n z -= np.eye(z.shape[0]) * z.diagonal()\n tmp = z.dot(self.Kin.dot(z.transpose()))\n return tmp\n\n @cached('covar_base')\n def penalty(self):\n if self.penalty_function is None:\n return 0\n else:\n return (1/(2*self.penalty_function[1]**2.0)) * (self.length - self.penalty_function[0])**2.0\n\n @cached('covar_base')\n def penalty_grad(self, i):\n if self.penalty_function is None:\n return 0\n elif i == 0:\n return 0\n elif i == 1:\n # print 'length zkz: '+str(self.length)\n return 2.0*((1/(2*self.penalty_function[1]**2.0)) * (self.length - self.penalty_function[0])) * self.length\n else:\n raise Exception('Index out of range in penalty gradient')\n\n ####################\n # Interpretable Params\n ####################\n def getInterParams(self):\n return self.se.getInterParams()\n\n # def K_grad_interParam_i(self,i):\n # if i==0:\n # r = sp.exp(-self.E()/(2*self.se.length))\n # else:\n # A = sp.exp(-self.E()/(2*self.se.length))*self.se.E()\n # r = self.se.scale * A / (2*self.se.length**2)\n # return r\n"
] | [
[
"numpy.dot",
"numpy.reshape",
"numpy.arange",
"numpy.eye",
"numpy.kron",
"numpy.ones",
"numpy.concatenate",
"numpy.outer",
"numpy.array",
"numpy.zeros"
],
[
"scipy.eye",
"scipy.randn",
"scipy.rand"
],
[
"numpy.eye",
"numpy.zeros"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
koba35/retinanet | [
"99820cde438a2fc14e38973437766de6fe6a94a3"
] | [
"losses.py"
] | [
"import numpy as np\nimport torch\nimport torch.nn as nn\n\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\n\nclass FocalLoss(nn.Module):\n # def __init__(self):\n\n def forward(self, classifications, regressions, anchors, annotations):\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\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\n for j in range(batch_size):\n\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 if bbox_annotation.shape[0] == 0:\n regression_losses.append(torch.tensor(0).float().cuda())\n classification_losses.append(torch.tensor(0).float().cuda())\n\n continue\n\n classification = torch.clamp(classification, 1e-4, 1.0 - 1e-4)\n\n IoU = calc_iou(anchors[0, :, :], bbox_annotation[:, :4]) # num_anchors x num_annotations\n\n IoU_max, IoU_argmax = torch.max(IoU, dim=1) # num_anchors x 1\n\n # import pdb\n # pdb.set_trace()\n\n # compute the loss for classification\n targets = torch.ones(classification.shape) * -1\n targets = targets.cuda()\n\n targets[torch.lt(IoU_max, 0.4), :] = 0\n\n positive_indices = torch.ge(IoU_max, 0.5)\n\n num_positive_anchors = positive_indices.sum()\n\n assigned_annotations = bbox_annotation[IoU_argmax, :]\n\n targets[positive_indices, :] = 0\n targets[positive_indices, assigned_annotations[positive_indices, 4].long()] = 1\n\n alpha_factor = torch.ones(targets.shape).cuda() * 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 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 * torch.pow(bce, gamma)\n cls_loss = focal_weight * bce\n\n cls_loss = torch.where(torch.ne(targets, -1.0), cls_loss, torch.zeros(cls_loss.shape).cuda())\n\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 positive_indices.sum() > 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 targets = targets / torch.Tensor([[0.1, 0.1, 0.2, 0.2]]).cuda()\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 regression_losses.append(torch.tensor(0).float().cuda())\n\n return torch.stack(classification_losses).mean(dim=0, keepdim=True), torch.stack(regression_losses).mean(dim=0,\n keepdim=True)\n"
] | [
[
"torch.abs",
"torch.ge",
"torch.ones",
"torch.max",
"torch.Tensor",
"torch.zeros",
"torch.eq",
"torch.lt",
"torch.unsqueeze",
"torch.tensor",
"torch.le",
"torch.log",
"torch.stack",
"torch.clamp",
"torch.pow",
"torch.ne"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
googleinterns/protein-embedding-retrieval | [
"388563d3206e1486fe5dbcfd8326be6f1185a00e"
] | [
"contextual_lenses/train_utils.py"
] | [
"\"\"\"Train utils\n\nGeneral tools for instantiating and training models.\n\"\"\"\n\nimport flax\nfrom flax import nn\nfrom flax import optim\nfrom flax.training import checkpoints\nfrom flax.training import common_utils\n\nimport jax\nfrom jax import random\nimport jax.nn\nimport jax.numpy as jnp\nfrom jax.config import config\nconfig.enable_omnistaging()\n\nimport tensorflow as tf\n\nimport numpy as np\n\nimport functools\n\nimport copy\n\nfrom google_research.protein_lm import models\n\n\n# Data batching.\ndef create_data_iterator(df,\n input_col,\n output_col,\n batch_size,\n epochs=1,\n buffer_size=None,\n seed=0,\n drop_remainder=False,\n add_outputs=True,\n as_numpy=True):\n \"\"\"Creates iterator of batches of (inputs) or (inputs, outputs).\"\"\"\n\n if buffer_size is None:\n buffer_size = len(df)\n\n inputs = list(df[input_col].values)\n inputs = tf.data.Dataset.from_tensor_slices(inputs)\n\n outputs = df[output_col].values\n outputs = tf.data.Dataset.from_tensor_slices(outputs)\n\n if add_outputs:\n batches = tf.data.Dataset.zip(\n (inputs, outputs)).shuffle(buffer_size=buffer_size,\n seed=seed,\n reshuffle_each_iteration=True)\n else:\n batches = inputs.shuffle(buffer_size=buffer_size,\n seed=seed,\n reshuffle_each_iteration=True)\n\n batches = batches.repeat(epochs).batch(batch_size=batch_size,\n drop_remainder=drop_remainder)\n\n if as_numpy:\n batches = batches.as_numpy_iterator()\n\n return batches\n\n\ndef path_inclusion_filter_fn(path, param, layer):\n \"\"\"Returns whether or not layer name is contained in path.\"\"\"\n\n return layer in path\n\n\ndef create_optimizer(model, learning_rate, weight_decay, layers=None):\n \"\"\"Instantiates Adam multi-optimizer.\"\"\"\n\n if layers is None:\n assert (\n type(learning_rate) == type(weight_decay) == float\n ), 'Specify float values for moded learning rate and weight decay!'\n optimizer_def = optim.Adam(learning_rate=learning_rate,\n weight_decay=weight_decay)\n optimizer = optimizer_def.create(model)\n\n else:\n assert (\n len(learning_rate) == len(weight_decay) == len(layers)\n ), 'Number of specified learning rates, weight decays, and layers must be equal!'\n optimizers = []\n for lr, wd, layer in zip(learning_rate, weight_decay, layers):\n if lr > 0:\n opt = optim.Adam(learning_rate=lr, weight_decay=wd)\n filter_fn = functools.partial(path_inclusion_filter_fn,\n layer=layer)\n traversal = optim.ModelParamTraversal(filter_fn)\n traversal_opt = (traversal, opt)\n optimizers.append(traversal_opt)\n optimizer_def = optim.MultiOptimizer(*optimizers)\n optimizer = optimizer_def.create(model)\n\n return optimizer\n\n\[email protected](jax.jit, static_argnums=(3, 4))\ndef train_step(optimizer, X, Y, loss_fn, loss_fn_kwargs):\n \"\"\"Trains model (optimizer.target) using specified loss function.\"\"\"\n def compute_loss_fn(model, X, Y, loss_fn, loss_fn_kwargs):\n Y_hat = model(X)\n loss = loss_fn(Y, Y_hat, **loss_fn_kwargs)\n return loss\n\n grad_fn = jax.value_and_grad(compute_loss_fn)\n _, grad = grad_fn(optimizer.target, X, Y, loss_fn, loss_fn_kwargs)\n optimizer = optimizer.apply_gradient(grad)\n\n return optimizer\n\n\ndef get_p_train_step():\n \"\"\"Wraps train_step with jax.pmap.\"\"\"\n\n p_train_step = jax.pmap(train_step,\n axis_name='batch',\n static_broadcasted_argnums=(3, 4))\n\n return p_train_step\n\n\ndef train(model,\n train_data,\n loss_fn,\n loss_fn_kwargs,\n learning_rate=1e-4,\n weight_decay=0.1,\n layers=None,\n restore_dir=None,\n save_dir=None,\n use_pmap=False):\n \"\"\"Instantiates optimizer, applies train_step/p_train_step over training data.\"\"\"\n\n optimizer = create_optimizer(model,\n learning_rate=learning_rate,\n weight_decay=weight_decay,\n layers=layers)\n\n if restore_dir is not None:\n optimizer = checkpoints.restore_checkpoint(ckpt_dir=restore_dir,\n target=optimizer)\n\n if use_pmap:\n p_train_step = get_p_train_step()\n optimizer = optimizer.replicate()\n\n for batch in iter(train_data):\n X, Y = batch\n X, Y = common_utils.shard(X), common_utils.shard(Y)\n optimizer = p_train_step(optimizer, X, Y, loss_fn, loss_fn_kwargs)\n\n optimizer = optimizer.unreplicate()\n\n else:\n for batch in iter(train_data):\n X, Y = batch\n optimizer = train_step(optimizer, X, Y, loss_fn, loss_fn_kwargs)\n\n if save_dir is not None:\n state = optimizer.state\n if type(state) == list:\n step = [sub_state.step for sub_state in state]\n else:\n step = state.step\n checkpoints.save_checkpoint(ckpt_dir=save_dir,\n target=optimizer,\n step=step)\n\n return optimizer\n\n\ndef load_params(params,\n encoder_fn_params=None,\n reduce_fn_params=None,\n predict_fn_params=None):\n \"\"\"Updates randomly initialized parameters using loaded parameters.\"\"\"\n\n loaded_params = copy.deepcopy(params)\n fn_names = list(loaded_params.keys())\n\n num_learnable_layers = len([\n params_dict for params_dict in\n [encoder_fn_params, reduce_fn_params, predict_fn_params]\n if params_dict is not None\n ])\n if encoder_fn_params is not None:\n encoder_fn_ind = '_0'\n if reduce_fn_params is not None:\n reduce_fn_ind = '_1'\n predict_fn_ind = '_2'\n else:\n predict_fn_ind = '_1'\n else:\n if reduce_fn_params is not None:\n reduce_fn_ind = '_0'\n predict_fn_ind = '_1'\n else:\n predict_fn_ind = '_0'\n\n assert (len(loaded_params.keys()) >= num_learnable_layers\n ), 'Model encoder and lens architecture incorrectly specified!'\n\n encoder_fn_name = None\n if encoder_fn_params is not None:\n for fn_name in fn_names:\n if encoder_fn_ind in fn_name:\n if encoder_fn_name is not None:\n raise ValueError(\n 'Multiple instances of encoder_fn detected. %s' %\n fn_name)\n encoder_fn_name = fn_name\n loaded_params[encoder_fn_name] = encoder_fn_params\n\n reduce_fn_name = None\n if reduce_fn_params is not None:\n for fn_name in fn_names:\n if reduce_fn_ind in fn_name:\n if reduce_fn_name is not None:\n raise ValueError(\n 'Multiple instances of reduce_fn detected. %s' %\n fn_name)\n reduce_fn_name = fn_name\n loaded_params[reduce_fn_name] = reduce_fn_params\n\n predict_fn_name = None\n if predict_fn_params is not None:\n for fn_name in fn_names:\n if predict_fn_ind in fn_name:\n if predict_fn_name is not None:\n raise ValueError(\n 'Multiple instances of predict_fn detected. %s' %\n fn_name)\n predict_fn_name = fn_name\n loaded_params[predict_fn_name] = predict_fn_params\n\n return loaded_params\n\n\nclass RepresentationModel(nn.Module):\n def apply(self,\n x,\n encoder_fn,\n encoder_fn_kwargs,\n reduce_fn,\n reduce_fn_kwargs,\n num_categories,\n output_features,\n output='prediction',\n use_transformer=False,\n padding_mask=None):\n \"\"\"Computes padding mask, encodes indices using embeddings, \n applies lensing operation, predicts scalar value.\n \"\"\"\n\n outputs = dict()\n\n if padding_mask is None:\n padding_mask = jnp.expand_dims(jnp.where(x < num_categories - 1, 1,\n 0),\n axis=2)\n\n if not use_transformer:\n x = encoder_fn(x,\n num_categories=num_categories,\n **encoder_fn_kwargs)\n else:\n x = encoder_fn(x)\n\n rep = reduce_fn(x, padding_mask=padding_mask, **reduce_fn_kwargs)\n\n outputs['embedding'] = rep\n\n out = nn.Dense(rep,\n output_features,\n kernel_init=nn.initializers.xavier_uniform(),\n bias_init=nn.initializers.normal(stddev=1e-6))\n\n outputs['prediction'] = out\n\n return outputs[output]\n\n\ndef create_representation_model(encoder_fn,\n encoder_fn_kwargs,\n reduce_fn,\n reduce_fn_kwargs,\n num_categories,\n output_features,\n output='prediction',\n key=random.PRNGKey(0),\n encoder_fn_params=None,\n reduce_fn_params=None,\n predict_fn_params=None):\n \"\"\"Instantiates a RepresentationModel object.\"\"\"\n\n module = RepresentationModel.partial(encoder_fn=encoder_fn,\n encoder_fn_kwargs=encoder_fn_kwargs,\n reduce_fn=reduce_fn,\n reduce_fn_kwargs=reduce_fn_kwargs,\n num_categories=num_categories,\n output_features=output_features,\n output=output,\n use_transformer=False)\n\n _, initial_params = RepresentationModel.init_by_shape(\n key,\n input_specs=[((1, 1), jnp.float32)],\n encoder_fn=encoder_fn,\n encoder_fn_kwargs=encoder_fn_kwargs,\n reduce_fn=reduce_fn,\n reduce_fn_kwargs=reduce_fn_kwargs,\n num_categories=num_categories,\n output_features=output_features,\n output=output,\n use_transformer=False)\n\n loaded_params = load_params(initial_params, encoder_fn_params,\n reduce_fn_params, predict_fn_params)\n\n model = nn.Model(module, loaded_params)\n\n return model\n\n\ndef create_transformer_representation_model(transformer_kwargs,\n reduce_fn,\n reduce_fn_kwargs,\n num_categories,\n output_features,\n bidirectional=False,\n output='prediction',\n key=random.PRNGKey(0),\n encoder_fn_params=None,\n reduce_fn_params=None,\n predict_fn_params=None):\n \"\"\"Instantiates a RepresentationModel object with Transformer encoder.\"\"\"\n\n if not bidirectional:\n transformer = models.FlaxLM(**transformer_kwargs)\n else:\n transformer = models.FlaxBERT(**transformer_kwargs)\n transformer_optimizer = transformer._optimizer\n transformer_model = models.jax_utils.unreplicate(\n transformer_optimizer.target)\n transformer_encoder = transformer_model.module.partial(\n output_head='output_emb')\n\n module = RepresentationModel.partial(encoder_fn=transformer_encoder,\n encoder_fn_kwargs={},\n reduce_fn=reduce_fn,\n reduce_fn_kwargs=reduce_fn_kwargs,\n num_categories=num_categories,\n output_features=output_features,\n output=output,\n use_transformer=True)\n\n _, initial_params = RepresentationModel.init_by_shape(\n key,\n input_specs=[((1, 1), jnp.float32)],\n encoder_fn=transformer_encoder,\n encoder_fn_kwargs={},\n reduce_fn=reduce_fn,\n reduce_fn_kwargs=reduce_fn_kwargs,\n num_categories=num_categories,\n output_features=output_features,\n output=output,\n use_transformer=True)\n\n loaded_params = load_params(initial_params, encoder_fn_params,\n reduce_fn_params, predict_fn_params)\n\n model = nn.Model(module, loaded_params)\n\n return model\n\n\ndef architecture_to_layers(encoder_fn_name, reduce_fn_name):\n\n layers = []\n\n no_trainable_encoder = False\n if encoder_fn_name is None or encoder_fn_name == 'transformer':\n layers.append('Transformer_0')\n elif encoder_fn_name == 'one_hot':\n no_trainable_encoder = True\n elif encoder_fn_name == 'cnn_one_hot':\n layers.append('CNN_0')\n else:\n raise ValueError('Incorrect encoder name specified.')\n\n no_trainable_lens = False\n if reduce_fn_name == 'mean_pool' or reduce_fn_name == 'max_pool':\n no_trainable_lens = True\n elif reduce_fn_name == 'linear_mean_pool' or reduce_fn_name == 'linear_max_pool':\n if no_trainable_encoder:\n layers.append('Dense_0')\n else:\n layers.append('Dense_1')\n elif reduce_fn_name == 'gated_conv':\n if no_trainable_encoder:\n layers.append('GatedConv_0')\n else:\n layers.append('GatedConv_1')\n else:\n raise ValueError('Incorrect lens name specified.')\n\n if no_trainable_encoder:\n if no_trainable_lens:\n layers.append('Dense_0')\n else:\n layers.append('Dense_1')\n else:\n if no_trainable_lens:\n layers.append('Dense_1')\n else:\n layers.append('Dense_2')\n\n trainable_encoder = not no_trainable_encoder\n\n return layers, trainable_encoder\n"
] | [
[
"tensorflow.data.Dataset.zip",
"tensorflow.data.Dataset.from_tensor_slices"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"1.10"
]
}
] |
sethmnielsen/mavsim_template_files | [
"453ec4f7d38fc2d1162198b554834b5bdb7de96f",
"453ec4f7d38fc2d1162198b554834b5bdb7de96f"
] | [
"mavsim_python/chap3/mav_dynamics.py",
"mavsim_python/tools/rotations.py"
] | [
"\"\"\"\nmav_dynamics\n - this file implements the dynamic equations of motion for MAV\n - use unit quaternion for the attitude state\n\npart of mavsimPy\n - Beard & McLain, PUP, 2012\n - Update history:\n 12/17/2018 - RWB\n 1/14/2019 - RWB\n\"\"\"\nimport sys\nsys.path.append('..')\nimport numpy as np\n\n# load message types\nfrom message_types.msg_state import msg_state\n\nimport parameters.aerosonde_parameters as MAV\nfrom tools.rotations import Quaternion2Euler\n\nfrom IPython.core.debugger import Pdb\n\nclass mav_dynamics:\n def __init__(self, Ts):\n self.ts_simulation = Ts\n # set initial states based on parameter file\n self.reset_state()\n self.msg_true_state = msg_state()\n\n ###################################\n # public functions\n\n def reset_state(self):\n # _state is the 13x1 internal state of the aircraft that is being propagated:\n # _state = [pn, pe, pd, u, v, w, e0, e1, e2, e3, p, q, r]\n self._state = np.array([[MAV.pn0], # (0)\n [MAV.pe0], # (1)\n [MAV.pd0], # (2)\n [MAV.u0], # (3)\n [MAV.v0], # (4)\n [MAV.w0], # (5)\n [MAV.e0], # (6)\n [MAV.e1], # (7)\n [MAV.e2], # (8)\n [MAV.e3], # (9)\n [MAV.p0], # (10)\n [MAV.q0], # (11)\n [MAV.r0]]) # (12)\n\n\n def update_state(self, forces_moments):\n '''\n\n Integrate the differential equations defining dynamics.\n Inputs are the forces and moments on the aircraft.\n Ts is the time step between function calls.\n '''\n\n # Integrate ODE using Runge-Kutta RK4 algorithm\n time_step = self.ts_simulation\n k1 = self._derivatives(self._state, forces_moments)\n k2 = self._derivatives(self._state + time_step/2.*k1, forces_moments)\n k3 = self._derivatives(self._state + time_step/2.*k2, forces_moments)\n k4 = self._derivatives(self._state + time_step*k3, forces_moments)\n self._state += time_step/6 * (k1 + 2*k2 + 2*k3 + k4)\n\n # normalize the quaternion\n e0 = self._state.item(6)\n e1 = self._state.item(7)\n e2 = self._state.item(8)\n e3 = self._state.item(9)\n normE = np.sqrt(e0**2+e1**2+e2**2+e3**2)\n self._state[6][0] = self._state.item(6)/normE\n self._state[7][0] = self._state.item(7)/normE\n self._state[8][0] = self._state.item(8)/normE\n self._state[9][0] = self._state.item(9)/normE\n\n # update the message class for the true state\n self._update_msg_true_state()\n\n ###################################\n # private functions\n def _derivatives(self, state, forces_moments):\n \"\"\"\n for the dynamics xdot = f(x, u), returns f(x, u)\n \"\"\"\n # extract the states\n pn = state.item(0)\n pe = state.item(1)\n pd = state.item(2)\n u = state.item(3)\n v = state.item(4)\n w = state.item(5)\n e0 = state.item(6)\n e1 = state.item(7)\n e2 = state.item(8)\n e3 = state.item(9)\n p = state.item(10)\n q = state.item(11)\n r = state.item(12)\n # extract forces/moments\n fx = forces_moments.item(0)\n fy = forces_moments.item(1)\n fz = forces_moments.item(2)\n l = forces_moments.item(3)\n m = forces_moments.item(4)\n n = forces_moments.item(5)\n\n # position kinematics\n R_vb = np.array([[e1**2+e0**2-e2**2-e3**2, 2*(e1*e2-e3*e0), 2*(e1*e3+e2*e0)],\n [2*(e1*e2+e3*e0), e2**2+e0**2-e1**2-e3**2, 2*(e2*e3-e1*e0)],\n [2*(e1*e3-e2*e0), 2*(e2*e3+e1*e0), e3**2+e0**2-e1**2-e2**2]])\n pn_dot, pe_dot, pd_dot = R_vb @ np.array([u, v, w])\n\n # position dynamics\n vec_pos = np.array([r*v - q*w, p*w - r*u, q*u - p*v])\n u_dot, v_dot, w_dot = vec_pos + 1/MAV.mass * np.array([fx, fy, fz])\n\n # rotational kinematics\n mat_rot = np.array([[0, -p, -q, -r],\n [p, 0, r, -q],\n [q, -r, 0, p],\n [r, q, -p, 0]])\n e0_dot, e1_dot, e2_dot, e3_dot = 0.5*mat_rot @ np.array([e0,e1,e2,e3])\n\n # rotatonal dynamics\n G = MAV.gamma\n G1 = MAV.gamma1\n G2 = MAV.gamma2\n G3 = MAV.gamma3\n G4 = MAV.gamma4\n G5 = MAV.gamma5\n G6 = MAV.gamma6\n G7 = MAV.gamma7\n G8 = MAV.gamma8\n\n vec_rot = np.array([G1*p*q - G2*q*r, G5*p*r - G6*(p**2-r**2), G7*p*q - G1*q*r])\n vec_rot2 = np.array([G3*l + G4*n, m/MAV.Jy, G4*l + G8*n])\n\n p_dot, q_dot, r_dot = vec_rot + vec_rot2\n\n # collect the derivative of the states\n x_dot = np.array([[pn_dot, pe_dot, pd_dot, u_dot, v_dot, w_dot,\n e0_dot, e1_dot, e2_dot, e3_dot, p_dot, q_dot, r_dot]]).T\n return x_dot\n\n def _update_msg_true_state(self):\n # update the true state message:\n phi, theta, psi = Quaternion2Euler(self._state[6:10])\n self.msg_true_state.pn = self._state.item(0)\n self.msg_true_state.pe = self._state.item(1)\n self.msg_true_state.h = -self._state.item(2)\n self.msg_true_state.phi = phi\n self.msg_true_state.theta = theta\n self.msg_true_state.psi = psi\n self.msg_true_state.p = self._state.item(10)\n self.msg_true_state.q = self._state.item(11)\n self.msg_true_state.r = self._state.item(12)\n",
"import numpy as np\nfrom math import cos, sin\n\nnp.set_printoptions(suppress=True, precision=6)\n\ndef Quaternion2Euler(quat):\n e0 = quat[0]\n e1 = quat[1]\n e2 = quat[2]\n e3 = quat[3]\n\n phi = np.arctan2(2*(e0*e1 + e2*e3), (e0**2 + e3**2 - e1**2 - e2**2))\n theta = np.arcsin(2*(e0*e2 - e1*e3))\n psi = np.arctan2(2*(e0*e3 + e1*e2), (e0**2 + e1**2 - e2**2 - e3**2))\n\n return phi, theta, psi\n\n\ndef Euler2Quaternion(eul):\n phi2 = eul[0]/2\n tha2 = eul[1]/2\n psi2 = eul[2]/2\n\n e0 = cos(psi2)*cos(tha2)*cos(phi2) + sin(psi2)*sin(tha2)*sin(phi2)\n e1 = cos(psi2)*cos(tha2)*sin(phi2) - sin(psi2)*sin(tha2)*cos(phi2)\n e2 = cos(psi2)*sin(tha2)*cos(phi2) + sin(psi2)*cos(tha2)*sin(phi2)\n e3 = sin(psi2)*cos(tha2)*cos(phi2) - cos(psi2)*sin(tha2)*sin(phi2)\n\n return np.array([e0, e1, e2, e3])\n\ndef Quaternion2Rotation(quat):\n e0 = quat[0]\n e1 = quat[1]\n e2 = quat[2]\n e3 = quat[3]\n\n R = np.array([[e1**2 + e0**2 - e2**2 -e3**2, 2*(e1*e2 - e3*e0), 2*(e1*e3 + e2*e0)],\n [2*(e1*e2 + e3*e0), e2**2 + e0**2 - e1**2 - e3**2, 2*(e2*e3 - e1*e0)],\n [2*(e1*e3 - e2*e0), 2*(e2*e3 + e1*e0), e3**2 + e0**2 - e1**2 - e2**2]])\n\n return R\n\ndef Euler2Rotation(phi, theta, psi):\n \"\"\"\n Converts euler angles to rotation matrix (R_b^i, i.e., body to inertial)\n \"\"\"\n # only call sin and cos once for each angle to speed up rendering\n c_phi = np.cos(phi)\n s_phi = np.sin(phi)\n c_theta = np.cos(theta)\n s_theta = np.sin(theta)\n c_psi = np.cos(psi)\n s_psi = np.sin(psi)\n\n R_roll = np.array([[1, 0, 0],\n [0, c_phi, s_phi],\n [0, -s_phi, c_phi]])\n R_pitch = np.array([[c_theta, 0, -s_theta],\n [0, 1, 0],\n [s_theta, 0, c_theta]])\n R_yaw = np.array([[c_psi, s_psi, 0],\n [-s_psi, c_psi, 0],\n [0, 0, 1]])\n\n R = R_roll @ R_pitch @ R_yaw # inertial to body (Equation 2.4 in book)\n return R.T # transpose to return body to inertial\n\ndef jacobian(fun, x, state):\n # compute jacobian of fun with respect to x\n f = fun(x, state)\n m = f.shape[0]\n n = x.shape[0]\n eps = 0.01 # deviation\n J = np.zeros((m, n))\n for i in range(0, n):\n x_eps = np.copy(x)\n x_eps[i] += eps\n f_eps = fun(x_eps, state)\n df = (f_eps - f) / eps\n J[:, i] = df\n return J\n"
] | [
[
"numpy.array",
"numpy.sqrt"
],
[
"numpy.arcsin",
"numpy.set_printoptions",
"numpy.cos",
"numpy.sin",
"numpy.arctan2",
"numpy.copy",
"numpy.array",
"numpy.zeros"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
EEmGuzman/orphics | [
"f8f25f9db7c9104dba5cbeaac0b4924bf4f6920e",
"f8f25f9db7c9104dba5cbeaac0b4924bf4f6920e"
] | [
"tests/legacy/test_cross_cov.py",
"orphics/unmerged/theory/cosmology.py"
] | [
"from __future__ import print_function\nfrom orphics import maps,io,cosmology,symcoupling as sc,stats,lensing\nfrom enlib import enmap,bench\nimport numpy as np\nimport os,sys\n\n\n\ncache = True\nhdv = False\ndeg = 5\npx = 1.5\nshape,wcs = maps.rect_geometry(width_deg = deg,px_res_arcmin=px)\nmc = sc.LensingModeCoupling(shape,wcs)\npols = ['TT',\"TE\",'EE','EB','TB']\n\n\ntheory = cosmology.default_theory(lpad=20000)\nnoise_t = 10.0\nnoise_p = 10.0*np.sqrt(2.)\nfwhm = 1.5\nkbeam = maps.gauss_beam(fwhm,mc.modlmap)\nells = np.arange(0,3000,1)\nlbeam = maps.gauss_beam(fwhm,ells)\nntt = np.nan_to_num((noise_t*np.pi/180./60.)**2./kbeam**2.)\nnee = np.nan_to_num((noise_p*np.pi/180./60.)**2./kbeam**2.)\nnbb = np.nan_to_num((noise_p*np.pi/180./60.)**2./kbeam**2.)\nlntt = np.nan_to_num((noise_t*np.pi/180./60.)**2./lbeam**2.)\nlnee = np.nan_to_num((noise_p*np.pi/180./60.)**2./lbeam**2.)\nlnbb = np.nan_to_num((noise_p*np.pi/180./60.)**2./lbeam**2.)\n\n\nellmin = 20\nellmax = 3000\nxmask = maps.mask_kspace(shape,wcs,lmin=ellmin,lmax=ellmax)\nymask = xmask\n\nAls = {}\nfor pol in pols:\n with bench.show(\"ALcalc\"):\n AL = mc.AL(pol,xmask,ymask,ntt,nee,nbb,theory=theory,hdv=hdv,cache=cache)\n Als[pol] = AL.copy()\nbin_edges = np.arange(10,2000,40)\n\npl = io.Plotter(yscale='log')\npl.add(ells,theory.gCl('kk',ells),lw=3,color='k')\n\ncrosses = [('TT','EE'),('TT','TE'),('EE','TE'),('EB','TB')]\n\nfor pol1,pol2 in crosses:\n print(pol1,pol2)\n with bench.show(\"ALcalc\"):\n cross = mc.cross(pol1,pol2,theory,xmask,ymask,noise_t=ntt,noise_e=nee,noise_b=nbb,\n ynoise_t=None,ynoise_e=None,ynoise_b=None,\n cross_xnoise_t=None,cross_ynoise_t=None,\n cross_xnoise_e=None,cross_ynoise_e=None,\n cross_xnoise_b=None,cross_ynoise_b=None,\n theory_norm=None,hdv=hdv,save_expression=\"current\",validate=True,cache=True)\n\n Nlalt = np.abs(mc.NL(Als[pol1],Als[pol2],cross))\n cents,nkkalt = stats.bin_in_annuli(Nlalt,mc.modlmap,bin_edges)\n pl.add(cents,nkkalt,marker=\"o\",alpha=0.2,label=pol1 + \"x\" + pol2)\npl.legend()\npl.done()\n\nzcrosses = [('TT','TB'),('TT','EB'),('EE','EB'),('EE','TB')]\n\npl = io.Plotter()\n\nfor pol1,pol2 in zcrosses:\n print(pol1,pol2)\n with bench.show(\"ALcalc\"):\n cross = mc.cross(pol1,pol2,theory,xmask,ymask,noise_t=ntt,noise_e=nee,noise_b=nbb,\n ynoise_t=None,ynoise_e=None,ynoise_b=None,\n cross_xnoise_t=None,cross_ynoise_t=None,\n cross_xnoise_e=None,cross_ynoise_e=None,\n cross_xnoise_b=None,cross_ynoise_b=None,\n theory_norm=None,hdv=hdv,save_expression=\"current\",validate=True,cache=True)\n\n Nlalt = mc.NL(Als[pol1],Als[pol2],cross)\n cents,nkkalt = stats.bin_in_annuli(Nlalt,mc.modlmap,bin_edges)\n pl.add(cents,nkkalt,marker=\"o\",alpha=0.2,label=pol1 + \"x\" + pol2)\n\npl.legend()\npl.done()\n\nprint(\"nffts : \",mc.nfft,mc.nifft)\n",
"from __future__ import print_function\nimport warnings\nwarnings.warn(\"WARNING: This module is deprecated. Most of its contents have moved to orphics.cosmology. If you do not find the function you require there, please raise an issue.\")\nimport camb\nfrom math import pi\nfrom orphics.tools.cmb import loadTheorySpectraFromPycambResults\nfrom camb import model, initialpower\nimport numpy as np\n\nfrom scipy.interpolate import interp1d\nfrom scipy.integrate import quad\nimport itertools\n\ndefaultConstants = {}\ndefaultConstants['TCMB'] = 2.7255\ndefaultConstants['G_CGS'] = 6.67259e-08\ndefaultConstants['MSUN_CGS'] = 1.98900e+33\ndefaultConstants['MPC2CM'] = 3.085678e+24\ndefaultConstants['ERRTOL'] = 1e-12\n\n\ndefaultCosmology = {}\ndefaultCosmology['omch2'] = 0.12470\ndefaultCosmology['ombh2'] = 0.02230\ndefaultCosmology['H0'] = 67.0\ndefaultCosmology['ns'] = 0.96\ndefaultCosmology['As'] = 2.2e-9\ndefaultCosmology['mnu'] = 0.0\ndefaultCosmology['w0'] = -1.0\n\n\n\nclass Cosmology(object):\n '''\n A wrapper around CAMB that tries to pre-calculate as much as possible\n Intended to be inherited by other classes like LimberCosmology and \n ClusterCosmology\n '''\n def __init__(self,paramDict=defaultCosmology,constDict=defaultConstants,lmax=2000,clTTFixFile=None,skipCls=False,pickling=False,fill_zero=True,dimensionless=True):\n\n cosmo = paramDict\n self.paramDict = paramDict\n c = constDict\n self.c = c\n self.cosmo = paramDict\n\n\n self.c['TCMBmuK'] = self.c['TCMB'] * 1.0e6\n \n self.H0 = cosmo['H0']\n self.h = self.H0/100.\n try:\n self.omch2 = cosmo['omch2']\n self.om = (cosmo['omch2']+cosmo['ombh2'])/self.h**2.\n except:\n self.omch2 = (cosmo['om']-cosmo['ob'])*self.H0*self.H0/100./100.\n self.om = cosmo['om']\n \n try:\n self.ombh2 = cosmo['ombh2']\n self.ob = cosmo['ombh2']/self.h**2.\n except:\n self.ombh2 = cosmo['ob']*self.H0*self.H0/100./100.\n self.ob = cosmo['ob']\n\n try:\n self.tau = cosmo['tau']\n except:\n self.tau = defaultCosmology['tau']\n warnings.warn(\"No tau specified; assuming default of \"+str(self.tau))\n \n \n self.mnu = cosmo['mnu']\n self.w0 = cosmo['w0']\n self.pars = camb.CAMBparams()\n self.pars.set_cosmology(H0=self.H0, ombh2=self.ombh2, omch2=self.omch2, mnu=self.mnu, tau=self.tau) # add tau\n self.pars.set_dark_energy(w=self.w0)\n self.pars.InitPower.set_params(ns=cosmo['ns'],As=cosmo['As'])\n\n self.results= camb.get_background(self.pars)\n self.omnuh2 = self.pars.omegan * ((self.H0 / 100.0) ** 2.)\n \n\n # self.rho_crit0 = 3. / (8. * pi) * (self.h*100 * 1.e5)**2. / c['G_CGS'] * c['MPC2CM'] / c['MSUN_CGS']\n self.rho_crit0H100 = 3. / (8. * pi) * (100 * 1.e5)**2. / c['G_CGS'] * c['MPC2CM'] / c['MSUN_CGS']\n self.cmbZ = 1100.\n self.lmax = lmax\n\n if (clTTFixFile is not None) and not(skipCls):\n import numpy as np\n ells,cltts = np.loadtxt(clTTFixFile,unpack=True)\n from scipy.interpolate import interp1d\n self.clttfunc = interp1d(ells,cltts,bounds_error=False,fill_value=0.)\n\n elif not(skipCls):\n print(\"Generating theory Cls...\")\n self.pars.set_accuracy(AccuracyBoost=2.0, lSampleBoost=4.0, lAccuracyBoost=4.0)\n self.pars.set_for_lmax(lmax=(lmax+500), lens_potential_accuracy=3, max_eta_k=2*(lmax+500))\n theory = loadTheorySpectraFromPycambResults(self.results,self.pars,lmax,unlensedEqualsLensed=False,useTotal=False,TCMB = 2.7255e6,lpad=lmax,pickling=pickling,fill_zero=fill_zero,get_dimensionless=dimensionless)\n self.clttfunc = lambda ell: theory.lCl('TT',ell)\n self.theory = theory\n\n # import numpy as np\n # ells = np.arange(2,lmax,1)\n # cltts = self.clttfunc(ells)\n # np.savetxt(\"data/cltt_lensed_Feb18.txt\",np.vstack((ells,cltts)).transpose())\n\n \n\n\nclass LimberCosmology(Cosmology):\n '''Partially based on Anthony Lewis' CAMB Python Notebook\n To do:\n - Add support for curvature\n - Test magnification bias for counts\n - Test that delta function and step function dndz(z)s are equivalent as step function width -> 0\n\n How To Use:\n 1. Initialize with cosmology, constants, lmax, kmax, number of z points\n 2. Add a delta function, step-function or generic dndz with addDeltaNz, addStepNz or addNz. A delta function window tagged \"cmb\" is automatically generated on initialization.\n 3. If you want, access the following objects (tag is the name of the window you specified in step 2):\n a) LimberCosmologyObject.zs (the zrange on which the following things are evaluated)\n b) LimberCosmologyObject.kernels[tag]['W'] (the lensing window function)\n c) LimberCosmologyObject.kernels[tag]['window_z'] (only the (chi-chi)/chi part -- or equivalent integral for non-delta-function windows -- of the lensing windo returned as a callable function win(z))\n d) LimberCosmologyObject.kernels[tag]['dndz'] (a callable function of z that gives the normalized redshift distribution of the sources)\n\n\n pkgrid_override can be a RectBivariateSpline object such that camb.PK.P(z,k,grid=True) returns the same as pkgrid_override(k,z)\n '''\n def __init__(self,paramDict=defaultCosmology,constDict=defaultConstants,lmax=2000,clTTFixFile=None,skipCls=False,pickling=False,numz=100,kmax=42.47,nonlinear=True,skipPower=False,fill_zero=True,pkgrid_override=None):\n Cosmology.__init__(self,paramDict,constDict,lmax,clTTFixFile,skipCls,pickling,fill_zero)\n\n \n self.chistar = self.results.conformal_time(0)- model.tau_maxvis.value\n self.zstar = self.results.redshift_at_comoving_radial_distance(self.chistar)\n\n self.kmax = kmax\n if nonlinear:\n self.pars.NonLinear = model.NonLinear_both\n else:\n self.pars.NonLinear = model.NonLinear_none\n self.chis = np.linspace(0,self.chistar,numz)\n self.zs=self.results.redshift_at_comoving_radial_distance(self.chis)\n self.dchis = (self.chis[2:]-self.chis[:-2])/2\n self.chis = self.chis[1:-1]\n self.zs = self.zs[1:-1]\n self.Hzs = np.array([self.results.hubble_parameter(z) for z in self.zs])\n self._cSpeedKmPerSec = 299792.458\n self.kernels = {}\n self._initWkappaCMB()\n\n self.nonlinear = nonlinear\n self.skipPower = skipPower\n\n if not(skipPower): self._initPower(pkgrid_override)\n\n\n def _initPower(self,pkgrid_override=None):\n print(\"initializing power...\")\n if pkgrid_override is None:\n self.PK = camb.get_matter_power_interpolator(self.pars, nonlinear=self.nonlinear,hubble_units=False, k_hunit=False, kmax=self.kmax, zmax=self.zs[-1])\n else:\n class Ptemp:\n def __init__(self,pkgrid):\n self.pk = pkgrid\n def P(self,zs,ks,grid=True):\n ks = np.asarray(ks)\n zs = np.asarray(zs) \n return self.pk(ks,zs,grid=grid).T\n self.PK = Ptemp(pkgrid_override)\n \n self.precalcFactor = self.Hzs**2. /self.chis/self.chis/self._cSpeedKmPerSec**2.\n\n\n \n\n\n def generateCls(self,ellrange,autoOnly=False,zmin=0.):\n\n if self.skipPower: self._initPower()\n\n\n w = np.ones(self.chis.shape)\n\n retList = {}\n if autoOnly:\n listKeys = list(zip(list(self.kernels.keys()),list(self.kernels.keys())))\n else:\n listKeys = list(itertools.combinations_with_replacement(list(self.kernels.keys()),2))\n \n for key1,key2 in listKeys:\n retList[key1+\",\"+key2] = []\n for ell in ellrange:\n k=(ell+0.5)/self.chis\n w[:]=1\n w[k<1e-4]=0\n w[k>=self.kmax]=0\n pkin = self.PK.P(self.zs, k, grid=False)\n common = ((w*pkin)*self.precalcFactor)[self.zs>=zmin]\n \n for key1,key2 in listKeys:\n estCl = np.dot(self.dchis[self.zs>=zmin], common*(self.kernels[key1]['W']*self.kernels[key2]['W'])[self.zs>=zmin])\n retList[key1+\",\"+key2].append(estCl)\n \n for key1,key2 in listKeys:\n retList[key1+\",\"+key2] = np.array(retList[key1+\",\"+key2])\n\n \n self.Clmatrix = retList\n self.ellrange = ellrange\n\n def getCl(self,key1,key2):\n\n try:\n return self.Clmatrix[key1+\",\"+key2]\n except KeyError:\n return self.Clmatrix[key2+\",\"+key1]\n except:\n print(\"Key combination not found\")\n raise\n \n \n def _lensWindow(self,kernel,numzIntegral):\n '''\n Calculates the following integral\n W(z) = \\int dz' p(z') (chi(z')-chi(z))/chi(z')\n where p(z) is the dndz/pdf of spectra\n and kernel must contain ['dndz']\n '''\n\n if kernel['dndz']==\"delta\":\n zthis = kernel['zdelta']\n retvals = ((1.-self.chis/(self.results.comoving_radial_distance(zthis))))\n retvals[self.zs>zthis] = 0.\n return retvals\n else:\n \n\n retvals = []\n for chinow,znow in zip(self.chis,self.zs):\n\n if znow>kernel['zmax']:\n retvals.append(0.) # this could be sped up\n else:\n\n _galFunc = lambda z: (kernel['dndz'](z)*((1.-chinow/(self.results.comoving_radial_distance(z))))) \n zStart = max(znow,kernel['zmin'])\n zs=np.linspace(zStart,kernel['zmax'],numzIntegral)\n dzs = (zs[2:]-zs[:-2])/2\n zs = zs[1:-1]\n _galInt = np.dot(dzs,np.array([_galFunc(zp) for zp in zs])) \n\n retvals.append((_galInt))\n return np.array(retvals)\n \n def addDeltaNz(self,tag,zsource,bias=None,magbias=None):\n\n assert not(tag in list(self.kernels.keys())), \"Tag already exists.\"\n assert tag!=\"cmb\", \"cmb is a tag reserved for cosmic microwave background. Use a different tag.\"\n \n \n self.kernels[tag] = {}\n self.kernels[tag]['dndz'] = \"delta\" \n self.kernels[tag]['zdelta'] = zsource\n\n self._generateWindow(tag,bias,magbias,numzIntegral=None)\n \n \n def addStepNz(self,tag,zmin,zmax,bias=None,magbias=None,numzIntegral=300):\n assert not(tag in list(self.kernels.keys())), \"Tag already exists.\"\n assert tag!=\"cmb\", \"cmb is a tag reserved for cosmic microwave background. Use a different tag.\"\n \n self.kernels[tag] = {}\n self.kernels[tag]['zmin'] = zmin\n self.kernels[tag]['zmax'] = zmax\n normStep = (self.kernels[tag]['zmax']-self.kernels[tag]['zmin'])\n self.kernels[tag]['dndz'] = lambda z: 1./normStep\n \n self._generateWindow(tag,bias,magbias,numzIntegral)\n \n def addNz(self,tag,zedges,nz,bias=None,magbias=None,numzIntegral=300):\n\n '''\n Assumes equally spaced bins\n If bias, then assumes counts, else assumes lensing\n If magbias provided, applies it as magnification bias assuming it is 's' in Eq 7 of Omuri Holder. Bias must be provided too.\n '''\n\n assert not(tag in list(self.kernels.keys())), \"Tag already exists.\"\n assert tag!=\"cmb\", \"cmb is a tag reserved for cosmic microwave background. Use a different tag.\"\n \n \n dzs = (zedges[1:]-zedges[:-1])\n norm = np.dot(dzs,nz)\n zmids = (zedges[1:]+zedges[:-1])/2.\n self.kernels[tag] = {}\n self.kernels[tag]['dndz'] = interp1d(zmids,nz/norm,bounds_error=False,fill_value=0.)\n self.kernels[tag]['zmin'] = zedges.min()\n self.kernels[tag]['zmax'] = zedges.max()\n\n self._generateWindow(tag,bias,magbias,numzIntegral)\n\n def _generateWindow(self,tag,bias,magbias,numzIntegral):\n print((\"Initializing galaxy window for \", tag , \" ...\"))\n if bias==None:\n\n retvals = self._lensWindow(self.kernels[tag],numzIntegral)\n self.kernels[tag]['window_z'] = interp1d(self.zs,retvals.copy())\n self.kernels[tag]['W'] = retvals *1.5*(self.omch2+self.ombh2+self.omnuh2)*100.*100.*(1.+self.zs)*self.chis/self.Hzs/self._cSpeedKmPerSec\n self.kernels[tag]['type'] = 'lensing'\n else:\n # FAILS FOR STEP !!!!\n assert self.kernels[tag]['dndz']!=\"delta\"\n self.kernels[tag]['W'] = self.zs*0.+bias*self.kernels[tag]['dndz'](self.zs)\n self.kernels[tag]['W'][self.zs<self.kernels[tag]['zmin']] = 0.\n self.kernels[tag]['W'][self.zs>self.kernels[tag]['zmax']] = 0.\n self.kernels[tag]['type'] = 'counts'\n if magbias!=None:\n retvals = self._lensWindow(self.kernels[tag],numzIntegral)\n magcorrection = retvals*1.5*(self.omch2+self.ombh2+self.omnuh2)*100.*100.*(1.+self.zs)*self.chis*(5.*magbias-2.)/self.Hzs**2./self._cSpeedKmPerSec # this needs to be checked again\n self.kernels[tag]['W'] += magcorrection\n print((\"Lensing bias max percent correction in counts \", np.max((np.nan_to_num(magcorrection *100./ self.kernels[tag]['W'])))))\n print((\"Lensing bias min percent correction in counts \", np.min((np.nan_to_num(magcorrection *100./ self.kernels[tag]['W'])))))\n\n\n \n \n\n\n def _initWkappaCMB(self):#,numz):\n\n print(\"Initializing CMB window..\")\n chirange = self.chis\n \n iwcmb = 1.5*(self.omch2+self.ombh2+self.omnuh2)*100.*100.*(1.+self.zs)*self.chis*((self.chistar - self.chis)/self.chistar)/self.Hzs/self._cSpeedKmPerSec\n self.kernels['cmb']={}\n self.kernels['cmb']['W'] = iwcmb\n self.kernels['cmb']['window_z'] = interp1d(self.zs,(self.chistar - self.chis)/self.chistar)\n \n \n\n"
] | [
[
"numpy.arange",
"numpy.sqrt",
"numpy.nan_to_num"
],
[
"numpy.dot",
"numpy.linspace",
"numpy.asarray",
"numpy.nan_to_num",
"numpy.ones",
"scipy.interpolate.interp1d",
"numpy.array",
"numpy.loadtxt"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [
"0.13",
"1.6",
"0.14",
"1.10",
"0.15",
"1.4",
"0.16",
"1.9",
"0.19",
"1.5",
"0.18",
"1.2",
"1.7",
"0.12",
"1.0",
"0.17",
"1.3",
"1.8"
],
"tensorflow": []
}
] |
AKSHANSH47/crowdsource-platform2 | [
"a31446d44bc10dca56a0d534cab226947a6bbb4e"
] | [
"fixtures/createJson.py"
] | [
"__author__ = 'Megha'\n# Script to transfer csv containing data about various models to json\n# Input csv file constituting of the model data\n# Output json file representing the csv data as json object\n# Assumes model name to be first line\n# Field names of the model on the second line\n# Data seperated by __DELIM__\n# Example:\n# L01 ModelName: registrationmodel\n# L02 FieldNames: user,activation_key,created_timestamp,last_updated\n# L03 Data: 1,qwer,2015-05-01T00:17:40.085Z,2015-05-01T00:17:40.085Z\n# L04 Data: 2,assd,2015-05-01T00:17:40.085Z,2015-05-01T00:17:40.085Z\n\nimport numpy as np\nimport pandas as pd\nimport json as json\n\n__MODULE_NAME__ = 7 # Number of lines after which Model Name\n__INPUT_FILE__ = 'meghaWorkerData.csv'\n__OUTPUT_FILE__ = 'meghaWorkerData.json'\n__NEWLINE__ = '\\n'\n__KEY1__ = 0\n__KEY2__ = 0\n__DELIM__ = ','\n__APPEND__ = 'crowdsourcing.'\n__KEY_MODEL__ = 'model'\n__KEY_FIELDS__ = 'fields'\n__KEY_PK__ = 'pk'\n\n\ndef create_dict(input_dict, module, data_collection):\n for key, value in input_dict.items():\n data_dict = {}\n data_dict[__KEY_FIELDS__] = value\n data_dict[__KEY_PK__] = key\n data_dict[__KEY_MODEL__] = __APPEND__ + module\n data_collection.append(data_dict)\n return data_collection\n\n\ndef create_data_json(file):\n in_fp = open(file, 'rb')\n file_lines = in_fp.readlines()\n in_fp.close()\n data_collection = []\n for line_no in range(0, len(file_lines)):\n if line_no % __MODULE_NAME__ == 0:\n columns = file_lines[line_no + 1].strip(__NEWLINE__).split(__DELIM__)\n instance1 = file_lines[line_no + 2].strip(__NEWLINE__).split(__DELIM__)\n instance2 = file_lines[line_no + 3].strip(__NEWLINE__).split(__DELIM__)\n instance3 = file_lines[line_no + 4].strip(__NEWLINE__).split(__DELIM__)\n instance4 = file_lines[line_no + 5].strip(__NEWLINE__).split(__DELIM__)\n instance5 = file_lines[line_no + 6].strip(__NEWLINE__).split(__DELIM__)\n data = np.array([instance1, instance2, instance3, instance4, instance5])\n df = pd.DataFrame(data, columns=columns)\n create_dict(df.transpose().to_dict(), file_lines[line_no].strip(__NEWLINE__), data_collection)\n del (df)\n print(data_collection)\n out_fp = open(__OUTPUT_FILE__, 'wb')\n out_fp.write(json.dumps(data_collection, indent=2))\n out_fp.close()\n\n\nif __name__ == '__main__':\n create_data_json(__INPUT_FILE__)\n"
] | [
[
"numpy.array",
"pandas.DataFrame"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"0.23",
"0.21",
"2.0",
"1.4",
"0.19",
"1.1",
"1.5",
"1.2",
"0.24",
"0.20",
"1.0",
"0.25",
"1.3"
],
"scipy": [],
"tensorflow": []
}
] |
convergence-lab/covid19-detection | [
"6a57e87ec1d8688712e6170a4c3aafb6e113ca73"
] | [
"src/train.py"
] | [
"import toml\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.metrics import accuracy_score, f1_score, roc_auc_score\nfrom logzero import logger\n\nimport torch\nfrom torch import nn, optim\nfrom torch.utils.data import DataLoader\nfrom torchvision import transforms\n\nfrom model import Model\nfrom data import load_data, CovidChestxrayDataset\n\ndef check_grad(parameters):\n grad = 0\n cnt = 0\n for p in parameters:\n grad += p.grad.norm()\n cnt += 1\n return grad / cnt\n\ndef train():\n with open(\"config.toml\") as f:\n config = toml.load(f)\n\n base_dir = config[\"data\"][\"base_dir\"]\n epochs = config[\"train\"][\"epochs\"]\n batch_size = config[\"train\"][\"batch_size\"]\n lr = config[\"train\"][\"lr\"]\n betas = config[\"train\"][\"betas\"]\n in_filters = config[\"model\"][\"in_filters\"]\n image_size = config[\"model\"][\"image_size\"]\n filters = config[\"model\"][\"filters\"]\n num_classes = config[\"model\"][\"num_classes\"]\n kernel_size = config[\"model\"][\"kernel_size\"]\n padding = config[\"model\"][\"padding\"]\n num_resblocks = config[\"model\"][\"num_resblocks\"]\n device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n\n records = load_data(base_dir)\n train_records, test_records = train_test_split(records, test_size=0.2)\n\n train_transform = transforms.Compose([\n transforms.Resize(image_size),\n transforms.RandomAffine(10, translate=[0.1, 0.1], shear=0.1),\n transforms.ColorJitter(brightness=0.7, contrast=0.7),\n transforms.ToTensor(),\n transforms.Normalize(0.5, 0.5)\n ])\n\n test_transform = transforms.Compose([\n transforms.Resize(image_size),\n transforms.ToTensor(),\n transforms.Normalize(0.5, 0.5)\n ])\n\n trainset = CovidChestxrayDataset(train_records, base_dir, train_transform)\n testset = CovidChestxrayDataset(test_records, base_dir, test_transform)\n trainloader = DataLoader(trainset, batch_size=batch_size, shuffle=True)\n testloader = DataLoader(testset, batch_size=1, shuffle=False)\n\n net = Model(in_filters, image_size, filters, kernel_size, padding, num_resblocks, num_classes)\n net.to(device)\n\n criterion = nn.NLLLoss()\n optimizer = optim.AdamW(net.parameters(), lr=lr, betas=betas, weight_decay=1e-2)\n\n for epoch in range(epochs):\n net.train()\n train_loss = 0\n train_targets = []\n train_probs = []\n train_preds = []\n grad = 0\n for batch in trainloader:\n img, label = batch\n train_targets += label.numpy().tolist()\n img, label = img.to(device), label.to(device)\n optimizer.zero_grad()\n pred = net(img)\n loss = criterion(pred, label)\n loss.backward()\n grad += check_grad(net.parameters())\n torch.nn.utils.clip_grad_norm_(net.parameters(), 1)\n optimizer.step()\n train_loss += loss.item()\n train_preds += pred.cpu().detach().numpy().argmax(axis=1).tolist()\n train_probs += pred.cpu().detach().numpy()[:, 1].tolist()\n acc = accuracy_score(train_targets, train_preds)\n f1 = f1_score(train_targets, train_preds, average=\"macro\")\n auc = roc_auc_score(train_targets, train_probs)\n logger.info(f\"Epoch {epoch+1} Train loss {train_loss/len(trainloader):.5}, Acc {acc*100:.3}%, F1 {f1*100:.3}%, AUC {auc*100:.4}%, grad {grad/len(trainloader)}\")\n net.eval()\n test_loss = 0\n test_targets = []\n test_preds = []\n test_probs = []\n for batch in testloader:\n img, label = batch\n test_targets += label.numpy().tolist()\n img, label = img.to(device), label.to(device)\n with torch.no_grad():\n pred = net(img)\n loss = criterion(pred, label)\n test_loss += loss.item()\n test_preds += pred.cpu().detach().numpy().argmax(axis=1).tolist()\n test_probs += pred.cpu().detach().numpy()[:, 1].tolist()\n\n acc = accuracy_score(test_targets, test_preds)\n f1 = f1_score(test_targets, test_preds, average=\"macro\")\n auc = roc_auc_score(test_targets, test_probs)\n logger.info(f\"Epoch {epoch+1} Test loss {test_loss/len(testloader):.5}, Acc {acc*100:.3}%, F1 {f1*100:.3}%, AUC {auc*100:.4}%\")\n torch.save(net.state_dict, \"net.pt\")\n\nif __name__ == \"__main__\":\n train()"
] | [
[
"sklearn.metrics.roc_auc_score",
"torch.nn.NLLLoss",
"sklearn.metrics.accuracy_score",
"torch.utils.data.DataLoader",
"sklearn.model_selection.train_test_split",
"torch.no_grad",
"torch.cuda.is_available",
"sklearn.metrics.f1_score",
"torch.save"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
HLTCHKUST/emotion-dialogue | [
"0d58b339134dd9a2f386948ae474b270a77370f9",
"0d58b339134dd9a2f386948ae474b270a77370f9",
"0d58b339134dd9a2f386948ae474b270a77370f9",
"0d58b339134dd9a2f386948ae474b270a77370f9"
] | [
"baseline/baseline_classifier.py",
"baseline/LR/LR_emoji_baseline.py",
"voting_confidence.py",
"models/lstm_model.py"
] | [
"from utils import constant\nfrom sklearn import svm\nfrom sklearn.svm import SVC\nfrom sklearn.linear_model import LogisticRegression\nfrom xgboost import XGBClassifier\n\n\ndef get_classifier(ty=\"LR\", c=1.0, max_depth=5, n_estimators=300, gamma=0):\n if(ty==\"LR\"):\n classifier = LogisticRegression(solver='lbfgs',multi_class='multinomial', C=c)\n elif(ty==\"SVM\"):\n classifier = SVC(kernel='linear')\n elif(ty==\"XGB\"):\n classifier = XGBClassifier(max_depth=max_depth, n_estimators=n_estimators, gamma=gamma, n_jobs=4, tree_method=\"gpu_hist\") ## change later ##\n return classifier",
"from utils.data_reader import prepare_data_for_feature, generate_vocab, read_data\nfrom utils.utils import getMetrics\nfrom utils.features import get_feature\nfrom utils import constant\nfrom baseline.baseline_classifier import get_classifier\nimport numpy as np\nimport argparse\n\nimport math\nimport csv\nimport os\n\n'''\nTry\npython main_classifier.py --emb_dim 300\n'''\n# feature_list = ['glove-common','glove-twitter','glove-w2v','emoji','elmo','bert','deepmoji','emo2vec']\n# feature_list = [\"glove-common\", \"emoji-300\", \"deepmoji\", \"elmo\", \"bert\", \"emo2vec\"]\nfeature_list = [\"emoji\"]\nfor item in feature_list:\n filename = str(item)+'-'+str(constant.emb_dim)\n ## predefine variables to evaluate the LR model\n F1Max = 0\n cMax = 0 # the value of c when F1 score gets max value\n\n ## LR model\n ## use csv file to store the best c for LR model with different features\n results = []\n\n if not os.path.exists(\"baseline/result\"):\n os.makedirs(\"./baseline/result\")\n\n with open('baseline/result/LR_single_{}_max.csv'.format(filename), 'w') as f:\n writer = csv.writer(f)\n writer.writerow([\"feature\",\"C\",\"microF1\"])\n\n with open('baseline/result/LR_single_{}_findC.csv'.format(filename), 'w') as f:\n writer = csv.writer(f)\n writer.writerow([\"feature\",\"C\",\"microF1\"])\n\n # data_loaders_tr, data_loaders_val, data_loaders_test, vocab = prepare_data_loaders(num_split=constant.num_split, batch_size=constant.batch_size, hier=False)\n\n ## distinguish twitter glove and common glove\n if item[:5]=='glove':\n ty = item[6:]\n feature = item[:5]\n elif item.find('-')>0:\n ty = 'common'\n feature = item[:(item.find('-')-1)]\n else:\n ty = 'common'\n feature = item\n\n ## compute Micro F1 score for each feature\n for j in range(2, 24):\n c = j/2\n model = get_classifier(ty='LR', c=c)\n\n microF1s = 0\n for i in range(constant.num_split):\n\n ## prepare data for feature-10 folders\n vocab = generate_vocab()\n train, val, dev_no_lab = read_data(is_shuffle=True, random_state=i)\n ## feature_list: glove emoji elmo bert deepmoji emo2vec\n ## if you want twitter glove or common glove use ty='twitter' and ty='common'\n X_train, y_train = get_feature(train, vocab, feature_list=[feature], mode=['sum'],split=\"train\",ty=ty) ## [29010,3,emb_size] 3 is number of sentence\n X_test, y_test = get_feature(val, vocab, feature_list=[feature], mode=['sum'],split=\"valid\",ty=ty) ## [1150,3,emb_size]\n\n print(\"###### EXPERIMENT %d when C equals to %f ######\" % ((i+1),c))\n print(\"(EXPERIMENT %d) Create the model\" % (i+1))\n\n ## train aval and predict\n model.fit(X_train.reshape(X_train.shape[0], -1), y_train) ## [29010,3,emb_size] --> [29010, 3 * emb_size]\n\n ## validate to validation set \n y_pred = model.predict(X_test.reshape(X_test.shape[0], -1))\n\n ## covert output to one hot\n one_hot = np.zeros((y_pred.shape[0], 4))\n one_hot[np.arange(y_pred.shape[0]), y_pred] = 1\n ## call the scorer \n acc, microPrecision, microRecall, microF1 = getMetrics(one_hot,y_test,verbose=True)\n\n microF1s = microF1s + microF1\n \n microF1s = microF1s/constant.num_split\n\n results.append([filename, c, microF1s])\n with open('baseline/result/LR_single_{}_max.csv'.format(filename), 'a') as f:\n writer = csv.writer(f)\n for row in results:\n writer.writerow(row)\n results = []\n\n \n if microF1s > F1Max:\n F1Max = microF1s\n cMax = c\n\n resultMax=[filename, cMax, F1Max]\n print(\"(EXPERIMENT %d) Best F1 VAL: %3.5f\" % ((i+1), F1Max))\n\n ## prepare for the next cycle\n microF1s = 0\n\n ## write the best result into csv file\n with open('baseline/result/LR_single_{}_findC.csv'.format(filename), 'a') as f:\n writer = csv.writer(f)\n writer.writerow(resultMax)\n\n resultMax = []\n F1Max = 0",
"from utils.data_reader import prepare_data, prepare_data_loaders\nfrom utils import constant\nfrom utils.utils import getMetrics\n\nfrom models.lstm_model import HLstmModel\nfrom models.transformer import HUTransformer\n\nimport torch.nn as nn\nimport torch\nimport numpy as np\nfrom tqdm import tqdm\nimport os\n\nimport pandas as pd\nimport numpy as np\nimport os \nimport math\n\nimport os.path\n\nvoting_dir_list = constant.voting_dir_list\nsave_prediction_path = constant.save_prediction_path\nsave_confidence_path = constant.save_confidence_path\n\nlabel = {\"others\":0, \"happy\":1, \"sad\":2, \"angry\":3}\nlabel2emotion = [\"others\", \"happy\", \"sad\", \"angry\"]\n\ndef voting():\n print(\"voting\")\n happy_pred = []\n sad_pred = []\n angry_pred = []\n others_pred = []\n\n df_list = []\n pred_num = 0\n for i in range(len(voting_dir_list)):\n directory = voting_dir_list[i]\n print(\"Directory:\", directory)\n\n for file in os.listdir(directory):\n filename = os.fsdecode(file)\n print(\">\", directory+\"/\"+filename)\n if filename.startswith(\"test_confidence\"): \n df = pd.read_csv(directory+\"/\"+filename, delimiter='\\t')\n df_list.append(df)\n\n idx = 0\n for d in df['happy'].values:\n if pred_num == 0:\n happy_pred.append(d)\n else:\n happy_pred[idx] += d\n idx += 1\n\n idx = 0\n for d in df['sad'].values:\n if pred_num == 0:\n sad_pred.append(d)\n else:\n sad_pred[idx] += d\n idx += 1\n \n idx = 0\n for d in df['angry'].values:\n if pred_num == 0:\n angry_pred.append(d)\n else:\n angry_pred[idx] += d\n idx += 1\n\n idx = 0\n for d in df['others'].values:\n if pred_num == 0:\n others_pred.append(d)\n else:\n others_pred[idx] += d\n idx += 1\n pred_num += 1 # one time\n \n return df_list, happy_pred, sad_pred, angry_pred, others_pred\n\ndf_list, happy_pred, sad_pred, angry_pred, others_pred = voting()\ndf = df_list[0]\n\npredictions = []\ncnt_non_other = 0\ncnt = 0 \nfor i in range(len(happy_pred)):\n pred = np.array([others_pred[i], happy_pred[i], sad_pred[i], angry_pred[i]])\n best_pred = np.argmax(pred)\n predictions.append(label2emotion[best_pred])\n\n if best_pred != 0:\n cnt_non_other += 1\n else:\n cnt += 1\n \ndf['label'] = predictions\ndf['happy'] = happy_pred\ndf['sad'] = sad_pred\ndf['angry'] = angry_pred\ndf['others'] = others_pred\n\ndf.to_csv(save_confidence_path, index=None, sep='\\t')\nprint(df)\nprint(\"Non Other:\",cnt_non_other,\"Other:\",cnt)\n\ndf = df.drop(['others','happy','sad','angry'], axis=1)\ndf.to_csv(save_prediction_path, index=None, sep='\\t')",
"import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport torch.nn.init as I\nfrom torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence\nfrom torch.autograd import Variable\n\nimport numpy as np\nimport math\n\nfrom models.common_layer import Attention\nfrom utils import constant\nfrom models.common_layer import MultiHeadAttention, BertPooler\nfrom utils.features import share_embedding\n\nclass LstmModel(nn.Module):\n \"\"\"\n An LSTM model. \n Inputs: \n X: (batch_size, seq_len)\n X_lengths: (batch_size)\n Outputs: (batch_size, labels)\n \"\"\"\n def __init__(self, vocab, embedding_size, hidden_size, num_layers, max_length=700, input_dropout=0.0, layer_dropout=0.0, is_bidirectional=False, attentive=False):\n super(LstmModel, self).__init__()\n self.embedding_dim = embedding_size\n self.hidden_size = hidden_size\n\n self.input_dropout = nn.Dropout(input_dropout)\n self.layer_dropout = nn.Dropout(layer_dropout)\n self.vocab = vocab\n # self.emb = nn.Embedding(num_vocab, embedding_size, padding_idx=0)\n self.emb = share_embedding(self.vocab,constant.pretrained, fix_pretrain=constant.fix_pretrain)\n self.lstm = nn.LSTM(embedding_size, hidden_size=hidden_size, num_layers=num_layers, bidirectional=is_bidirectional)\n self.W = nn.Linear(hidden_size*2 if is_bidirectional else hidden_size,4) ## 4 emotion\n self.softmax = nn.Softmax(dim=1)\n\n self.num_layers = num_layers\n self.is_bidirectional = is_bidirectional\n\n def forward(self, X, X_lengths, extract_feature=False):\n \"\"\"\n Forward algorithm\n if extract_feature is True: returns output of LSTM before output layer\n else: returns the logits and softmax of logits\n \"\"\"\n X = self.emb(X)\n X = self.input_dropout(X)\n\n X = X.transpose(0, 1) # (len, batch_size, dim)\n\n packed_input = torch.nn.utils.rnn.pack_padded_sequence(X, X_lengths, batch_first=False)\n _, hidden = self.lstm(packed_input) \n # returns hidden state of all timesteps as well as hidden state at last timestep\n # should take last non zero hidden state, not last timestamp (may have zeros), don't take output\n # output, _ = torch.nn.utils.rnn.pad_packed_sequence(packed_output, batch_first=False)\n\n last_hidden = hidden[-1] # (num_direction, batch_size, dim)\n if len(last_hidden.size()) == 3:\n last_hidden_1 = last_hidden[-1]\n\n if self.is_bidirectional:\n last_hidden = torch.cat((last_hidden[0].squeeze(0), last_hidden[1].squeeze(0)), dim=1)\n else:\n last_hidden = last_hidden.squeeze(0)\n\n if extract_feature:\n return last_hidden\n\n last_hidden = self.layer_dropout(last_hidden)\n\n a_hat = self.W(last_hidden) # (batch_size, 4)\n return a_hat, self.softmax(a_hat)\n\nclass HLstmModel(nn.Module):\n \"\"\"\n A Hierarchical LSTM model with self-attention.\n Inputs: \n X_1: (batch_size, seq_len),\n X_2: (batch_size, seq_len),\n X_3: (batch_size, seq_len),\n X_lengths: (batch_size)\n Outputs: (batch_size, labels)\n \"\"\"\n def __init__(self, vocab, embedding_size, hidden_size, num_layers, max_length=700, input_dropout=0.0, layer_dropout=0.0, is_bidirectional=False,\n attentive=False, multiattentive=False, num_heads=5, total_key_depth=500, total_value_depth=1000, use_mask = True, sum_tensor=False, super_ratio=0.0, double_supervision=False,\n context=False,pool=\"\",pool_stride=2, pool_kernel=3):\n super(HLstmModel, self).__init__()\n self.embedding_dim = embedding_size\n self.hidden_size = hidden_size\n self.sum_tensor = sum_tensor\n self.input_dropout = nn.Dropout(input_dropout)\n self.layer_dropout = nn.Dropout(layer_dropout)\n self.vocab = vocab\n\n self.pooler = BertPooler(hidden_size*2 if is_bidirectional else hidden_size)\n # self.emb = nn.Embedding(num_vocab, embedding_size, padding_idx=0)\n self.emb = share_embedding(self.vocab,constant.pretrained, constant.fix_pretrain)\n self.context = context\n if self.context:\n self.context_lstm = nn.LSTM(embedding_size, hidden_size=hidden_size, num_layers=num_layers, bidirectional=is_bidirectional)\n\n self.lstm = nn.LSTM(embedding_size, hidden_size=hidden_size, num_layers=num_layers, bidirectional=is_bidirectional)\n \n self.pool = pool\n if self.pool == \"avg\":\n kernel_size = pool_kernel\n stride = pool_stride\n padding = 0\n\n l_in = hidden_size\n if is_bidirectional:\n l_in *= 2\n\n self.pooling_layer = nn.AvgPool1d(kernel_size, stride=stride, padding=padding)\n l_out = int(((l_in + 2 * padding - kernel_size) / stride) + 1)\n\n self.lstm_layer = nn.LSTM(l_out, hidden_size=hidden_size, num_layers=num_layers, bidirectional=is_bidirectional)\n elif self.pool == \"max\":\n kernel_size = pool_kernel\n stride = pool_stride\n padding = 0\n dilation = 1\n\n l_in = hidden_size\n if is_bidirectional:\n l_in *= 2\n\n self.pooling_layer = nn.MaxPool1d(kernel_size, stride=stride, padding=padding, dilation=dilation)\n l_out = int(((l_in + 2 * padding - dilation * (kernel_size - 1) - 1) / stride) + 1)\n\n self.lstm_layer = nn.LSTM(l_out, hidden_size=hidden_size, num_layers=num_layers, bidirectional=is_bidirectional)\n elif self.pool == \"globalmax\" or self.pool == \"globalavg\":\n self.lstm_layer = nn.LSTM(hidden_size*2 if is_bidirectional else hidden_size, hidden_size=hidden_size, num_layers=num_layers, bidirectional=is_bidirectional)\n else:\n self.lstm_layer = nn.LSTM(hidden_size*2 if is_bidirectional else hidden_size, hidden_size=hidden_size, num_layers=num_layers, bidirectional=is_bidirectional)\n self.W = nn.Linear(hidden_size*2 if is_bidirectional else hidden_size,4) ## 4 emotion\n self.softmax = nn.Softmax(dim=1)\n\n self.num_layers = num_layers\n self.is_bidirectional = is_bidirectional\n\n self.attentive =attentive\n self.multiattentive = multiattentive\n self.use_mask = use_mask\n if self.multiattentive:\n self.attentive = True\n if self.attentive:\n if self.multiattentive:\n self.word_attention = MultiHeadAttention(hidden_size*2 if is_bidirectional else hidden_size, total_key_depth, total_value_depth,\n hidden_size*2 if is_bidirectional else hidden_size, num_heads)\n self.sentences_attention = MultiHeadAttention(hidden_size*2 if is_bidirectional else hidden_size, total_key_depth, total_value_depth,\n hidden_size*2 if is_bidirectional else hidden_size, num_heads)\n else:\n self.word_attention = Attention(hidden_size*2 if is_bidirectional else hidden_size)\n self.sentences_attention = Attention(hidden_size*2 if is_bidirectional else hidden_size)\n\n self.double_supervision = double_supervision\n if double_supervision:\n self.output_super = nn.Linear(hidden_size*3, 4) # lower layer supervision\n\n def forward(self, X_1, X_2, X_3, X_1_lengths, X_2_lengths, X_3_lengths, extract_feature=False, cuda=True):\n \"\"\"\n Forward algorithm\n if extract_feature is True: returns output of LSTM before output layer\n else: returns the logits and softmax of logits\n \"\"\"\n if self.use_mask:\n mask1 = X_1.data.eq(constant.PAD_idx).unsqueeze(1)\n mask2 = X_2.data.eq(constant.PAD_idx).unsqueeze(1)\n mask3 = X_3.data.eq(constant.PAD_idx).unsqueeze(1)\n else:\n mask1=mask2=mask3=None\n X_1 = self.emb(X_1)\n X_2 = self.emb(X_2)\n X_3 = self.emb(X_3)\n\n # sort X_2 and X_3\n X_1_lengths = torch.LongTensor(X_1_lengths)\n sorted_X_2_lengths, perm_index_x_2 = torch.sort(torch.LongTensor(X_2_lengths), descending=True)\n sorted_X_3_lengths, perm_index_x_3 = torch.sort(torch.LongTensor(X_3_lengths), descending=True)\n if cuda:\n X_1_lengths = X_1_lengths.cuda()\n sorted_X_2_lengths = sorted_X_2_lengths.cuda()\n sorted_X_3_lengths = sorted_X_3_lengths.cuda()\n perm_index_x_2 = perm_index_x_2.cuda()\n perm_index_x_3 = perm_index_x_3.cuda()\n\n sorted_X_2 = X_2[perm_index_x_2]\n sorted_X_3 = X_3[perm_index_x_3]\n \n X_1 = self.input_dropout(X_1).transpose(0, 1) # (len, batch_size, dim)\n sorted_X_2 = self.input_dropout(sorted_X_2).transpose(0, 1) # (len, batch_size, dim)\n sorted_X_3 = self.input_dropout(sorted_X_3).transpose(0, 1) # (len, batch_size, dim)\n\n # returns hidden state of all timesteps as well as hidden state at last timestep\n # should take last non zero hidden state, not last timestamp (may have zeros), don't take output\n packed_input_1 = torch.nn.utils.rnn.pack_padded_sequence(X_1, X_1_lengths, batch_first=False)\n packed_input_2 = torch.nn.utils.rnn.pack_padded_sequence(sorted_X_2, sorted_X_2_lengths, batch_first=False)\n packed_input_3 = torch.nn.utils.rnn.pack_padded_sequence(sorted_X_3, sorted_X_3_lengths, batch_first=False)\n \n if self.context:\n lstm_out1, hidden_1 = self.context_lstm(packed_input_1) # hidden: (len, batch_size, dim)\n lstm_out2, hidden_2 = self.context_lstm(packed_input_2) # hidden: (len, batch_size, dim)\n else:\n lstm_out1, hidden_1 = self.lstm(packed_input_1) # hidden: (len, batch_size, dim)\n lstm_out2, hidden_2 = self.lstm(packed_input_2) # hidden: (len, batch_size, dim)\n lstm_out3, hidden_3 = self.lstm(packed_input_3) # hidden: (len, batch_size, dim)\n\n if self.attentive:\n padded_lstm_out1, _ = nn.utils.rnn.pad_packed_sequence(lstm_out1)\n padded_lstm_out2, _ = nn.utils.rnn.pad_packed_sequence(lstm_out2)\n padded_lstm_out3, _ = nn.utils.rnn.pad_packed_sequence(lstm_out3)\n padded_lstm_out1 = padded_lstm_out1.permute(1,0,2) #(batch, seq_len, num_directions * hidden_size)\n padded_lstm_out2 = padded_lstm_out2.permute(1,0,2)\n padded_lstm_out3 = padded_lstm_out3.permute(1,0,2)\n if self.multiattentive:\n \n last_hidden_1 = self.word_attention(padded_lstm_out1,padded_lstm_out1,padded_lstm_out1,src_mask=mask1)\n last_hidden_2 = self.word_attention(padded_lstm_out2,padded_lstm_out2,padded_lstm_out2,src_mask=mask2)\n last_hidden_3 = self.word_attention(padded_lstm_out3,padded_lstm_out3,padded_lstm_out3,src_mask=mask3)\n if self.sum_tensor:\n last_hidden_1 = torch.sum(last_hidden_1, dim=1)\n last_hidden_2 = torch.sum(last_hidden_2, dim=1)\n last_hidden_3 = torch.sum(last_hidden_3, dim=1)\n else:\n last_hidden_1 = self.pooler(last_hidden_1)\n last_hidden_2 = self.pooler(last_hidden_2)\n last_hidden_3 = self.pooler(last_hidden_3)\n else:\n last_hidden_1 = self.word_attention(padded_lstm_out1, X_1_lengths) #(batch, num_directions * hidden_size)\n last_hidden_2 = self.word_attention(padded_lstm_out2, sorted_X_2_lengths)\n last_hidden_3 = self.word_attention(padded_lstm_out3, sorted_X_2_lengths)\n else:\n last_hidden_1 = hidden_1[-1] # (num_direction * num_layer, batch_size, dim)\n last_hidden_2 = hidden_2[-1] # (num_direction * num_layer, batch_size, dim)\n last_hidden_3 = hidden_3[-1] # (num_direction * num_layer, batch_size, dim)\n\n batch_size = last_hidden_1.size(1)\n dim = last_hidden_1.size(2)\n last_hidden_1 = last_hidden_1.view(self.num_layers, 2 if self.is_bidirectional else 1, batch_size, dim)[-1]\n last_hidden_2 = last_hidden_2.view(self.num_layers, 2 if self.is_bidirectional else 1, batch_size, dim)[-1]\n last_hidden_3 = last_hidden_3.view(self.num_layers, 2 if self.is_bidirectional else 1, batch_size, dim)[-1]\n\n if self.is_bidirectional:\n last_hidden_1 = torch.cat((last_hidden_1[0].squeeze(0), last_hidden_1[1].squeeze(0)), dim=1)\n last_hidden_2 = torch.cat((last_hidden_2[0].squeeze(0), last_hidden_2[1].squeeze(0)), dim=1)\n last_hidden_3 = torch.cat((last_hidden_3[0].squeeze(0), last_hidden_3[1].squeeze(0)), dim=1)\n else:\n last_hidden_1 = last_hidden_1.squeeze(0) # (batch_size, dim)\n last_hidden_2 = last_hidden_2.squeeze(0) # (batch_size, dim)\n last_hidden_3 = last_hidden_3.squeeze(0) # (batch_size, dim)\n\n # restore the order\n unsorted_last_hidden_2 = last_hidden_2.new(*last_hidden_2.size())\n unsorted_last_hidden_2.scatter_(0, perm_index_x_2.unsqueeze(1).expand(last_hidden_2.size(0), last_hidden_2.size(1)), last_hidden_2)\n unsorted_last_hidden_3 = last_hidden_3.new(*last_hidden_3.size())\n unsorted_last_hidden_3.scatter_(0, perm_index_x_3.unsqueeze(1).expand(last_hidden_3.size(0), last_hidden_3.size(1)), last_hidden_3)\n\n last_hidden = torch.cat((last_hidden_1.unsqueeze(0), unsorted_last_hidden_2.unsqueeze(0), unsorted_last_hidden_3.unsqueeze(0)), dim=0) # (3, batch_size, dim)\n concatenated_hidden = last_hidden.transpose(0, 1) # (batch_size, 3, dim)\n if self.pool == \"avg\" or self.pool == \"max\":\n last_hidden = self.pooling_layer(last_hidden)\n elif self.pool == \"globalavg\" or self.pool == \"globalmax\":\n context_hidden = last_hidden[:2] # (2, batch_size, dim)\n if self.pool == \"globalavg\":\n context_hidden = context_hidden.mean(dim=0).unsqueeze(0) # (1, batch_size, dim)\n else:\n context_hidden = context_hidden.max(dim=0)[0].unsqueeze(0) # (1, batch_size, dim)\n turn3_hidden = last_hidden[2].unsqueeze(0) # (1, batch_size, dim)\n last_hidden = torch.cat((context_hidden, turn3_hidden), dim=0)\n\n concatenated_hidden = concatenated_hidden.contiguous().view(concatenated_hidden.size(0), -1) # (batch_size, 3 * dim)\n\n lstm_layer_out, hidden = self.lstm_layer(last_hidden)\n if self.attentive:\n lstm_layer_out = lstm_layer_out.permute(1,0,2) #(batch, seq_len, num_directions * hidden_size)\n if self.multiattentive:\n last_hidden = torch.sum(self.sentences_attention(lstm_layer_out, lstm_layer_out, lstm_layer_out),dim=1)\n else:\n last_hidden = self.sentences_attention(lstm_layer_out) #(batch, num_directions * hidden_size)\n else:\n last_hidden = hidden[-1] # (num_direction * num_layers, batch_size, dim)\n batch_size = last_hidden.size(1)\n dim = last_hidden.size(2)\n last_hidden = last_hidden.view(self.num_layers, 2 if self.is_bidirectional else 1, batch_size, dim)[-1]\n\n if self.is_bidirectional:\n last_hidden = torch.cat((last_hidden[0].squeeze(0), last_hidden[1].squeeze(0)), dim=1)\n else:\n last_hidden = last_hidden.squeeze(0)\n\n if extract_feature: # for SVM\n if self.double_supervision:\n return torch.cat((concatenated_hidden, last_hidden), dim=1)\n else:\n return last_hidden\n\n last_hidden = self.layer_dropout(last_hidden)\n\n a_hat = self.W(last_hidden) # (batch_size, 4) \n if self.double_supervision:\n additional_logits = self.output_super(concatenated_hidden) # (batch_size, 4)\n return a_hat, self.softmax(a_hat), additional_logits, self.softmax(additional_logits)\n return a_hat, self.softmax(a_hat)\n"
] | [
[
"sklearn.linear_model.LogisticRegression",
"sklearn.svm.SVC"
],
[
"numpy.arange",
"numpy.zeros"
],
[
"pandas.read_csv",
"numpy.array",
"numpy.argmax"
],
[
"torch.nn.Softmax",
"torch.nn.Dropout",
"torch.LongTensor",
"torch.nn.LSTM",
"torch.cat",
"torch.sum",
"torch.nn.utils.rnn.pack_padded_sequence",
"torch.nn.Linear",
"torch.nn.utils.rnn.pad_packed_sequence",
"torch.nn.MaxPool1d",
"torch.nn.AvgPool1d"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [
"2.0",
"1.4",
"1.1",
"1.5",
"1.2",
"1.3"
],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
dedsec-9/AutoGL | [
"487f2b2f798b9b1363ad5dc100fb410b12222e06",
"487f2b2f798b9b1363ad5dc100fb410b12222e06",
"487f2b2f798b9b1363ad5dc100fb410b12222e06",
"487f2b2f798b9b1363ad5dc100fb410b12222e06",
"487f2b2f798b9b1363ad5dc100fb410b12222e06"
] | [
"examples/node_classification.py",
"test/performance/graph_classification/pyg/base.py",
"test/performance/heterogeneous/dgl/hgt_main.py",
"autogl/module/ensemble/stacking.py",
"test/performance/graph_classification/dgl/base.py"
] | [
"import yaml\nimport random\nimport torch.backends.cudnn\nimport numpy as np\nfrom autogl.datasets import build_dataset_from_name\nfrom autogl.solver import AutoNodeClassifier\nfrom autogl.module import Acc\nfrom autogl.backend import DependentBackend\n\nif __name__ == \"__main__\":\n\n from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter\n\n parser = ArgumentParser(\n \"auto node classification\", formatter_class=ArgumentDefaultsHelpFormatter\n )\n parser.add_argument(\n \"--dataset\",\n default=\"cora\",\n type=str,\n help=\"dataset to use\",\n choices=[\n \"cora\",\n \"pubmed\",\n \"citeseer\",\n \"coauthor_cs\",\n \"coauthor_physics\",\n \"amazon_computers\",\n \"amazon_photo\",\n ],\n )\n parser.add_argument(\n \"--configs\",\n type=str,\n default=\"../configs/nodeclf_gcn_benchmark_small.yml\",\n help=\"config to use\",\n )\n # following arguments will override parameters in the config file\n parser.add_argument(\"--hpo\", type=str, default=\"tpe\", help=\"hpo methods\")\n parser.add_argument(\n \"--max_eval\", type=int, default=50, help=\"max hpo evaluation times\"\n )\n parser.add_argument(\"--seed\", type=int, default=0, help=\"random seed\")\n parser.add_argument(\"--device\", default=0, type=int, help=\"GPU device\")\n\n args = parser.parse_args()\n if torch.cuda.is_available():\n torch.cuda.set_device(args.device)\n seed = args.seed\n # set random seed\n random.seed(seed)\n np.random.seed(seed)\n torch.manual_seed(seed)\n if torch.cuda.is_available():\n torch.cuda.manual_seed(seed)\n torch.backends.cudnn.deterministic = True\n torch.backends.cudnn.benchmark = False\n\n dataset = build_dataset_from_name(args.dataset)\n label = dataset[0].nodes.data[\"y\" if DependentBackend.is_pyg() else \"label\"]\n num_classes = len(np.unique(label.numpy()))\n\n configs = yaml.load(open(args.configs, \"r\").read(), Loader=yaml.FullLoader)\n configs[\"hpo\"][\"name\"] = args.hpo\n configs[\"hpo\"][\"max_evals\"] = args.max_eval\n autoClassifier = AutoNodeClassifier.from_config(configs)\n\n # train\n if args.dataset in [\"cora\", \"citeseer\", \"pubmed\"]:\n autoClassifier.fit(dataset, time_limit=3600, evaluation_method=[Acc])\n else:\n autoClassifier.fit(\n dataset,\n time_limit=3600,\n evaluation_method=[Acc],\n seed=seed,\n train_split=20 * num_classes,\n val_split=30 * num_classes,\n balanced=False,\n )\n autoClassifier.get_leaderboard().show()\n acc = autoClassifier.evaluate(metric=\"acc\")\n print(\"test acc: {:.4f}\".format(acc))\n",
"\"\"\"\nPerformance check of PYG (model + trainer + dataset)\n\"\"\"\nimport os\nimport random\nimport numpy as np\nfrom tqdm import tqdm\nimport torch\nimport torch.nn.functional as F\nfrom torch.nn import Sequential, Linear, ReLU\nimport torch_geometric\nfrom torch_geometric.datasets import TUDataset\nif int(torch_geometric.__version__.split(\".\")[0]) >= 2:\n from torch_geometric.loader import DataLoader\nelse:\n from torch_geometric.data import DataLoader\nfrom torch_geometric.nn import GINConv, global_add_pool, GraphConv, TopKPooling\nfrom torch_geometric.nn import global_mean_pool as gap, global_max_pool as gmp\nimport logging\n\ntorch.backends.cudnn.deterministic = True\n#torch.use_deterministic_algorithms(True)\n\nlogging.basicConfig(level=logging.ERROR)\n\nclass GIN(torch.nn.Module):\n def __init__(self):\n super(GIN, self).__init__()\n\n num_features = dataset.num_features\n dim = 32\n\n nn1 = Sequential(Linear(num_features, dim), ReLU(), Linear(dim, dim))\n self.conv1 = GINConv(nn1)\n self.bn1 = torch.nn.BatchNorm1d(dim)\n\n nn2 = Sequential(Linear(dim, dim), ReLU(), Linear(dim, dim))\n self.conv2 = GINConv(nn2)\n self.bn2 = torch.nn.BatchNorm1d(dim)\n\n nn3 = Sequential(Linear(dim, dim), ReLU(), Linear(dim, dim))\n self.conv3 = GINConv(nn3)\n self.bn3 = torch.nn.BatchNorm1d(dim)\n\n nn4 = Sequential(Linear(dim, dim), ReLU(), Linear(dim, dim))\n self.conv4 = GINConv(nn4)\n self.bn4 = torch.nn.BatchNorm1d(dim)\n\n nn5 = Sequential(Linear(dim, dim), ReLU(), Linear(dim, dim))\n self.conv5 = GINConv(nn5)\n self.bn5 = torch.nn.BatchNorm1d(dim)\n\n self.fc1 = Linear(dim, dim)\n self.fc2 = Linear(dim, dataset.num_classes)\n\n def forward(self, data):\n x, edge_index, batch = data.x, data.edge_index, data.batch\n x = F.relu(self.conv1(x, edge_index))\n x = self.bn1(x)\n x = F.relu(self.conv2(x, edge_index))\n x = self.bn2(x)\n x = F.relu(self.conv3(x, edge_index))\n x = self.bn3(x)\n x = F.relu(self.conv4(x, edge_index))\n x = self.bn4(x)\n x = F.relu(self.conv5(x, edge_index))\n x = self.bn5(x)\n x = global_add_pool(x, batch)\n x = F.relu(self.fc1(x))\n x = F.dropout(x, p=0.5, training=self.training)\n x = self.fc2(x)\n return F.log_softmax(x, dim=-1)\n\nclass TopKPool(torch.nn.Module):\n def __init__(self):\n super(TopKPool, self).__init__()\n\n self.conv1 = GraphConv(dataset.num_features, 128)\n self.pool1 = TopKPooling(128, ratio=0.8)\n self.conv2 = GraphConv(128, 128)\n self.pool2 = TopKPooling(128, ratio=0.8)\n self.conv3 = GraphConv(128, 128)\n self.pool3 = TopKPooling(128, ratio=0.8)\n\n self.lin1 = torch.nn.Linear(256, 128)\n self.lin2 = torch.nn.Linear(128, 64)\n self.lin3 = torch.nn.Linear(64, dataset.num_classes)\n\n def forward(self, data):\n x, edge_index, batch = data.x, data.edge_index, data.batch\n\n x = F.relu(self.conv1(x, edge_index))\n x, edge_index, _, batch, _, _ = self.pool1(x, edge_index, None, batch)\n x1 = torch.cat([gmp(x, batch), gap(x, batch)], dim=1)\n\n x = F.relu(self.conv2(x, edge_index))\n x, edge_index, _, batch, _, _ = self.pool2(x, edge_index, None, batch)\n x2 = torch.cat([gmp(x, batch), gap(x, batch)], dim=1)\n\n x = F.relu(self.conv3(x, edge_index))\n x, edge_index, _, batch, _, _ = self.pool3(x, edge_index, None, batch)\n x3 = torch.cat([gmp(x, batch), gap(x, batch)], dim=1)\n\n x = x1 + x2 + x3\n\n x = F.relu(self.lin1(x))\n x = F.dropout(x, p=0.5, training=self.training)\n x = F.relu(self.lin2(x))\n x = F.log_softmax(self.lin3(x), dim=-1)\n\n return x\n\ndef test(model, loader, args):\n model.eval()\n\n correct = 0\n for data in loader:\n data = data.to(args.device)\n output = model(data)\n pred = output.max(dim=1)[1]\n correct += pred.eq(data.y).sum().item()\n return correct / len(loader.dataset)\n\ndef train(model, train_loader, val_loader, args):\n optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)\n\n parameters = model.state_dict()\n best_acc = 0.\n for epoch in range(args.epoch):\n model.train()\n for data in train_loader:\n data = data.to(args.device)\n optimizer.zero_grad()\n output = model(data)\n loss = F.nll_loss(output, data.y)\n loss.backward()\n optimizer.step()\n\n val_acc = test(model, val_loader, args)\n if val_acc > best_acc:\n best_acc = val_acc\n parameters = model.state_dict()\n \n model.load_state_dict(parameters)\n return model\n\nif __name__ == '__main__':\n\n import argparse\n parser = argparse.ArgumentParser('pyg trainer')\n parser.add_argument('--device', type=str, default='cuda')\n parser.add_argument('--dataset', type=str, choices=['MUTAG', 'COLLAB', 'IMDBBINARY', 'IMDBMULTI', 'NCI1', 'PROTEINS', 'PTC', 'REDDITBINARY', 'REDDITMULTI5K'], default='MUTAG')\n parser.add_argument('--dataset_seed', type=int, default=2021)\n parser.add_argument('--batch_size', type=int, default=32)\n parser.add_argument('--repeat', type=int, default=50)\n parser.add_argument('--model', type=str, choices=['gin', 'topkpool'], default='gin')\n parser.add_argument('--lr', type=float, default=0.0001)\n parser.add_argument('--epoch', type=int, default=100)\n\n args = parser.parse_args()\n\n # seed = 100\n dataset = TUDataset(os.path.expanduser('~/.pyg'), args.dataset)\n \n # 1. split dataset [fix split]\n dataids = list(range(len(dataset)))\n random.seed(args.dataset_seed)\n random.shuffle(dataids)\n torch.manual_seed(args.dataset_seed)\n np.random.seed(args.dataset_seed)\n if args.device == 'cuda':\n torch.cuda.manual_seed(args.dataset_seed)\n \n fold = int(len(dataset) * 0.1)\n train_index = dataids[:fold * 8]\n val_index = dataids[fold * 8: fold * 9]\n test_index = dataids[fold * 9: ]\n dataset.train_index = train_index\n dataset.val_index = val_index\n dataset.test_index = test_index\n dataset.train_split = dataset[dataset.train_index]\n dataset.val_split = dataset[dataset.val_index]\n dataset.test_split = dataset[dataset.test_index]\n\n labels = np.array([data.y.item() for data in dataset.test_split])\n\n def seed_worker(worker_id):\n #seed = torch.initial_seed()\n torch.manual_seed(args.dataset_seed)\n np.random.seed(args.dataset_seed)\n random.seed(args.dataset_seed)\n g = torch.Generator()\n g.manual_seed(args.dataset_seed)\n\n train_loader = DataLoader(dataset.train_split, batch_size=args.batch_size, worker_init_fn=seed_worker, generator=g)\n val_loader = DataLoader(dataset.val_split, batch_size=args.batch_size, worker_init_fn=seed_worker, generator=g)\n test_loader = DataLoader(dataset.test_split, batch_size=args.batch_size, worker_init_fn=seed_worker, generator=g)\n\n #train_loader = DataLoader(dataset.train_split, batch_size=args.batch_size, shuffle=False)\n #val_loader = DataLoader(dataset.val_split, batch_size=args.batch_size, shuffle=False)\n #test_loader = DataLoader(dataset.test_split, batch_size=args.batch_size, shuffle=False)\n\n accs = []\n\n for seed in tqdm(range(args.repeat)):\n torch.manual_seed(seed)\n np.random.seed(seed)\n #random.seed(seed)\n if args.device == 'cuda':\n torch.cuda.manual_seed(seed)\n\n if args.model == 'gin':\n model = GIN()\n elif args.model == 'topkpool':\n model = TopKPool()\n \n model.to(args.device)\n\n train(model, train_loader, val_loader, args)\n acc = test(model, test_loader, args)\n accs.append(acc)\n print('{:.4f} ~ {:.4f}'.format(np.mean(accs), np.std(accs)))\n",
"\"\"\"\nPerformance check of AutoGL model + DGL (trainer + dataset)\n\"\"\"\nimport os\nos.environ[\"AUTOGL_BACKEND\"] = \"dgl\"\nimport numpy as np\nfrom tqdm import tqdm\nimport torch\nimport torch.nn.functional as F\nfrom autogl.module.model.dgl import AutoHGT, AutoHeteroRGCN\nfrom autogl.solver.utils import set_seed\nimport numpy as np\nimport argparse\nfrom autogl.datasets import build_dataset_from_name\n\ndef get_n_params(model):\n pp=0\n for p in list(model.parameters()):\n nn=1\n for s in list(p.size()):\n nn = nn*s\n pp += nn\n return pp\n\ndef test(model, graph, idx, labels):\n model.eval()\n pred = model(graph)[idx].max(1)[1]\n acc = (pred == labels[idx]).float().mean()\n return acc.item()\n\ndef train(model, G, args, train_mask, labels):\n optimizer = torch.optim.AdamW(model.parameters())\n scheduler = torch.optim.lr_scheduler.OneCycleLR(optimizer, total_steps=args.n_epoch, max_lr = args.max_lr)\n for epoch in np.arange(args.n_epoch) + 1:\n model.train()\n logits = model(G)\n # The loss is computed only for labeled nodes.\n loss = F.cross_entropy(logits[train_mask], labels[train_mask].to(args.device))\n optimizer.zero_grad()\n loss.backward()\n torch.nn.utils.clip_grad_norm_(model.parameters(), args.clip)\n optimizer.step()\n scheduler.step()\n\nif __name__=='__main__':\n\n parser = argparse.ArgumentParser(description='hetero dgl model')\n\n parser.add_argument('--n_epoch', type=int, default=200)\n parser.add_argument('--n_inp', type=int, default=256)\n parser.add_argument('--clip', type=int, default=1.0) \n parser.add_argument('--max_lr', type=float, default=1e-3) \n parser.add_argument('--repeat', type=int, default=50)\n parser.add_argument('--device', type=str, default='cuda')\n parser.add_argument('--model', type=str, choices=['hgt', 'HeteroRGCN'], default='hgt')\n\n args = parser.parse_args()\n\n torch.manual_seed(0)\n\n dataset = build_dataset_from_name(\"hetero-acm-hgt\")\n G = dataset[0].to(args.device)\n print(G)\n\n target_field = dataset.schema[\"target_node_type\"]\n labels = G.nodes[target_field].data[\"label\"].to(args.device)\n\n train_mask = G.nodes[target_field].data[\"train_mask\"].nonzero().flatten()\n val_mask = G.nodes[target_field].data[\"val_mask\"].nonzero().flatten()\n test_mask = G.nodes[target_field].data[\"test_mask\"].nonzero().flatten()\n\n num_features = G.nodes[target_field].data[\"feat\"].size(1)\n num_classes = labels.max().item() + 1\n accs = []\n\n for seed in tqdm(range(args.repeat)):\n set_seed(seed)\n if args.model=='hgt':\n model = AutoHGT(dataset=dataset,\n num_features=num_features,\n num_classes=num_classes,\n device=args.device,\n init=False\n ).from_hyper_parameter({\n \"num_layers\": 2,\n \"hidden\": [256,256],\n \"heads\": 4,\n \"dropout\": 0.2,\n \"act\": \"gelu\",\n \"use_norm\": True,\n }).model\n elif args.model=='HeteroRGCN':\n model = AutoHeteroRGCN(dataset=dataset,\n num_features=num_features,\n num_classes=num_classes,\n device=args.device,\n init=False\n ).from_hyper_parameter({\n \"num_layers\": 2,\n \"hidden\": [256],\n \"act\": \"leaky_relu\",\n }).model\n\n model.to(args.device)\n\n train(model, G, args, train_mask, labels)\n accs.append(test(model, G, test_mask, labels))\n print('{:.4f} ~ {:.4f}'.format(np.mean(accs), np.std(accs)))\n",
"\"\"\"\nEnsemble module.\n\"\"\"\n\nimport numpy as np\n\nimport torch\nimport torch.nn.functional as F\nfrom sklearn.ensemble import GradientBoostingClassifier\nfrom sklearn.linear_model import LogisticRegression\n\nfrom .base import BaseEnsembler\nfrom . import register_ensembler\nfrom ...utils import get_logger\n\nSTACKING_LOGGER = get_logger(\"stacking\")\n\n\n@register_ensembler(\"stacking\")\nclass Stacking(BaseEnsembler):\n \"\"\"\n A stacking ensembler. Currently we support gradient boosting as the meta-algorithm.\n\n Parameters\n ----------\n meta_model : 'gbm' or 'glm' (Optional)\n Type of the stacker:\n 'gbm' : Gradient boosting model. This is the default.\n 'glm' : Generalized linear model.\n\n meta_params : a ``dict`` (Optional)\n When ``meta_model`` is specified, you can customize the parameters of the stacker.\n If this argument is not provided, the stacker will be configurated with default parameters.\n Default ``{}``.\n \"\"\"\n\n def __init__(self, meta_model=\"gbm\", meta_params={}, *args, **kwargs):\n super().__init__()\n self.model_name = meta_model.lower()\n assert self.model_name in [\n \"gbm\",\n \"glm\",\n ], \"Only support gbm and glm when ensemble!\"\n self.meta_params = meta_params\n\n def fit(\n self, predictions, label, identifiers, feval, n_classes=\"auto\", *args, **kwargs\n ):\n \"\"\"\n Fit the ensembler to the given data using Stacking method.\n\n Parameters\n ----------\n predictions : a list of np.ndarray\n Predictions of base learners (corresponding to the elements in identifiers).\n\n label : a list of int\n Class labels of instances.\n\n identifiers : a list of str\n The names of base models.\n\n feval : (a list of) autogl.module.train.evaluate\n Performance evaluation metrices.\n\n n_classes : int or str (Optional)\n The number of classes. Default as ``'auto'``, which will use maximum label.\n\n Returns\n -------\n (a list of) float\n The validation performance of the final stacker.\n \"\"\"\n\n n_classes = n_classes if not n_classes == \"auto\" else max(label) + 1\n assert n_classes > max(\n label\n ), \"Detect max label passed (%d) exceeeds\" \" n_classes given (%d)\" % (\n max(label),\n n_classes,\n )\n\n assert len(identifiers) == len(\n set(identifiers)\n ), \"Duplicate name\" \" in identifiers {} !\".format(identifiers)\n\n self.fit_identifiers = identifiers\n\n if not isinstance(feval, list):\n feval = [feval]\n\n self._re_initialize(identifiers, len(predictions))\n\n config = self.meta_params\n\n STACKING_LOGGER.debug(\"meta-model name %s\", self.model_name)\n\n if self.model_name == \"gbm\":\n meta_X = (\n torch.tensor(predictions).transpose(0, 1).flatten(start_dim=1).numpy()\n )\n meta_Y = np.array(label)\n config = {}\n model = GradientBoostingClassifier(**config)\n model.fit(meta_X, meta_Y)\n\n self.model = model\n ensemble_prediction = model.predict_proba(meta_X)\n\n elif self.model_name == \"glm\":\n meta_X = (\n torch.tensor(predictions).transpose(0, 1).flatten(start_dim=1).numpy()\n )\n meta_Y = np.array(label)\n\n config[\"multi_class\"] = \"auto\"\n config[\"solver\"] = \"lbfgs\"\n model = LogisticRegression(**config)\n model.fit(meta_X, meta_Y)\n\n self.model = model\n ensemble_prediction = model.predict_proba(meta_X)\n\n elif self.model_name == \"nn\":\n meta_X = torch.tensor(predictions).transpose(0, 1).flatten(start_dim=1)\n meta_Y = F.one_hot(\n torch.tensor(label, dtype=torch.int64), n_classes\n ).double()\n # print(meta_Y.type())\n\n n_instance, n_input = meta_X.size()\n n_learners = len(identifiers)\n\n fc = torch.nn.Linear(n_input, n_input // n_learners).double()\n\n config[\"lr\"] = 1e-1\n # config['weight_decay'] = 1e-2\n optimizer = torch.optim.SGD(fc.parameters(), **config)\n\n max_epoch = 100\n for epoch in range(max_epoch):\n optimizer.zero_grad()\n ensemble_prediction = F.normalize(fc.forward(meta_X), dim=0)\n loss = F.mse_loss(ensemble_prediction, meta_Y)\n loss.backward()\n optimizer.step()\n\n self.model = fc\n ensemble_prediction = (\n F.normalize(fc.forward(meta_X), dim=0).detach().numpy()\n )\n\n else:\n STACKING_LOGGER.error(\n \"Cannot parse stacking ensemble model name %s\", self.model_name\n )\n\n return [fx.evaluate(ensemble_prediction, label) for fx in feval]\n\n def ensemble(self, predictions, identifiers, *args, **kwargs):\n \"\"\"\n Ensemble the predictions of base models.\n\n Parameters\n ----------\n predictions : a list of ``np.ndarray``\n Predictions of base learners (corresponding to the elements in identifiers).\n identifiers : a list of ``str``\n The names of base models.\n\n Returns\n -------\n ``np.ndarray``\n The ensembled predictions.\n \"\"\"\n\n assert len(identifiers) == len(\n set(identifiers)\n ), \"Duplicate name in\" \" identifiers {} !\".format(identifiers)\n\n assert set(self.fit_identifiers) == set(\n identifiers\n ), \"Different identifiers\" \" passed in fit {} and ensemble {} !\".format(\n self.fit_identifiers, identifiers\n )\n\n # re-order predictions if needed\n if not self.fit_identifiers == identifiers:\n re_id = [\n identifiers.index(identifier) for identifier in self.fit_identifiers\n ]\n predictions = [predictions[i] for i in re_id]\n\n if self.model_name in [\"gbm\", \"glm\"]:\n pred_packed = (\n torch.tensor(predictions).transpose(0, 1).flatten(start_dim=1).numpy()\n )\n return self.model.predict_proba(pred_packed)\n\n elif self.model_name in [\"nn\"]:\n pred_packed = torch.tensor(predictions).transpose(0, 1).flatten(start_dim=1)\n return F.normalize(self.model.forward(pred_packed), dim=0).detach().numpy()\n\n def _re_initialize(self, identifiers, n_models):\n self.identifiers = identifiers\n self.model = None\n",
"\"\"\"\nPerformance check of DGL original dataset, model, trainer setting\n\nBorrowed from DGL official examples: https://github.com/dmlc/dgl/tree/master/examples/pytorch/gin\n\nTopkPool is not supported currently\n\"\"\"\n\n# from dgl.dataloading.pytorch.dataloader import GraphDataLoader\nimport pickle\nfrom dgl.dataloading import GraphDataLoader\nimport numpy as np\nfrom tqdm import tqdm\n\nimport random\n\nimport torch\nimport torch.nn as nn\nimport torch.optim as optim\n\nfrom dgl.data import GINDataset\n\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom dgl.nn.pytorch.conv import GINConv\nfrom dgl.nn.pytorch.glob import SumPooling, AvgPooling, MaxPooling\n\ndef set_seed(seed=None):\n \"\"\"\n Set seed of whole process\n \"\"\"\n if seed is None:\n seed = random.randint(0, 5000)\n\n random.seed(seed)\n np.random.seed(seed)\n torch.manual_seed(seed)\n if torch.cuda.is_available():\n torch.cuda.manual_seed_all(seed)\n torch.backends.cudnn.deterministic = True\n torch.backends.cudnn.benchmark = False\n\nclass DatasetAbstraction():\n def __init__(self, graphs, labels):\n for g in graphs:\n g.ndata['feat'] = g.ndata['attr']\n self.graphs, self.labels = [], []\n for g, l in zip(graphs, labels):\n self.graphs.append(g)\n self.labels.append(l)\n self.gclasses = max(self.labels).item() + 1\n self.graph = self.graphs\n \n def __len__(self):\n return len(self.graphs)\n \n def __getitem__(self, idx):\n if isinstance(idx, int):\n return self.graphs[idx], self.labels[idx]\n elif isinstance(idx, torch.BoolTensor):\n idx = [i for i in range(len(idx)) if idx[i]]\n elif isinstance(idx, torch.Tensor) and idx.unique()[0].sum().item() == 1:\n idx = [i for i in range(len(idx)) if idx[i]]\n return DatasetAbstraction([self.graphs[i] for i in idx], [self.labels[i] for i in idx])\n\nclass ApplyNodeFunc(nn.Module):\n \"\"\"Update the node feature hv with MLP, BN and ReLU.\"\"\"\n def __init__(self, mlp):\n super(ApplyNodeFunc, self).__init__()\n self.mlp = mlp\n self.bn = nn.BatchNorm1d(self.mlp.output_dim)\n\n def forward(self, h):\n h = self.mlp(h)\n h = self.bn(h)\n h = F.relu(h)\n return h\n\n\nclass MLP(nn.Module):\n \"\"\"MLP with linear output\"\"\"\n def __init__(self, num_layers, input_dim, hidden_dim, output_dim):\n \"\"\"MLP layers construction\n Paramters\n ---------\n num_layers: int\n The number of linear layers\n input_dim: int\n The dimensionality of input features\n hidden_dim: int\n The dimensionality of hidden units at ALL layers\n output_dim: int\n The number of classes for prediction\n \"\"\"\n super(MLP, self).__init__()\n self.linear_or_not = True # default is linear model\n self.num_layers = num_layers\n self.output_dim = output_dim\n\n if num_layers < 1:\n raise ValueError(\"number of layers should be positive!\")\n elif num_layers == 1:\n # Linear model\n self.linear = nn.Linear(input_dim, output_dim)\n else:\n # Multi-layer model\n self.linear_or_not = False\n self.linears = torch.nn.ModuleList()\n self.batch_norms = torch.nn.ModuleList()\n\n self.linears.append(nn.Linear(input_dim, hidden_dim))\n for layer in range(num_layers - 2):\n self.linears.append(nn.Linear(hidden_dim, hidden_dim))\n self.linears.append(nn.Linear(hidden_dim, output_dim))\n\n for layer in range(num_layers - 1):\n self.batch_norms.append(nn.BatchNorm1d((hidden_dim)))\n\n def forward(self, x):\n if self.linear_or_not:\n # If linear model\n return self.linear(x)\n else:\n # If MLP\n h = x\n for i in range(self.num_layers - 1):\n h = F.relu(self.batch_norms[i](self.linears[i](h)))\n return self.linears[-1](h)\n\n\nclass GIN(nn.Module):\n \"\"\"GIN model\"\"\"\n def __init__(self, num_layers, num_mlp_layers, input_dim, hidden_dim,\n output_dim, final_dropout, learn_eps, graph_pooling_type,\n neighbor_pooling_type):\n \"\"\"model parameters setting\n Paramters\n ---------\n num_layers: int\n The number of linear layers in the neural network\n num_mlp_layers: int\n The number of linear layers in mlps\n input_dim: int\n The dimensionality of input features\n hidden_dim: int\n The dimensionality of hidden units at ALL layers\n output_dim: int\n The number of classes for prediction\n final_dropout: float\n dropout ratio on the final linear layer\n learn_eps: boolean\n If True, learn epsilon to distinguish center nodes from neighbors\n If False, aggregate neighbors and center nodes altogether.\n neighbor_pooling_type: str\n how to aggregate neighbors (sum, mean, or max)\n graph_pooling_type: str\n how to aggregate entire nodes in a graph (sum, mean or max)\n \"\"\"\n super(GIN, self).__init__()\n self.num_layers = num_layers\n self.learn_eps = learn_eps\n\n # List of MLPs\n self.ginlayers = torch.nn.ModuleList()\n self.batch_norms = torch.nn.ModuleList()\n\n for layer in range(self.num_layers - 1):\n if layer == 0:\n mlp = MLP(num_mlp_layers, input_dim, hidden_dim, hidden_dim)\n else:\n mlp = MLP(num_mlp_layers, hidden_dim, hidden_dim, hidden_dim)\n\n self.ginlayers.append(\n GINConv(ApplyNodeFunc(mlp), neighbor_pooling_type, 0, self.learn_eps))\n self.batch_norms.append(nn.BatchNorm1d(hidden_dim))\n\n # Linear function for graph poolings of output of each layer\n # which maps the output of different layers into a prediction score\n self.linears_prediction = torch.nn.ModuleList()\n\n for layer in range(num_layers):\n if layer == 0:\n self.linears_prediction.append(\n nn.Linear(input_dim, output_dim))\n else:\n self.linears_prediction.append(\n nn.Linear(hidden_dim, output_dim))\n\n self.drop = nn.Dropout(final_dropout)\n\n if graph_pooling_type == 'sum':\n self.pool = SumPooling()\n elif graph_pooling_type == 'mean':\n self.pool = AvgPooling()\n elif graph_pooling_type == 'max':\n self.pool = MaxPooling()\n else:\n raise NotImplementedError\n\n def forward(self, g, h):\n # list of hidden representation at each layer (including input)\n hidden_rep = [h]\n\n for i in range(self.num_layers - 1):\n h = self.ginlayers[i](g, h)\n h = self.batch_norms[i](h)\n h = F.relu(h)\n hidden_rep.append(h)\n\n score_over_layer = 0\n\n # perform pooling over all nodes in each graph in every layer\n for i, h in enumerate(hidden_rep):\n pooled_h = self.pool(g, h)\n score_over_layer += self.drop(self.linears_prediction[i](pooled_h))\n\n return score_over_layer\n\n\ndef train(net, trainloader, validloader, optimizer, criterion, epoch, device):\n best_model = pickle.dumps(net.state_dict())\n \n best_acc = 0.\n for e in range(epoch):\n net.train()\n for graphs, labels in trainloader:\n\n labels = labels.to(device)\n graphs = graphs.to(device)\n feat = graphs.ndata.pop('attr')\n outputs = net(graphs, feat)\n\n loss = criterion(outputs, labels)\n\n # backprop\n optimizer.zero_grad()\n loss.backward()\n optimizer.step()\n\n \n gt = []\n pr = []\n net.eval()\n for graphs, labels in validloader:\n labels = labels.to(device)\n graphs = graphs.to(device)\n gt.append(labels)\n feat = graphs.ndata.pop('attr')\n outputs = net(graphs, feat)\n pr.append(outputs.argmax(1))\n gt = torch.cat(gt, dim=0)\n pr = torch.cat(pr, dim=0)\n acc = (gt == pr).float().mean().item()\n if acc > best_acc:\n best_acc = acc\n best_model = pickle.dumps(net.state_dict())\n \n net.load_state_dict(pickle.loads(best_model))\n\n return net\n\ndef eval_net(net, dataloader, device):\n net.eval()\n\n total = 0\n total_correct = 0\n\n for data in dataloader:\n graphs, labels = data\n graphs = graphs.to(device)\n labels = labels.to(device)\n feat = graphs.ndata.pop('attr')\n total += len(labels)\n outputs = net(graphs, feat)\n _, predicted = torch.max(outputs.data, 1)\n\n total_correct += (predicted == labels.data).sum().item()\n\n acc = 1.0 * total_correct / total\n\n net.train()\n\n return acc\n\n\ndef main():\n\n import argparse\n parser = argparse.ArgumentParser()\n parser.add_argument(\"--repeat\", type=int, default=10)\n parser.add_argument('--dataset', type=str, choices=['MUTAG', 'COLLAB', 'IMDBBINARY', 'IMDBMULTI', 'NCI1', 'PROTEINS', 'PTC', 'REDDITBINARY', 'REDDITMULTI5K'], default='MUTAG')\n\n args = parser.parse_args()\n\n device = torch.device('cuda')\n dataset_ = GINDataset(args.dataset, False)\n dataset = DatasetAbstraction([g[0] for g in dataset_], [g[1] for g in dataset_])\n \n # 1. split dataset [fix split]\n dataids = list(range(len(dataset)))\n random.seed(2021)\n random.shuffle(dataids)\n \n fold = int(len(dataset) * 0.1)\n train_dataset = dataset[dataids[:fold * 8]]\n val_dataset = dataset[dataids[fold * 8: fold * 9]]\n test_dataset = dataset[dataids[fold * 9: ]]\n\n trainloader = GraphDataLoader(train_dataset, batch_size=32, shuffle=True)\n valloader = GraphDataLoader(val_dataset, batch_size=32, shuffle=False)\n testloader = GraphDataLoader(test_dataset, batch_size=32, shuffle=False)\n\n accs = []\n for seed in tqdm(range(args.repeat)):\n # set up seeds, args.seed supported\n set_seed(seed)\n\n model = GIN(\n 5, 2, dataset_.dim_nfeats, 64, dataset_.gclasses, 0.5, False,\n \"sum\", \"sum\").to(device)\n\n criterion = nn.CrossEntropyLoss() # defaul reduce is true\n optimizer = optim.Adam(model.parameters(), lr=0.0001)\n\n model = train(model, trainloader, valloader, optimizer, criterion, 100, device)\n acc = eval_net(model, testloader, device)\n accs.append(acc)\n\n print('{:.2f} ~ {:.2f}'.format(np.mean(accs) * 100, np.std(accs) * 100))\n\nif __name__ == '__main__':\n main()\n"
] | [
[
"numpy.random.seed"
],
[
"torch.nn.BatchNorm1d",
"torch.Generator",
"numpy.random.seed",
"torch.nn.functional.dropout",
"torch.nn.functional.log_softmax",
"torch.manual_seed",
"torch.cuda.manual_seed",
"torch.nn.functional.nll_loss",
"torch.nn.Linear",
"numpy.std",
"numpy.mean",
"torch.nn.ReLU"
],
[
"torch.optim.lr_scheduler.OneCycleLR",
"torch.manual_seed",
"numpy.arange",
"numpy.std",
"numpy.mean"
],
[
"sklearn.linear_model.LogisticRegression",
"torch.tensor",
"torch.nn.Linear",
"torch.nn.functional.mse_loss",
"sklearn.ensemble.GradientBoostingClassifier",
"numpy.array"
],
[
"torch.nn.BatchNorm1d",
"torch.nn.Dropout",
"torch.nn.CrossEntropyLoss",
"torch.max",
"numpy.random.seed",
"torch.cat",
"torch.manual_seed",
"torch.nn.ModuleList",
"torch.nn.Linear",
"numpy.std",
"torch.nn.functional.relu",
"numpy.mean",
"torch.cuda.is_available",
"torch.cuda.manual_seed_all",
"torch.device"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
hekaplex/resnet_dl | [
"fc8d4dcc0adffbe22d01d333e6cf5db955f2f011",
"fc8d4dcc0adffbe22d01d333e6cf5db955f2f011",
"fc8d4dcc0adffbe22d01d333e6cf5db955f2f011",
"2e70203197cd79f9522d65731ee5dc0eb236b005",
"fc8d4dcc0adffbe22d01d333e6cf5db955f2f011",
"fc8d4dcc0adffbe22d01d333e6cf5db955f2f011",
"fc8d4dcc0adffbe22d01d333e6cf5db955f2f011"
] | [
"benchmarks/image_recognition/tensorflow_serving/inceptionv3/inference/fp32/image_recognition_benchmark.py",
"benchmarks/image_recognition/tensorflow_serving/resnet50v1_5/inference/fp32/util.py",
"benchmarks/image_recognition/tensorflow_serving/resnet50v1_5/inference/fp32/model_graph_to_saved_model.py",
"models/language_translation/tensorflow/transformer_lt_official/inference/fp32/official/utils/logs/metric_hook_test.py",
"models/image_segmentation/tensorflow/3d_unet/inference/fp32/unet3d/prediction.py",
"models/language_translation/tensorflow/transformer_lt_official/inference/fp32/infer_ab.py",
"models/image_recognition/tensorflow/inceptionv4/inference/datasets.py"
] | [
"#\r\n# -*- coding: utf-8 -*-\r\n#\r\n# Copyright (c) 2019 Intel Corporation\r\n#\r\n# Licensed under the Apache License, Version 2.0 (the \"License\");\r\n# you may not use this file except in compliance with the License.\r\n# You may obtain a copy of the License at\r\n#\r\n# http://www.apache.org/licenses/LICENSE-2.0\r\n#\r\n# Unless required by applicable law or agreed to in writing, software\r\n# distributed under the License is distributed on an \"AS IS\" BASIS,\r\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n# See the License for the specific language governing permissions and\r\n# limitations under the License.\r\n#\r\n# SPDX-License-Identifier: EPL-2.0\r\n#\r\n\r\n\"\"\"Send simulated image data to tensorflow_model_server loaded with ResNet50 or InceptionV3 model.\r\n\r\n\"\"\"\r\n\r\nfrom __future__ import print_function\r\n\r\nimport os\r\nimport random\r\n\r\nimport grpc\r\nimport numpy as np\r\nimport sys\r\nimport tensorflow as tf\r\nimport tensorflow.compat.v1 as tf_v1\r\nimport time\r\nfrom tensorflow_serving.apis import predict_pb2\r\nfrom tensorflow_serving.apis import prediction_service_pb2_grpc\r\n\r\nfrom util import preprocess_image, parse_example_proto\r\n\r\ntf_v1.disable_eager_execution()\r\n\r\ntf_v1.app.flags.DEFINE_string('server', 'localhost:8500', 'PredictionService host:port')\r\ntf_v1.app.flags.DEFINE_integer('batch_size', 1, 'Batch size to use')\r\ntf_v1.app.flags.DEFINE_string('data_dir', '', 'path to images in TF records format')\r\ntf_v1.app.flags.DEFINE_string('model', 'resnet50', 'Name of model (resnet50 or inceptionv3).')\r\nFLAGS = tf_v1.app.flags.FLAGS\r\n\r\n\r\ndef sample_images(image_size):\r\n \"\"\"Pull a random batch of images from FLAGS.data_dir containing TF record formatted ImageNet validation set\r\n Returns:\r\n ndarray of float32 with shape [FLAGS.batch_size, image_size, image_size, 3]\r\n \"\"\"\r\n\r\n sample_file = random.choice(os.listdir(FLAGS.data_dir))\r\n dataset = tf.data.TFRecordDataset(os.path.join(FLAGS.data_dir, sample_file))\r\n dataset = dataset.map(lambda x: parse_example_proto(x)).shuffle(True).batch(FLAGS.batch_size)\r\n iterator = dataset.make_one_shot_iterator()\r\n next_element = iterator.get_next()\r\n with tf.Session() as sess:\r\n images, labels = sess.run(next_element)\r\n images = np.array([sess.run(preprocess_image(x, FLAGS.model, image_size)) for x in images])\r\n\r\n return images\r\n\r\n\r\ndef main(_):\r\n if FLAGS.model == 'resnet50':\r\n image_size = 224\r\n elif FLAGS.model == 'inceptionv3':\r\n image_size = 299\r\n else:\r\n print('Please specify model as either resnet50 or inceptionv3.')\r\n sys.exit(-1)\r\n\r\n channel = grpc.insecure_channel(FLAGS.server)\r\n stub = prediction_service_pb2_grpc.PredictionServiceStub(channel)\r\n i = 0\r\n num_iteration = 40\r\n warm_up_iteration = 10\r\n total_time = 0\r\n for _ in range(num_iteration):\r\n i += 1\r\n if FLAGS.data_dir:\r\n image_np = sample_images(image_size)\r\n else:\r\n image_np = np.random.rand(FLAGS.batch_size, image_size, image_size, 3).astype(np.float32)\r\n if FLAGS.model == 'resnet50':\r\n # For ResNet50, rescale to [0, 256]\r\n image_np *= 256.0\r\n elif FLAGS.model == 'inceptionv3':\r\n # For InceptionV3, rescale to [-1, 1]\r\n image_np = (image_np - 0.5) * 2.0\r\n\r\n request = predict_pb2.PredictRequest()\r\n request.model_spec.name = FLAGS.model\r\n request.model_spec.signature_name = 'serving_default'\r\n request.inputs['input'].CopyFrom(\r\n tf.make_tensor_proto(image_np, shape=[FLAGS.batch_size, image_size, image_size, 3]))\r\n start_time = time.time()\r\n stub.Predict(request, 10.0) # 10 secs timeout\r\n time_consume = time.time() - start_time\r\n print('Iteration %d: %.3f sec' % (i, time_consume))\r\n if i > warm_up_iteration:\r\n total_time += time_consume\r\n\r\n time_average = total_time / (num_iteration - warm_up_iteration)\r\n print('Average time: %.3f sec' % (time_average))\r\n\r\n print('Batch size = %d' % FLAGS.batch_size)\r\n if (FLAGS.batch_size == 1):\r\n print('Latency: %.3f ms' % (time_average * 1000))\r\n\r\n print('Throughput: %.3f images/sec' % (FLAGS.batch_size / time_average))\r\n\r\n\r\nif __name__ == '__main__':\r\n tf_v1.app.run()\r\n",
"#\r\n# -*- coding: utf-8 -*-\r\n#\r\n# Copyright (c) 2019 Intel Corporation\r\n#\r\n# Licensed under the Apache License, Version 2.0 (the \"License\");\r\n# you may not use this file except in compliance with the License.\r\n# You may obtain a copy of the License at\r\n#\r\n# http://www.apache.org/licenses/LICENSE-2.0\r\n#\r\n# Unless required by applicable law or agreed to in writing, software\r\n# distributed under the License is distributed on an \"AS IS\" BASIS,\r\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n# See the License for the specific language governing permissions and\r\n# limitations under the License.\r\n#\r\n# SPDX-License-Identifier: EPL-2.0\r\n#\r\n\r\nfrom __future__ import print_function\r\n\r\nimport tensorflow.compat.v1 as tf\r\n\r\n\r\ndef preprocess_image(image_buffer, model, image_size):\r\n \"\"\"Preprocess JPEG encoded bytes to 3D float Tensor.\"\"\"\r\n\r\n # Decode the string as an RGB JPEG of unknown height and width.\r\n image = tf.image.decode_jpeg(image_buffer, channels=3)\r\n # Convert pixels to [0, 1)\r\n image = tf.image.convert_image_dtype(image, dtype=tf.float32)\r\n # Crop the central region to 87.5% of the original image.\r\n image = tf.image.central_crop(image, central_fraction=0.875)\r\n # Resize the image to image_size x image_size.\r\n image = tf.expand_dims(image, 0)\r\n image = tf.image.resize_bilinear(image, [image_size, image_size], align_corners=False)\r\n image = tf.squeeze(image, [0])\r\n if model in ['resnet50', 'resnet50v1_5']:\r\n # For ResNet50, rescale to [0, 256]\r\n image = tf.multiply(image, 256.0)\r\n elif model == 'Inceptionv3':\r\n # For InceptionV3, rescale to [-1, 1]\r\n image = tf.subtract(image, 0.5)\r\n image = tf.multiply(image, 2.0)\r\n return image\r\n\r\n\r\ndef parse_example_proto(example_serialized):\r\n # Dense features in Example proto.\r\n feature_map = {\r\n 'image/encoded': tf.FixedLenFeature([], dtype=tf.string,\r\n default_value=''),\r\n 'image/class/label': tf.FixedLenFeature([1], dtype=tf.int64,\r\n default_value=-1),\r\n }\r\n\r\n features = tf.parse_single_example(example_serialized, feature_map)\r\n label = tf.cast(features['image/class/label'], dtype=tf.int32)\r\n\r\n return features['image/encoded'], label\r\n",
"#\r\n# -*- coding: utf-8 -*-\r\n#\r\n# Copyright (c) 2019 Intel Corporation\r\n#\r\n# Licensed under the Apache License, Version 2.0 (the \"License\");\r\n# you may not use this file except in compliance with the License.\r\n# You may obtain a copy of the License at\r\n#\r\n# http://www.apache.org/licenses/LICENSE-2.0\r\n#\r\n# Unless required by applicable law or agreed to in writing, software\r\n# distributed under the License is distributed on an \"AS IS\" BASIS,\r\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n# See the License for the specific language governing permissions and\r\n# limitations under the License.\r\n#\r\n# SPDX-License-Identifier: EPL-2.0\r\n#\r\n\r\n\"\"\"Import a model graph and export a SavedModel.\r\n\r\nUsage: model_graph_to_saved_model.py [--model_version=y] import_path export_dir\r\n\"\"\"\r\n\r\nfrom __future__ import print_function\r\n\r\nimport sys\r\nimport tensorflow.compat.v1 as tf\r\nfrom tensorflow.python.tools.optimize_for_inference_lib import optimize_for_inference\r\nfrom tensorflow.python.framework import dtypes\r\n\r\nINPUTS = 'input_tensor'\r\nOUTPUTS = 'softmax_tensor'\r\n\r\ntf.app.flags.DEFINE_integer('model_version', 1, 'Version number of the model.')\r\ntf.app.flags.DEFINE_string('import_path', '', 'Model import path.')\r\ntf.app.flags.DEFINE_string('export_dir', '/tmp', 'Export directory.')\r\nFLAGS = tf.app.flags.FLAGS\r\n\r\n\r\ndef main(_):\r\n if len(sys.argv) < 2 or sys.argv[-1].startswith('-'):\r\n print('Usage: model_graph_to_saved_model.py [--model_version=y] import_path export_dir')\r\n sys.exit(-1)\r\n if FLAGS.import_path == '':\r\n print('Please specify the path to the model graph you want to convert to SavedModel format.')\r\n sys.exit(-1)\r\n if FLAGS.model_version <= 0:\r\n print('Please specify a positive value for version number.')\r\n sys.exit(-1)\r\n\r\n # Import model graph\r\n with tf.Session() as sess:\r\n graph_def = tf.GraphDef()\r\n with tf.gfile.GFile(FLAGS.import_path, 'rb') as input_file:\r\n input_graph_content = input_file.read()\r\n graph_def.ParseFromString(input_graph_content)\r\n\r\n # Apply transform optimizations\r\n output_graph = optimize_for_inference(graph_def, [INPUTS], [OUTPUTS], dtypes.float32.as_datatype_enum, False)\r\n\r\n sess.graph.as_default()\r\n tf.import_graph_def(output_graph, name='')\r\n\r\n # Build the signature_def_map.\r\n in_image = sess.graph.get_tensor_by_name('input_tensor:0')\r\n inputs = {INPUTS: tf.compat.v1.saved_model.build_tensor_info(in_image)}\r\n\r\n out_classes = sess.graph.get_tensor_by_name('softmax_tensor:0')\r\n outputs = {OUTPUTS: tf.compat.v1.saved_model.build_tensor_info(out_classes)}\r\n\r\n signature = tf.saved_model.signature_def_utils.build_signature_def(\r\n inputs=inputs,\r\n outputs=outputs,\r\n method_name=tf.saved_model.signature_constants.PREDICT_METHOD_NAME\r\n )\r\n\r\n # Save out the SavedModel\r\n print('Exporting trained model to', FLAGS.export_dir + '/' + str(FLAGS.model_version))\r\n builder = tf.saved_model.builder.SavedModelBuilder(FLAGS.export_dir + '/' + str(FLAGS.model_version))\r\n builder.add_meta_graph_and_variables(\r\n sess, [tf.saved_model.tag_constants.SERVING],\r\n signature_def_map={\r\n tf.saved_model.signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY: signature\r\n }\r\n )\r\n builder.save()\r\n\r\n print('Done!')\r\n\r\n\r\nif __name__ == '__main__':\r\n tf.app.run()\r\n",
"# Copyright 2018 The TensorFlow Authors. All Rights Reserved.\r\n#\r\n# Licensed under the Apache License, Version 2.0 (the \"License\");\r\n# you may not use this file except in compliance with the License.\r\n# You may obtain a copy of the License at\r\n#\r\n# http://www.apache.org/licenses/LICENSE-2.0\r\n#\r\n# Unless required by applicable law or agreed to in writing, software\r\n# distributed under the License is distributed on an \"AS IS\" BASIS,\r\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n# See the License for the specific language governing permissions and\r\n# limitations under the License.\r\n# ==============================================================================\r\n\"\"\"Tests for metric_hook.\"\"\"\r\n\r\nfrom __future__ import absolute_import\r\nfrom __future__ import division\r\nfrom __future__ import print_function\r\n\r\nimport tempfile\r\nimport time\r\n\r\nimport tensorflow as tf # pylint: disable=g-bad-import-order\r\nfrom tensorflow.python.training import monitored_session # pylint: disable=g-bad-import-order\r\n\r\nfrom official.utils.logs import metric_hook\r\nfrom official.utils.testing import mock_lib\r\n\r\n\r\nclass LoggingMetricHookTest(tf.test.TestCase):\r\n \"\"\"Tests for LoggingMetricHook.\"\"\"\r\n\r\n def setUp(self):\r\n super(LoggingMetricHookTest, self).setUp()\r\n\r\n self._log_dir = tempfile.mkdtemp(dir=self.get_temp_dir())\r\n self._logger = mock_lib.MockBenchmarkLogger()\r\n\r\n def tearDown(self):\r\n super(LoggingMetricHookTest, self).tearDown()\r\n tf.io.gfile.rmtree(self.get_temp_dir())\r\n\r\n def test_illegal_args(self):\r\n with self.assertRaisesRegexp(ValueError, \"nvalid every_n_iter\"):\r\n metric_hook.LoggingMetricHook(tensors=[\"t\"], every_n_iter=0)\r\n with self.assertRaisesRegexp(ValueError, \"nvalid every_n_iter\"):\r\n metric_hook.LoggingMetricHook(tensors=[\"t\"], every_n_iter=-10)\r\n with self.assertRaisesRegexp(ValueError, \"xactly one of\"):\r\n metric_hook.LoggingMetricHook(\r\n tensors=[\"t\"], every_n_iter=5, every_n_secs=5)\r\n with self.assertRaisesRegexp(ValueError, \"xactly one of\"):\r\n metric_hook.LoggingMetricHook(tensors=[\"t\"])\r\n with self.assertRaisesRegexp(ValueError, \"metric_logger\"):\r\n metric_hook.LoggingMetricHook(tensors=[\"t\"], every_n_iter=5)\r\n\r\n def test_print_at_end_only(self):\r\n with tf.Graph().as_default(), tf.compat.v1.Session() as sess:\r\n tf.compat.v1.train.get_or_create_global_step()\r\n t = tf.constant(42.0, name=\"foo\")\r\n train_op = tf.constant(3)\r\n hook = metric_hook.LoggingMetricHook(\r\n tensors=[t.name], at_end=True, metric_logger=self._logger)\r\n hook.begin()\r\n mon_sess = monitored_session._HookedSession(sess, [hook]) # pylint: disable=protected-access\r\n sess.run(tf.compat.v1.global_variables_initializer())\r\n\r\n for _ in range(3):\r\n mon_sess.run(train_op)\r\n self.assertEqual(self._logger.logged_metric, [])\r\n\r\n hook.end(sess)\r\n self.assertEqual(len(self._logger.logged_metric), 1)\r\n metric = self._logger.logged_metric[0]\r\n self.assertRegexpMatches(metric[\"name\"], \"foo\")\r\n self.assertEqual(metric[\"value\"], 42.0)\r\n self.assertEqual(metric[\"unit\"], None)\r\n self.assertEqual(metric[\"global_step\"], 0)\r\n\r\n def test_global_step_not_found(self):\r\n with tf.Graph().as_default():\r\n t = tf.constant(42.0, name=\"foo\")\r\n hook = metric_hook.LoggingMetricHook(\r\n tensors=[t.name], at_end=True, metric_logger=self._logger)\r\n\r\n with self.assertRaisesRegexp(\r\n RuntimeError, \"should be created to use LoggingMetricHook.\"):\r\n hook.begin()\r\n\r\n def test_log_tensors(self):\r\n with tf.Graph().as_default(), tf.compat.v1.Session() as sess:\r\n tf.compat.v1.train.get_or_create_global_step()\r\n t1 = tf.constant(42.0, name=\"foo\")\r\n t2 = tf.constant(43.0, name=\"bar\")\r\n train_op = tf.constant(3)\r\n hook = metric_hook.LoggingMetricHook(\r\n tensors=[t1, t2], at_end=True, metric_logger=self._logger)\r\n hook.begin()\r\n mon_sess = monitored_session._HookedSession(sess, [hook]) # pylint: disable=protected-access\r\n sess.run(tf.compat.v1.global_variables_initializer())\r\n\r\n for _ in range(3):\r\n mon_sess.run(train_op)\r\n self.assertEqual(self._logger.logged_metric, [])\r\n\r\n hook.end(sess)\r\n self.assertEqual(len(self._logger.logged_metric), 2)\r\n metric1 = self._logger.logged_metric[0]\r\n self.assertRegexpMatches(str(metric1[\"name\"]), \"foo\")\r\n self.assertEqual(metric1[\"value\"], 42.0)\r\n self.assertEqual(metric1[\"unit\"], None)\r\n self.assertEqual(metric1[\"global_step\"], 0)\r\n\r\n metric2 = self._logger.logged_metric[1]\r\n self.assertRegexpMatches(str(metric2[\"name\"]), \"bar\")\r\n self.assertEqual(metric2[\"value\"], 43.0)\r\n self.assertEqual(metric2[\"unit\"], None)\r\n self.assertEqual(metric2[\"global_step\"], 0)\r\n\r\n def _validate_print_every_n_steps(self, sess, at_end):\r\n t = tf.constant(42.0, name=\"foo\")\r\n\r\n train_op = tf.constant(3)\r\n hook = metric_hook.LoggingMetricHook(\r\n tensors=[t.name], every_n_iter=10, at_end=at_end,\r\n metric_logger=self._logger)\r\n hook.begin()\r\n mon_sess = monitored_session._HookedSession(sess, [hook]) # pylint: disable=protected-access\r\n sess.run(tf.compat.v1.global_variables_initializer())\r\n mon_sess.run(train_op)\r\n self.assertRegexpMatches(str(self._logger.logged_metric), t.name)\r\n for _ in range(3):\r\n self._logger.logged_metric = []\r\n for _ in range(9):\r\n mon_sess.run(train_op)\r\n # assertNotRegexpMatches is not supported by python 3.1 and later\r\n self.assertEqual(str(self._logger.logged_metric).find(t.name), -1)\r\n mon_sess.run(train_op)\r\n self.assertRegexpMatches(str(self._logger.logged_metric), t.name)\r\n\r\n # Add additional run to verify proper reset when called multiple times.\r\n self._logger.logged_metric = []\r\n mon_sess.run(train_op)\r\n # assertNotRegexpMatches is not supported by python 3.1 and later\r\n self.assertEqual(str(self._logger.logged_metric).find(t.name), -1)\r\n\r\n self._logger.logged_metric = []\r\n hook.end(sess)\r\n if at_end:\r\n self.assertRegexpMatches(str(self._logger.logged_metric), t.name)\r\n else:\r\n # assertNotRegexpMatches is not supported by python 3.1 and later\r\n self.assertEqual(str(self._logger.logged_metric).find(t.name), -1)\r\n\r\n def test_print_every_n_steps(self):\r\n with tf.Graph().as_default(), tf.compat.v1.Session() as sess:\r\n tf.compat.v1.train.get_or_create_global_step()\r\n self._validate_print_every_n_steps(sess, at_end=False)\r\n # Verify proper reset.\r\n self._validate_print_every_n_steps(sess, at_end=False)\r\n\r\n def test_print_every_n_steps_and_end(self):\r\n with tf.Graph().as_default(), tf.compat.v1.Session() as sess:\r\n tf.compat.v1.train.get_or_create_global_step()\r\n self._validate_print_every_n_steps(sess, at_end=True)\r\n # Verify proper reset.\r\n self._validate_print_every_n_steps(sess, at_end=True)\r\n\r\n def _validate_print_every_n_secs(self, sess, at_end):\r\n t = tf.constant(42.0, name=\"foo\")\r\n train_op = tf.constant(3)\r\n\r\n hook = metric_hook.LoggingMetricHook(\r\n tensors=[t.name], every_n_secs=1.0, at_end=at_end,\r\n metric_logger=self._logger)\r\n hook.begin()\r\n mon_sess = monitored_session._HookedSession(sess, [hook]) # pylint: disable=protected-access\r\n sess.run(tf.compat.v1.global_variables_initializer())\r\n\r\n mon_sess.run(train_op)\r\n self.assertRegexpMatches(str(self._logger.logged_metric), t.name)\r\n\r\n # assertNotRegexpMatches is not supported by python 3.1 and later\r\n self._logger.logged_metric = []\r\n mon_sess.run(train_op)\r\n self.assertEqual(str(self._logger.logged_metric).find(t.name), -1)\r\n time.sleep(1.0)\r\n\r\n self._logger.logged_metric = []\r\n mon_sess.run(train_op)\r\n self.assertRegexpMatches(str(self._logger.logged_metric), t.name)\r\n\r\n self._logger.logged_metric = []\r\n hook.end(sess)\r\n if at_end:\r\n self.assertRegexpMatches(str(self._logger.logged_metric), t.name)\r\n else:\r\n # assertNotRegexpMatches is not supported by python 3.1 and later\r\n self.assertEqual(str(self._logger.logged_metric).find(t.name), -1)\r\n\r\n def test_print_every_n_secs(self):\r\n with tf.Graph().as_default(), tf.compat.v1.Session() as sess:\r\n tf.compat.v1.train.get_or_create_global_step()\r\n self._validate_print_every_n_secs(sess, at_end=False)\r\n # Verify proper reset.\r\n self._validate_print_every_n_secs(sess, at_end=False)\r\n\r\n def test_print_every_n_secs_and_end(self):\r\n with tf.Graph().as_default(), tf.compat.v1.Session() as sess:\r\n tf.compat.v1.train.get_or_create_global_step()\r\n self._validate_print_every_n_secs(sess, at_end=True)\r\n # Verify proper reset.\r\n self._validate_print_every_n_secs(sess, at_end=True)\r\n\r\n\r\nif __name__ == \"__main__\":\r\n tf.test.main()\r\n",
"import os\r\n\r\nimport nibabel as nib\r\nimport numpy as np\r\nimport tables\r\nimport time\r\nimport math\r\n\r\nfrom .training import load_old_model\r\nfrom .utils import pickle_load\r\nfrom .utils.patches import reconstruct_from_patches, get_patch_from_3d_data, compute_patch_indices\r\nfrom .augment import permute_data, generate_permutation_keys, reverse_permute_data\r\n\r\n\r\ndef patch_wise_prediction(model, data, overlap=0, batch_size=1, permute=False):\r\n \"\"\"\r\n :param batch_size:\r\n :param model:\r\n :param data:\r\n :param overlap:\r\n :return:\r\n \"\"\"\r\n patch_shape = tuple([int(dim) for dim in model.input.shape[-3:]])\r\n predictions = list()\r\n indices = compute_patch_indices(data.shape[-3:], patch_size=patch_shape, overlap=overlap)\r\n batch = list()\r\n i = 0\r\n\r\n total_model_time = 0\r\n while i < len(indices):\r\n while len(batch) < batch_size:\r\n patch = get_patch_from_3d_data(data[0], patch_shape=patch_shape, patch_index=indices[i])\r\n batch.append(patch)\r\n i += 1\r\n \r\n # print('batch.shape: {}'.format(np.asarray(batch).shape))\r\n start_time = time.time()\r\n prediction = predict(model, np.asarray(batch), permute=permute)\r\n end_time = time.time()\r\n total_model_time += (end_time - start_time)\r\n \r\n batch = list()\r\n # print('prediction.shape: {}'.format(prediction.shape))\r\n for predicted_patch in prediction:\r\n # print('predicted_patch.shape: {}'.format(predicted_patch.shape))\r\n predictions.append(predicted_patch)\r\n\r\n #print('model evaluation time: {} ms'.format(total_model_time * 1000))\r\n # print('predictions.length: {}'.format(len(predictions)))\r\n # print('predictions[0].shape: {}'.format(predictions[0].shape))\r\n output_shape = [int(model.output.shape[1])] + list(data.shape[-3:])\r\n return reconstruct_from_patches(predictions, patch_indices=indices, data_shape=output_shape)\r\n\r\n\r\ndef get_prediction_labels(prediction, threshold=0.5, labels=None):\r\n n_samples = prediction.shape[0]\r\n label_arrays = []\r\n for sample_number in range(n_samples):\r\n label_data = np.argmax(prediction[sample_number], axis=0) + 1\r\n label_data[np.max(prediction[sample_number], axis=0) < threshold] = 0\r\n if labels:\r\n for value in np.unique(label_data).tolist()[1:]:\r\n label_data[label_data == value] = labels[value - 1]\r\n label_arrays.append(np.array(label_data, dtype=np.uint8))\r\n return label_arrays\r\n\r\n\r\ndef get_test_indices(testing_file):\r\n return pickle_load(testing_file)\r\n\r\n\r\ndef predict_from_data_file(model, open_data_file, index):\r\n return model.predict(open_data_file.root.data[index])\r\n\r\n\r\ndef predict_and_get_image(model, data, affine):\r\n return nib.Nifti1Image(model.predict(data)[0, 0], affine)\r\n\r\n\r\ndef predict_from_data_file_and_get_image(model, open_data_file, index):\r\n return predict_and_get_image(model, open_data_file.root.data[index], open_data_file.root.affine)\r\n\r\n\r\ndef predict_from_data_file_and_write_image(model, open_data_file, index, out_file):\r\n image = predict_from_data_file_and_get_image(model, open_data_file, index)\r\n image.to_filename(out_file)\r\n\r\n\r\ndef prediction_to_image(prediction, affine, label_map=False, threshold=0.5, labels=None):\r\n if prediction.shape[1] == 1:\r\n data = prediction[0, 0]\r\n if label_map:\r\n label_map_data = np.zeros(prediction[0, 0].shape, np.int8)\r\n if labels:\r\n label = labels[0]\r\n else:\r\n label = 1\r\n label_map_data[data > threshold] = label\r\n data = label_map_data\r\n elif prediction.shape[1] > 1:\r\n if label_map:\r\n label_map_data = get_prediction_labels(prediction, threshold=threshold, labels=labels)\r\n data = label_map_data[0]\r\n else:\r\n return multi_class_prediction(prediction, affine)\r\n else:\r\n raise RuntimeError(\"Invalid prediction array shape: {0}\".format(prediction.shape))\r\n return nib.Nifti1Image(data, affine)\r\n\r\n\r\ndef multi_class_prediction(prediction, affine):\r\n prediction_images = []\r\n for i in range(prediction.shape[1]):\r\n prediction_images.append(nib.Nifti1Image(prediction[0, i], affine))\r\n return prediction_images\r\n\r\n\r\ndef run_validation_case(data_index, output_dir, model, data_file, training_modalities,\r\n output_label_map=False, threshold=0.5, labels=None, overlap=16, permute=False):\r\n \"\"\"\r\n Runs a test case and writes predicted images to file.\r\n :param data_index: Index from of the list of test cases to get an image prediction from.\r\n :param output_dir: Where to write prediction images.\r\n :param output_label_map: If True, will write out a single image with one or more labels. Otherwise outputs\r\n the (sigmoid) prediction values from the model.\r\n :param threshold: If output_label_map is set to True, this threshold defines the value above which is \r\n considered a positive result and will be assigned a label. \r\n :param labels:\r\n :param training_modalities:\r\n :param data_file:\r\n :param model:\r\n \"\"\"\r\n if not os.path.exists(output_dir):\r\n os.makedirs(output_dir)\r\n\r\n affine = data_file.root.affine[data_index]\r\n test_data = np.asarray([data_file.root.data[data_index]])\r\n # print('test_data.shape: {}'.format(test_data.shape))\r\n for i, modality in enumerate(training_modalities):\r\n image = nib.Nifti1Image(test_data[0, i], affine)\r\n image.to_filename(os.path.join(output_dir, \"data_{0}.nii.gz\".format(modality)))\r\n\r\n test_truth = nib.Nifti1Image(data_file.root.truth[data_index][0], affine)\r\n test_truth.to_filename(os.path.join(output_dir, \"truth.nii.gz\"))\r\n\r\n patch_shape = tuple([int(dim) for dim in model.input.shape[-3:]])\r\n if patch_shape == test_data.shape[-3:]:\r\n # print('this branch !!!!!!!!!!!!!')\r\n prediction = predict(model, test_data, permute=permute)\r\n else:\r\n prediction = patch_wise_prediction(model=model, data=test_data, overlap=overlap, permute=permute)[np.newaxis]\r\n # print('!!!!!prediction.shape: {}'.format(prediction.shape))\r\n prediction_image = prediction_to_image(prediction, affine, label_map=output_label_map, threshold=threshold,\r\n labels=labels)\r\n if isinstance(prediction_image, list):\r\n for i, image in enumerate(prediction_image):\r\n image.to_filename(os.path.join(output_dir, \"prediction_{0}.nii.gz\".format(i + 1)))\r\n else:\r\n prediction_image.to_filename(os.path.join(output_dir, \"prediction.nii.gz\"))\r\n\r\n\r\ndef run_validation_cases(validation_keys_file, model_file, training_modalities, labels, hdf5_file,\r\n output_label_map=False, output_dir=\".\", threshold=0.5, overlap=16, permute=False, warmup=10, report_interval=1, batch_size=1, n_batch=10):\r\n validation_indices = pickle_load(validation_keys_file)\r\n model = load_old_model(model_file)\r\n data_file = tables.open_file(hdf5_file, \"r\")\r\n\r\n elapsed_time = 0\r\n elapsed_step = 0\r\n\r\n for index in validation_indices:\r\n start = time.time() \r\n if 'subject_ids' in data_file.root:\r\n case_directory = os.path.join(output_dir, data_file.root.subject_ids[index].decode('utf-8'))\r\n else:\r\n case_directory = os.path.join(output_dir, \"validation_case_{}\".format(index))\r\n run_validation_case(data_index=index, output_dir=case_directory, model=model, data_file=data_file,\r\n training_modalities=training_modalities, output_label_map=output_label_map, labels=labels,\r\n threshold=threshold, overlap=overlap, permute=permute)\r\n end = time.time()\r\n\r\n if index >= warmup:\r\n elapsed_time += (end - start)\r\n elapsed_step += 1\r\n\r\n if elapsed_step + warmup == n_batch:\r\n # print('performance = {} img/s, count for {} steps and batch size is {}'.format(elapsed_step * batch_size / elapsed_time, elapsed_step, batch_size), flush=True)\r\n # print('latency = {} ms'.format(1000 * elapsed_time / elapsed_step), flush=True)\r\n print('Time spent per BATCH: %.4f ms' % (1000.0 * elapsed_time / elapsed_step))\r\n print('Total samples/sec: %.4f samples/s' % (elapsed_step * batch_size / elapsed_time))\r\n break\r\n\r\n data_file.close()\r\n\r\n\r\ndef predict(model, data, permute=False):\r\n if permute:\r\n predictions = list()\r\n for batch_index in range(data.shape[0]):\r\n predictions.append(predict_with_permutations(model, data[batch_index]))\r\n return np.asarray(predictions)\r\n else:\r\n return model.predict(data)\r\n\r\n\r\ndef predict_with_permutations(model, data):\r\n predictions = list()\r\n for permutation_key in generate_permutation_keys():\r\n temp_data = permute_data(data, permutation_key)[np.newaxis]\r\n predictions.append(reverse_permute_data(model.predict(temp_data)[0], permutation_key))\r\n return np.mean(predictions, axis=0)\r\n\r\ndef run_large_batch_validation_cases(validation_keys_file, model_file, training_modalities, labels, hdf5_file,\r\n output_label_map=False, output_dir=\".\", threshold=0.5, overlap=16, permute=False, batch_size=1, warmup=1, report_interval=1, n_batch=10):\r\n validation_indices = pickle_load(validation_keys_file)\r\n model = load_old_model(model_file)\r\n data_file = tables.open_file(hdf5_file, \"r\")\r\n\r\n \r\n\r\n #\r\n # Initilize validation case directory:\r\n #\r\n # for index in validation_indices:\r\n # if 'subject_ids' in data_file.root:\r\n # case_directory = os.path.join(output_dir, data_file.root.subject_ids[index].decode('utf-8'))\r\n # else:\r\n # case_directory = os.path.join(output_dir, \"validation_case_{}\".format(index))\r\n\r\n # if not os.path.exists(case_directory):\r\n # os.makedirs(case_directory)\r\n\r\n # # Write image to validation case directory:\r\n # affine = data_file.root.affine[index]\r\n # affine_dict[index] = affine\r\n # test_data = np.asarray([data_file.root.data[index]])\r\n # for i, modality in enumerate(training_modalities):\r\n # image = nib.Nifti1Image(test_data[0, i], affine)\r\n # image.to_filename(os.path.join(case_directory, \"data_{0}.nii.gz\".format(modality)))\r\n\r\n # test_truth = nib.Nifti1Image(data_file.root.truth[index][0], affine)\r\n # test_truth.to_filename(os.path.join(case_directory, \"truth.nii.gz\"))\r\n\r\n step = math.ceil(len(validation_indices) / batch_size)\r\n \r\n elapsed_time = 0\r\n elapsed_step = 0\r\n\r\n for i in range(step):\r\n print('iteration {} ...'.format(i))\r\n\r\n start_time = time.time()\r\n\r\n test_data_index = validation_indices[i * batch_size: (i + 1) * batch_size]\r\n test_data = []\r\n\r\n affine_dict = {}\r\n \r\n\r\n for tdi in test_data_index:\r\n #\r\n # Initilize validation case directory:\r\n #\r\n if 'subject_ids' in data_file.root:\r\n case_directory = os.path.join(output_dir, data_file.root.subject_ids[tdi].decode('utf-8'))\r\n else:\r\n case_directory = os.path.join(output_dir, \"validation_case_{}\".format(tdi))\r\n\r\n if not os.path.exists(case_directory):\r\n os.makedirs(case_directory)\r\n\r\n # Write image to validation case directory:\r\n affine = data_file.root.affine[tdi]\r\n affine_dict[tdi] = affine\r\n test_data_elem = np.asarray([data_file.root.data[tdi]])\r\n for index, modality in enumerate(training_modalities):\r\n image = nib.Nifti1Image(test_data_elem[0, index], affine)\r\n image.to_filename(os.path.join(case_directory, \"data_{0}.nii.gz\".format(modality)))\r\n\r\n test_truth = nib.Nifti1Image(data_file.root.truth[tdi][0], affine)\r\n test_truth.to_filename(os.path.join(case_directory, \"truth.nii.gz\"))\r\n\r\n test_data.append(data_file.root.data[tdi])\r\n\r\n test_data = np.asarray([test_data])\r\n # print('test_data.shape: {}'.format(test_data.shape))\r\n\r\n patch_shape = tuple([int(dim) for dim in model.input.shape[-3:]])\r\n if patch_shape == test_data.shape[-3:]:\r\n # prediction = predict(model, test_data, permute=permute)\r\n if test_data.ndim is 6:\r\n assert test_data.shape[0] is 1\r\n test_data = test_data[0]\r\n predictions = predict(model, test_data, permute=permute)\r\n else:\r\n predictions = []\r\n indices = compute_patch_indices(test_data.shape[-3:], patch_size=patch_shape, overlap=overlap)\r\n batch = []\r\n\r\n # print('len(indices): {}'.format(len(indices)))\r\n \r\n for b in range(test_data.shape[1]):\r\n indices_index = 0\r\n while indices_index < len(indices):\r\n patch = get_patch_from_3d_data(test_data[0][b], patch_shape=patch_shape, patch_index=indices[indices_index])\r\n batch.append(patch)\r\n indices_index += 1\r\n\r\n pred_start = time.time()\r\n prediction = predict(model, np.asarray(batch), permute=permute)\r\n pred_stop = time.time()\r\n print('pred time: {} ms'.format((pred_stop - pred_start) * 1000))\r\n # print('prediction.shape: {}'.format(prediction.shape))\r\n # batch = []\r\n ps = prediction.shape\r\n assert ps[0] % test_data.shape[1] == 0\r\n prediction = np.reshape(prediction, (test_data.shape[1], int(ps[0] / test_data.shape[1]), ps[1], ps[2], ps[3], ps[4]))\r\n\r\n for batch_index, batch_prediction in enumerate(prediction):\r\n # in case of the list out of index situation\r\n if len(predictions) < (batch_index + 1):\r\n assert batch_index is len(predictions)\r\n predictions.append([])\r\n\r\n for patch_index, predicted_patch in enumerate(batch_prediction):\r\n predictions[batch_index].append(predicted_patch)\r\n\r\n output_shape = [int(model.output.shape[1])] + list(test_data.shape[-3:])\r\n\r\n #\r\n # Re-construction\r\n #\r\n reconstructed_predictions = []\r\n for pred in predictions:\r\n # print('before reconstruction: {}, {}'.format(pred[0].shape, len(pred)))\r\n reconstructed_prediction = reconstruct_from_patches(pred, patch_indices=indices, data_shape=output_shape)[np.newaxis]\r\n # print('reconstructed_prediction.shape: {}'.format(reconstructed_prediction.shape))\r\n reconstructed_predictions.append(reconstructed_prediction)\r\n\r\n #\r\n # Predict to image\r\n #\r\n prediction_images = []\r\n for pred_index, pred in enumerate(reconstructed_predictions):\r\n rec_pred_index = test_data_index[pred_index]\r\n # print('pred_index: {}'.format(rec_pred_index))\r\n\r\n affine = affine_dict[rec_pred_index]\r\n\r\n # print('pred.shape: {}'.format(pred.shape))\r\n prediction_image = prediction_to_image(pred, affine, label_map=output_label_map, threshold=threshold,\r\n labels=labels)\r\n\r\n prediction_images.append(prediction_images)\r\n\r\n if 'subject_ids' in data_file.root:\r\n case_directory = os.path.join(output_dir, data_file.root.subject_ids[rec_pred_index].decode('utf-8'))\r\n else:\r\n case_directory = os.path.join(output_dir, \"validation_case_{}\".format(rec_pred_index)) \r\n if isinstance(prediction_image, list):\r\n for image_index, image in enumerate(prediction_image):\r\n image.to_filename(os.path.join(case_directory, \"prediction_{0}.nii.gz\".format(image_index + 1)))\r\n else:\r\n prediction_image.to_filename(os.path.join(case_directory, \"prediction.nii.gz\"))\r\n\r\n stop_time = time.time()\r\n\r\n if i >= warmup:\r\n elapsed_time += (stop_time - start_time)\r\n elapsed_step += 1\r\n\r\n if elapsed_step + warmup == n_batch:\r\n print('performance = {} img/s, count for {} steps and batch size is {}'.format(elapsed_step * batch_size / elapsed_time, elapsed_step, batch_size))\r\n print('latency = {} ms'.format(1000 * elapsed_time / elapsed_step))\r\n elapsed_time = 0\r\n elapsed_step = 0\r\n break\r\n\r\n\r\n\r\n\r\n data_file.close()\r\n \r\n",
"#\r\n# -*- coding: utf-8 -*-\r\n#\r\n# Copyright (c) 2019 Intel Corporation\r\n#\r\n# Licensed under the Apache License, Version 2.0 (the \"License\");\r\n# you may not use this file except in compliance with the License.\r\n# You may obtain a copy of the License at\r\n#\r\n# http://www.apache.org/licenses/LICENSE-2.0\r\n#\r\n# Unless required by applicable law or agreed to in writing, software\r\n# distributed under the License is distributed on an \"AS IS\" BASIS,\r\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n# See the License for the specific language governing permissions and\r\n# limitations under the License.\r\n#\r\n#\r\n\r\nimport tensorflow as tf\r\nfrom tensorflow.python.framework import ops\r\nfrom google.protobuf import text_format\r\n\r\nfrom tensorflow.core.framework import graph_pb2\r\nimport numpy as np\r\nfrom utils import tokenizer\r\nfrom utils.tokenizer import Subtokenizer\r\n\r\nfrom tensorflow.python.platform import flags as flags_lib\r\nfrom tensorflow.python.platform import app\r\nimport time\r\nimport pandas as pd\r\nfrom timeit import default_timer as timer\r\n\r\nflags = flags_lib\r\nFLAGS = flags.FLAGS\r\n\r\nflags.DEFINE_string(\"in_graph\", 'fp32_graphdef.pb',\r\n \"\"\"TensorFlow 'GraphDef' file for FP32 to load.\"\"\")\r\nflags.DEFINE_bool(\"input_binary\", True,\r\n \"\"\"Whether the input files are in binary format.\"\"\")\r\nflags.DEFINE_string(\r\n \"vocab_file\", \"vocab.ende.32768\",\r\n \"Path to subtoken vocabulary file.\")\r\nflags.DEFINE_string(\r\n \"file\", \"newstest2014.en\",\r\n \"\"\"File saved to an output file.\"\"\")\r\nflags.DEFINE_string(\r\n \"file_out\", \"translate.txt\",\r\n \"\"\"If --file flag is specified, save translation to this file.\"\"\")\r\nflags.DEFINE_integer(\"batch_size\", 64,\r\n \"\"\"The validation batch size\"\"\")\r\nflags.DEFINE_integer(\"num_inter\", 1,\r\n \"\"\"Number of sentences to exclude from validation file.\"\"\")\r\nflags.DEFINE_integer(\"num_intra\", 40,\r\n \"\"\"Number of sentences to exclude from validation file.\"\"\")\r\nflags.DEFINE_integer(\"num_batches\", 0,\r\n \"\"\"Number of batches of sentences to run inference for\"\"\")\r\nflags.DEFINE_bool(\"sort_input_sentences\", None,\r\n \"\"\"Sort the sequence of sentences in validation file. \r\n Sorting improves batch processing time\"\"\")\r\n\r\ndef input_generator_ts():\r\n \"\"\"Read and sort lines based on token count from the file\r\n sorted by decreasing length based on token sorting.\r\n Args:\r\n filename: String name of file to read inputs from.\r\n Returns:\r\n Sorted list of inputs, and dictionary mapping original index->sorted index\r\n of each element.\r\n \"\"\"\r\n with tf.io.gfile.GFile(FLAGS.file) as f:\r\n records = f.read().split(\"\\n\")\r\n inputs = [record.strip() for record in records]\r\n if not inputs[-1]:\r\n inputs.pop()\r\n\r\n subtokenizer = Subtokenizer(FLAGS.vocab_file)\r\n\r\n batch = []\r\n token_lens=[]\r\n for i, line in enumerate(inputs):\r\n enc = subtokenizer.encode(line, add_eos=True)\r\n token_lens.append((i, len(enc)))\r\n\r\n sorted_by_token_input_lens = sorted(token_lens, key=lambda x: x[1], reverse=True)\r\n\r\n #print('sorted_by_token_input_lens:{}'.format(sorted_by_token_input_lens))\r\n\r\n sorted_inputs = [None] * len(sorted_by_token_input_lens)\r\n sorted_keys = [0] * len(sorted_by_token_input_lens)\r\n\r\n for i, (index, _) in enumerate(sorted_by_token_input_lens):\r\n sorted_inputs[i] = inputs[index]\r\n sorted_keys[index] = i\r\n enc=subtokenizer.encode(sorted_inputs[i], add_eos=True)\r\n batch.append(enc)\r\n\r\n return batch,sorted_keys\r\n\r\ndef input_generator_ws():\r\n \"\"\"Read and sort lines from the file sorted by decreasing length based on word counts.\r\n Args:\r\n filename: String name of file to read inputs from.\r\n Returns:\r\n Sorted list of inputs, and dictionary mapping original index->sorted index\r\n of each element.\r\n \"\"\"\r\n with tf.io.gfile.GFile(FLAGS.file) as f:\r\n records = f.read().split(\"\\n\")\r\n inputs = [record.strip() for record in records]\r\n if not inputs[-1]:\r\n inputs.pop()\r\n\r\n batch = []\r\n\r\n subtokenizer = Subtokenizer(FLAGS.vocab_file)\r\n\r\n input_lens = [(i, len(line.split())) for i, line in enumerate(inputs)]\r\n sorted_input_lens = sorted(input_lens, key=lambda x: x[1], reverse=True)\r\n\r\n sorted_inputs = [None] * len(sorted_input_lens)\r\n sorted_keys = [0] * len(sorted_input_lens)\r\n for i, (index, _) in enumerate(sorted_input_lens):\r\n sorted_inputs[i] = inputs[index]\r\n sorted_keys[index] = i\r\n enc=subtokenizer.encode(sorted_inputs[i], add_eos=True)\r\n batch.append(enc)\r\n return batch,sorted_keys\r\n\r\ndef _trim_and_decode(ids):\r\n \"\"\"Trim EOS and PAD tokens from ids, and decode to return a string.\"\"\"\r\n subtokenizer = Subtokenizer(FLAGS.vocab_file)\r\n try:\r\n index = list(ids).index(tokenizer.EOS_ID)\r\n return subtokenizer.decode(ids[:index])\r\n except ValueError: # No EOS found in sequence\r\n return subtokenizer.decode(ids)\r\n\r\ndef main(unused_args):\r\n\r\n graph_def = graph_pb2.GraphDef()\r\n graph_file=FLAGS.in_graph\r\n\r\n\r\n start=timer()\r\n with open(graph_file, \"rb\") as f:\r\n if FLAGS.input_binary:\r\n graph_def.ParseFromString(f.read())\r\n else:\r\n text_format.Merge(f.read(), graph_def)\r\n end=timer()\r\n graph_parse_time = end-start\r\n print(\"Graph parsed in %f s\" % (end-start))\r\n\r\n start=timer()\r\n with tf.Graph().as_default() as graph:\r\n y = tf.import_graph_def(graph_def,return_elements=[\"model/Transformer/strided_slice_19:0\"], name='')\r\n end=timer()\r\n print(\"import_graph_def took %fs\" % (end-start))\r\n\r\n start=timer()\r\n batches,sorted_keys = input_generator_ts()\r\n end=timer()\r\n sort_time = end-start\r\n print(\"tokenizer took %f s\" % (sort_time))\r\n\r\n DATASET_SIZE=len(batches)\r\n print(\"Translating {} sentences from English to German.\".format(DATASET_SIZE))\r\n\r\n session_config = tf.compat.v1.ConfigProto(\r\n inter_op_parallelism_threads=FLAGS.num_inter,\r\n intra_op_parallelism_threads=FLAGS.num_intra)\r\n\r\n with tf.compat.v1.Session(config=session_config, graph=graph) as sess:\r\n\r\n run_options = tf.compat.v1.RunOptions(trace_level=tf.compat.v1.RunOptions.FULL_TRACE)\r\n run_metadata = tf.compat.v1.RunMetadata()\r\n\r\n translations = []\r\n\r\n batch = []\r\n batch_num=0\r\n line_count=0\r\n\r\n total_start_time = time.time()\r\n inference_time = 0.0\r\n\r\n for i, line in enumerate(batches): \r\n batch.append(line)\r\n duration = 0.0\r\n if i % FLAGS.batch_size == 0:\r\n line_count += 1\r\n batch_num = (i // FLAGS.batch_size) + 1\r\n start_time = time.time()\r\n dec_tensor = sess.run(y, feed_dict={'input_tensor:0': pd.DataFrame(batch).fillna(0).values.astype(np.int32)})\r\n duration = time.time() - start_time\r\n translations.append(dec_tensor)\r\n #print('Batch inferencing time:%s for batch size:%d and batch:%d' % (duration, FLAGS.batch_size, batch_num))\r\n batch = []\r\n elif i % (len(batches) - 1) == 0:\r\n batch_num = (i // FLAGS.batch_size) + 1\r\n start_time = time.time()\r\n dec_tensor = sess.run(y, feed_dict={'input_tensor:0': pd.DataFrame(batch).fillna(0).values.astype(np.int32)})\r\n duration = time.time() - start_time\r\n translations.append(dec_tensor)\r\n #print('Batch inferencing time:%s for batch size:%d and batch:%d' % (duration, FLAGS.batch_size, batch_num))\r\n batch = []\r\n inference_time += duration\r\n\r\n inference_time += graph_parse_time\r\n inference_time += sort_time\r\n print('Total inferencing time:%s' %(inference_time))\r\n print('Throughput:{} sentences/second'.format((DATASET_SIZE)/inference_time))\r\n\r\n translation_count = 0\r\n\r\n decoded_translations=[]\r\n for i,tr in enumerate(translations):\r\n for j,itr in enumerate(tr):\r\n for k,otr in enumerate(itr):\r\n translation_count += 1\r\n decoded_translations.append(_trim_and_decode(otr))\r\n\r\n print('Total number of sentences translated:%d' % (translation_count))\r\n\r\n with tf.io.gfile.GFile(FLAGS.file_out, \"w\") as f:\r\n for i in sorted_keys:\r\n f.write(\"%s\\n\" % decoded_translations[i])\r\n\r\nif __name__ == \"__main__\":\r\n app.run()\r\n",
"#\r\n# -*- coding: utf-8 -*-\r\n#\r\n# Copyright (c) 2018 Intel Corporation\r\n#\r\n# Licensed under the Apache License, Version 2.0 (the \"License\");\r\n# you may not use this file except in compliance with the License.\r\n# You may obtain a copy of the License at\r\n#\r\n# http://www.apache.org/licenses/LICENSE-2.0\r\n#\r\n# Unless required by applicable law or agreed to in writing, software\r\n# distributed under the License is distributed on an \"AS IS\" BASIS,\r\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n# See the License for the specific language governing permissions and\r\n# limitations under the License.\r\n#\r\n\r\n#\r\n# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\r\n#\r\n# Licensed under the Apache License, Version 2.0 (the \"License\");\r\n# you may not use this file except in compliance with the License.\r\n# You may obtain a copy of the License at\r\n#\r\n# http://www.apache.org/licenses/LICENSE-2.0\r\n#\r\n# Unless required by applicable law or agreed to in writing, software\r\n# distributed under the License is distributed on an \"AS IS\" BASIS,\r\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n# See the License for the specific language governing permissions and\r\n# limitations under the License.\r\n# ==============================================================================\r\n\r\n\"\"\"Benchmark dataset utilities.\r\n\"\"\"\r\n\r\nfrom abc import abstractmethod\r\nimport os\r\n\r\nimport numpy as np\r\nfrom six.moves import cPickle\r\nfrom six.moves import xrange # pylint: disable=redefined-builtin\r\nimport tensorflow as tf\r\n\r\nfrom tensorflow.python.platform import gfile\r\nimport preprocessing\r\n\r\n\r\nIMAGENET_NUM_TRAIN_IMAGES = 1281167\r\nIMAGENET_NUM_VAL_IMAGES = 50000\r\n\r\n\r\ndef create_dataset(data_dir, data_name):\r\n \"\"\"Create a Dataset instance based on data_dir and data_name.\"\"\"\r\n supported_datasets = {\r\n 'imagenet': ImagenetData,\r\n 'cifar10': Cifar10Data,\r\n }\r\n if not data_dir and not data_name:\r\n # When using synthetic data, use synthetic imagenet images by default.\r\n data_name = 'imagenet'\r\n\r\n if data_name is None:\r\n for supported_name in supported_datasets:\r\n if supported_name in data_dir:\r\n data_name = supported_name\r\n break\r\n\r\n if data_name is None:\r\n raise ValueError('Could not identify name of dataset. '\r\n 'Please specify with --data_name option.')\r\n\r\n if data_name not in supported_datasets:\r\n raise ValueError('Unknown dataset. Must be one of %s', ', '.join(\r\n [key for key in sorted(supported_datasets.keys())]))\r\n\r\n return supported_datasets[data_name](data_dir)\r\n\r\n\r\nclass Dataset(object):\r\n \"\"\"Abstract class for cnn benchmarks dataset.\"\"\"\r\n\r\n def __init__(self, name, height=None, width=None, depth=None, data_dir=None,\r\n queue_runner_required=False, num_classes=1000):\r\n self.name = name\r\n self.height = height\r\n self.width = width\r\n self.depth = depth or 3\r\n\r\n self.data_dir = data_dir\r\n self._queue_runner_required = queue_runner_required\r\n self._num_classes = num_classes\r\n\r\n def tf_record_pattern(self, subset):\r\n return os.path.join(self.data_dir, '%s-*-of-*' % subset)\r\n\r\n def reader(self):\r\n return tf.compat.v1.TFRecordReader()\r\n\r\n @property\r\n def num_classes(self):\r\n return self._num_classes\r\n\r\n @num_classes.setter\r\n def num_classes(self, val):\r\n self._num_classes = val\r\n\r\n @abstractmethod\r\n def num_examples_per_epoch(self, subset):\r\n pass\r\n\r\n def __str__(self):\r\n return self.name\r\n\r\n def get_image_preprocessor(self):\r\n return None\r\n\r\n def queue_runner_required(self):\r\n return self._queue_runner_required\r\n\r\n def use_synthetic_gpu_images(self):\r\n return not self.data_dir\r\n\r\n\r\nclass ImagenetData(Dataset):\r\n \"\"\"Configuration for Imagenet dataset.\"\"\"\r\n\r\n def __init__(self, data_dir=None):\r\n super(ImagenetData, self).__init__('imagenet', 300, 300, data_dir=data_dir)\r\n\r\n def num_examples_per_epoch(self, subset='train'):\r\n if subset == 'train':\r\n return IMAGENET_NUM_TRAIN_IMAGES\r\n elif subset == 'validation':\r\n return IMAGENET_NUM_VAL_IMAGES\r\n else:\r\n raise ValueError('Invalid data subset \"%s\"' % subset)\r\n\r\n def get_image_preprocessor(self):\r\n if self.use_synthetic_gpu_images():\r\n return preprocessing.SyntheticImagePreprocessor\r\n else:\r\n return preprocessing.RecordInputImagePreprocessor\r\n\r\n\r\nclass Cifar10Data(Dataset):\r\n \"\"\"Configuration for cifar 10 dataset.\r\n\r\n It will mount all the input images to memory.\r\n \"\"\"\r\n\r\n def __init__(self, data_dir=None):\r\n super(Cifar10Data, self).__init__('cifar10', 32, 32, data_dir=data_dir,\r\n queue_runner_required=True,\r\n num_classes=10)\r\n\r\n def read_data_files(self, subset='train'):\r\n \"\"\"Reads from data file and returns images and labels in a numpy array.\"\"\"\r\n assert self.data_dir, ('Cannot call `read_data_files` when using synthetic '\r\n 'data')\r\n if subset == 'train':\r\n filenames = [os.path.join(self.data_dir, 'data_batch_%d' % i)\r\n for i in xrange(1, 6)]\r\n elif subset == 'validation':\r\n filenames = [os.path.join(self.data_dir, 'test_batch')]\r\n else:\r\n raise ValueError('Invalid data subset \"%s\"' % subset)\r\n\r\n inputs = []\r\n for filename in filenames:\r\n with gfile.Open(filename, 'r') as f:\r\n inputs.append(cPickle.load(f))\r\n # See http://www.cs.toronto.edu/~kriz/cifar.html for a description of the\r\n # input format.\r\n all_images = np.concatenate(\r\n [each_input['data'] for each_input in inputs]).astype(np.float32)\r\n all_labels = np.concatenate(\r\n [each_input['labels'] for each_input in inputs])\r\n return all_images, all_labels\r\n\r\n def num_examples_per_epoch(self, subset='train'):\r\n if subset == 'train':\r\n return 50000\r\n elif subset == 'validation':\r\n return 10000\r\n else:\r\n raise ValueError('Invalid data subset \"%s\"' % subset)\r\n\r\n def get_image_preprocessor(self):\r\n if self.use_synthetic_gpu_images():\r\n return preprocessing.SyntheticImagePreprocessor\r\n else:\r\n return preprocessing.Cifar10ImagePreprocessor\r\n"
] | [
[
"tensorflow.compat.v1.app.flags.DEFINE_string",
"tensorflow.compat.v1.app.flags.DEFINE_integer",
"tensorflow.make_tensor_proto",
"tensorflow.Session",
"tensorflow.compat.v1.disable_eager_execution",
"numpy.random.rand",
"tensorflow.compat.v1.app.run"
],
[
"tensorflow.compat.v1.expand_dims",
"tensorflow.compat.v1.image.central_crop",
"tensorflow.compat.v1.subtract",
"tensorflow.compat.v1.multiply",
"tensorflow.compat.v1.image.decode_jpeg",
"tensorflow.compat.v1.FixedLenFeature",
"tensorflow.compat.v1.image.convert_image_dtype",
"tensorflow.compat.v1.image.resize_bilinear",
"tensorflow.compat.v1.parse_single_example",
"tensorflow.compat.v1.cast",
"tensorflow.compat.v1.squeeze"
],
[
"tensorflow.compat.v1.import_graph_def",
"tensorflow.compat.v1.saved_model.signature_def_utils.build_signature_def",
"tensorflow.compat.v1.app.flags.DEFINE_integer",
"tensorflow.compat.v1.Session",
"tensorflow.compat.v1.app.flags.DEFINE_string",
"tensorflow.python.tools.optimize_for_inference_lib.optimize_for_inference",
"tensorflow.compat.v1.gfile.GFile",
"tensorflow.compat.v1.GraphDef",
"tensorflow.compat.v1.compat.v1.saved_model.build_tensor_info",
"tensorflow.compat.v1.app.run"
],
[
"tensorflow.Graph",
"tensorflow.constant",
"tensorflow.test.main",
"tensorflow.compat.v1.global_variables_initializer",
"tensorflow.compat.v1.Session",
"tensorflow.compat.v1.train.get_or_create_global_step",
"tensorflow.python.training.monitored_session._HookedSession"
],
[
"numpy.unique",
"numpy.asarray",
"numpy.max",
"numpy.argmax",
"numpy.mean",
"numpy.array",
"numpy.zeros"
],
[
"tensorflow.python.platform.app.run",
"tensorflow.Graph",
"tensorflow.compat.v1.ConfigProto",
"tensorflow.import_graph_def",
"tensorflow.io.gfile.GFile",
"pandas.DataFrame",
"tensorflow.compat.v1.Session",
"tensorflow.compat.v1.RunOptions",
"tensorflow.core.framework.graph_pb2.GraphDef",
"tensorflow.compat.v1.RunMetadata"
],
[
"numpy.concatenate",
"tensorflow.python.platform.gfile.Open",
"tensorflow.compat.v1.TFRecordReader"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [
"0.23",
"0.21",
"2.0",
"1.4",
"0.19",
"1.1",
"1.5",
"1.2",
"0.24",
"0.20",
"1.0",
"0.25",
"1.3"
],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
arlo-lib/ARLO | [
"159669884044686e36e07bd1cc0948884ed7cc8d"
] | [
"experiments/Scripts for creating plots/sac_performance_over_generations.py"
] | [
"import numpy as np\nimport matplotlib.pyplot as plt\n\nif __name__ == '__main__':\n x=np.arange(50)\n \n y=np.array([-59.00138158129509, \n -43.966695525591895, \n -52.5277642686108,\n -32.1793153104166,\n -37.81484603001339,\n -24.97787027415733,\n -20.170115700140766,\n -19.194577812051865,\n -24.267556747544734,\n -18.56846706310683,\n -24.168507205879642,\n -21.613453728913854,\n -19.833679338413056,\n -16.78310378266553,\n -15.692655896866523,\n -15.496178593312704,\n -15.23787215267857,\n -14.754095951096263,\n -12.79724037524585,\n -11.496812508420765,\n -11.593305322673082,\n -12.144980726639616,\n -11.889169042516812,\n -10.983010599192548,\n -10.751331950717917,\n -10.887445777009278,\n -10.94197566653676,\n -10.983575687515879,\n -10.315668585661115,\n -10.200188159394665,\n -10.2623815297516,\n -9.98878690162022,\n -9.664489111145294,\n -9.798550374351311,\n -9.66769644336881,\n -9.114549499466483,\n -9.259332831572362,\n -9.175694376996443,\n -9.415038345909062,\n -9.50191440403006,\n -9.36517394141991,\n -9.244892043097575,\n -9.220243263930586,\n -9.160062939634974,\n -9.293750423507198,\n -9.189954421974406,\n -9.125946744761388,\n -9.182482014624696,\n -9.135265034880312,\n -9.35027383852138])\n \n plt.plot()\n plt.plot(x,y)"
] | [
[
"matplotlib.pyplot.plot",
"numpy.arange",
"numpy.array"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
satishpasumarthi/sagemaker-python-sdk | [
"255a339ae985041ef47e3a80da91b9f54bca17b9"
] | [
"tests/integ/test_ntm.py"
] | [
"# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\"). You\n# may not use this file except in compliance with the License. A copy of\n# the License is located at\n#\n# http://aws.amazon.com/apache2.0/\n#\n# or in the \"license\" file accompanying this file. This file is\n# distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF\n# ANY KIND, either express or implied. See the License for the specific\n# language governing permissions and limitations under the License.\nfrom __future__ import absolute_import\n\nimport os\n\nimport numpy as np\nimport pytest\n\nfrom sagemaker import NTM, NTMModel, Predictor\nfrom sagemaker.amazon.common import read_records\nfrom sagemaker.serverless import ServerlessInferenceConfig\nfrom sagemaker.utils import unique_name_from_base\nfrom tests.integ import DATA_DIR, TRAINING_DEFAULT_TIMEOUT_MINUTES\nfrom tests.integ.timeout import timeout, timeout_and_delete_endpoint_by_name\nfrom tests.integ.record_set import prepare_record_set_from_local_files\n\n\[email protected]\[email protected](\n reason=\"This test has always failed, but the failure was masked by a bug. \"\n \"This test should be fixed. Details in https://github.com/aws/sagemaker-python-sdk/pull/968\"\n)\ndef test_ntm(sagemaker_session, cpu_instance_type):\n job_name = unique_name_from_base(\"ntm\")\n\n with timeout(minutes=TRAINING_DEFAULT_TIMEOUT_MINUTES):\n data_path = os.path.join(DATA_DIR, \"ntm\")\n data_filename = \"nips-train_1.pbr\"\n\n with open(os.path.join(data_path, data_filename), \"rb\") as f:\n all_records = read_records(f)\n\n # all records must be same\n feature_num = int(all_records[0].features[\"values\"].float32_tensor.shape[0])\n\n ntm = NTM(\n role=\"SageMakerRole\",\n instance_count=1,\n instance_type=cpu_instance_type,\n num_topics=10,\n sagemaker_session=sagemaker_session,\n )\n\n record_set = prepare_record_set_from_local_files(\n data_path, ntm.data_location, len(all_records), feature_num, sagemaker_session\n )\n ntm.fit(records=record_set, job_name=job_name)\n\n with timeout_and_delete_endpoint_by_name(job_name, sagemaker_session):\n model = NTMModel(ntm.model_data, role=\"SageMakerRole\", sagemaker_session=sagemaker_session)\n predictor = model.deploy(1, cpu_instance_type, endpoint_name=job_name)\n\n predict_input = np.random.rand(1, feature_num)\n result = predictor.predict(predict_input)\n\n assert len(result) == 1\n for record in result:\n assert record.label[\"topic_weights\"] is not None\n\n\ndef test_ntm_serverless_inference(sagemaker_session, cpu_instance_type):\n job_name = unique_name_from_base(\"ntm-serverless\")\n\n with timeout(minutes=TRAINING_DEFAULT_TIMEOUT_MINUTES):\n data_path = os.path.join(DATA_DIR, \"ntm\")\n data_filename = \"nips-train_1.pbr\"\n\n with open(os.path.join(data_path, data_filename), \"rb\") as f:\n all_records = read_records(f)\n\n # all records must be same\n feature_num = int(all_records[0].features[\"values\"].float32_tensor.shape[0])\n\n ntm = NTM(\n role=\"SageMakerRole\",\n instance_count=1,\n instance_type=cpu_instance_type,\n num_topics=10,\n sagemaker_session=sagemaker_session,\n )\n\n record_set = prepare_record_set_from_local_files(\n data_path, ntm.data_location, len(all_records), feature_num, sagemaker_session\n )\n ntm.fit(records=record_set, job_name=job_name)\n\n with timeout_and_delete_endpoint_by_name(job_name, sagemaker_session):\n model = NTMModel(ntm.model_data, role=\"SageMakerRole\", sagemaker_session=sagemaker_session)\n predictor = model.deploy(\n serverless_inference_config=ServerlessInferenceConfig(), endpoint_name=job_name\n )\n assert isinstance(predictor, Predictor)\n"
] | [
[
"numpy.random.rand"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
johnbachman/deft | [
"3643dd33ba4cb548f7622f24a3b87fbe48e38050"
] | [
"adeft/tests/test_disambiguate.py"
] | [
"import os\nimport uuid\nimport json\nimport shutil\nimport logging\nfrom nose.tools import raises\n\nfrom numpy import array_equal\n\nfrom adeft.modeling.classify import load_model\nfrom adeft.locations import TEST_RESOURCES_PATH\nfrom adeft.disambiguate import AdeftDisambiguator, load_disambiguator\n\nlogger = logging.getLogger(__name__)\n\n# Get test model path so we can write a temporary file here\nTEST_MODEL_PATH = os.path.join(TEST_RESOURCES_PATH, 'test_model')\n# Path to scratch directory to write files to during tests\nSCRATCH_PATH = os.path.join(TEST_RESOURCES_PATH, 'scratch')\n\nexample1 = ('The insulin receptor (IR) is a transmembrane receptor that'\n ' is activated by insulin, IGF-I, IGF-II and belongs to the large'\n ' class of tyrosine kinase receptors')\n\nexample2 = ('The insulin receptor (IR) is a transmembrane receptor that'\n ' is activated by insulin, IGF-I, IGF-II and belongs to the large'\n ' class of tyrosine kinase receptors. Insulin resistance (IR)'\n ' is considered as a pathological condition in which cells fail'\n ' to respond normally to the hormone insulin')\n\nexample3 = ('IR is a transmembrane receptor that is activated by insulin,'\n ' IGF-1, IFG-II and belongs to the large class of tyrosine'\n ' kinase receptors')\n\n\ndef test_load_disambiguator():\n ad = load_disambiguator('IR', path=TEST_MODEL_PATH)\n assert ad.shortforms == ['IR']\n assert hasattr(ad, 'classifier')\n assert hasattr(ad, 'recognizers')\n\n\ndef test_dump_disambiguator():\n ad1 = load_disambiguator('IR', path=TEST_MODEL_PATH)\n tempname = uuid.uuid4().hex\n ad1.dump(tempname, path=SCRATCH_PATH)\n ad2 = load_disambiguator('IR', path=SCRATCH_PATH)\n\n assert ad1.grounding_dict == ad2.grounding_dict\n assert ad1.names == ad2.names\n assert ad1.pos_labels == ad2.pos_labels\n assert (array_equal(ad1.classifier.estimator.named_steps['logit'].coef_,\n ad2.classifier.estimator.named_steps['logit'].coef_))\n assert ad1.info() == ad2.info(), (ad1.info(), ad2.info())\n try:\n shutil.rmtree(os.path.join(SCRATCH_PATH, tempname))\n except Exception:\n logger.warning('Could not clean up temporary folder %s'\n % os.path.join(SCRATCH_PATH, tempname))\n\n\ndef test_disambiguate():\n test_model = load_model(os.path.join(TEST_MODEL_PATH, 'IR',\n 'IR_model.gz'))\n with open(os.path.join(TEST_MODEL_PATH, 'IR',\n 'IR_grounding_dict.json')) as f:\n grounding_dict = json.load(f)\n with open(os.path.join(TEST_MODEL_PATH, 'IR',\n 'IR_names.json')) as f:\n names = json.load(f)\n\n ad = AdeftDisambiguator(test_model, grounding_dict, names)\n # case where there is a unique defining pattern\n disamb1 = ad.disambiguate(example1)\n assert disamb1[0] == 'HGNC:6091'\n assert disamb1[1] == 'INSR'\n assert disamb1[2]['HGNC:6091'] == 1.0\n assert disamb1[2]['MESH:D011839'] == 0.0\n\n # case where there are conflicting defining patterns\n disamb2 = ad.disambiguate(example2)\n preds = disamb2[2]\n nonzero = {key for key, value in preds.items() if value > 0.0}\n assert nonzero == {'HGNC:6091', 'MESH:D007333'}\n\n # case without a defining pattern\n disamb3 = ad.disambiguate(example3)\n assert disamb3[0] == 'HGNC:6091'\n assert disamb3[1] == 'INSR'\n\n\ndef test_modify_groundings():\n \"\"\"Test updating groundings of existing model.\"\"\"\n ad = load_disambiguator('IR', path=TEST_MODEL_PATH)\n ad.modify_groundings(new_groundings={'HGNC:6091': 'UP:P06213'},\n new_names={'HGNC:6091': 'Insulin Receptor'})\n\n assert 'UP:P06213' in ad.pos_labels\n assert 'UP:P06213' in ad.classifier.pos_labels\n assert 'UP:P06213' in ad.classifier.estimator.classes_\n assert 'UP:P06213' in ad.names\n assert 'UP:P06213' in ad.grounding_dict['IR'].values()\n assert ad.names['UP:P06213'] == 'Insulin Receptor'\n\n\n@raises(ValueError)\ndef test_modify_groundings_error():\n ad = load_disambiguator('IR', path=TEST_MODEL_PATH)\n ad.modify_groundings(new_groundings={'MESH:D011839': 'HGNC:6091'})\n"
] | [
[
"numpy.array_equal"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
zedian/esm | [
"9d2b50cd96753e8a703ca810e875c9e887047ed9",
"9d2b50cd96753e8a703ca810e875c9e887047ed9"
] | [
"models.py",
"esm/new_modules.py"
] | [
"from __future__ import print_function\nimport torch\nfrom torch import nn\nimport torch.utils.data as Data\nimport torch.nn.functional as F\nfrom torch.autograd import Variable\nimport numpy as np\n\nimport collections\nimport math\nimport copy\n\ntorch.manual_seed(1)\nnp.random.seed(1)\n\n\n\nclass BIN_Interaction_Flat(nn.Sequential):\n '''\n Interaction Network with 2D interaction map\n '''\n \n def __init__(self, **config):\n super(BIN_Interaction_Flat, self).__init__()\n self.max_d = config['max_drug_seq']\n self.max_p = config['max_protein_seq']\n self.emb_size = config['emb_size']\n self.dropout_rate = config['dropout_rate']\n \n #densenet\n self.scale_down_ratio = config['scale_down_ratio']\n self.growth_rate = config['growth_rate']\n self.transition_rate = config['transition_rate']\n self.num_dense_blocks = config['num_dense_blocks']\n self.kernal_dense_size = config['kernal_dense_size']\n self.batch_size = config['batch_size']\n self.input_dim_drug = config['input_dim_drug']\n self.input_dim_target = config['input_dim_target']\n self.gpus = torch.cuda.device_count()\n self.n_layer = 2\n #encoder\n self.hidden_size = config['emb_size']\n self.intermediate_size = config['intermediate_size']\n self.num_attention_heads = config['num_attention_heads']\n self.attention_probs_dropout_prob = config['attention_probs_dropout_prob']\n self.hidden_dropout_prob = config['hidden_dropout_prob']\n \n self.flatten_dim = config['flat_dim'] \n \n # specialized embedding with positional one\n self.demb = Embeddings(self.input_dim_drug, self.emb_size, self.max_d, self.dropout_rate)\n self.pemb = Embeddings(self.input_dim_target, self.emb_size, self.max_p, self.dropout_rate)\n self.d_encoder = Encoder_MultipleLayers(Encoder, self.n_layer, self.hidden_size, self.intermediate_size, self.num_attention_heads, self.attention_probs_dropout_prob, self.hidden_dropout_prob)\n self.p_encoder = Encoder_MultipleLayers(Encoder, self.n_layer, self.hidden_size, self.intermediate_size, self.num_attention_heads, self.attention_probs_dropout_prob, self.hidden_dropout_prob)\n \n self.icnn = nn.Conv2d(1, 3, 3, padding = 0)\n \n self.decoder = nn.Sequential(\n nn.Linear(self.flatten_dim, 512),\n nn.ReLU(True),\n \n nn.BatchNorm1d(512),\n nn.Linear(512, 64),\n nn.ReLU(True),\n \n nn.BatchNorm1d(64),\n nn.Linear(64, 32),\n nn.ReLU(True),\n \n #output layer\n nn.Linear(32, 1)\n )\n \n def forward(self, d, p, d_mask, p_mask):\n \n ex_d_mask = d_mask.unsqueeze(1).unsqueeze(2)\n ex_p_mask = p_mask.unsqueeze(1).unsqueeze(2)\n \n ex_d_mask = (1.0 - ex_d_mask) * -10000.0\n ex_p_mask = (1.0 - ex_p_mask) * -10000.0\n \n d_emb = self.demb(d) # batch_size x seq_length x embed_size\n p_emb = self.pemb(p)\n\n # set output_all_encoded_layers be false, to obtain the last layer hidden states only...\n \n d_encoded_layers = self.d_encoder(d_emb.float(), ex_d_mask.float())\n p_encoded_layers = self.p_encoder(p_emb.float(), ex_p_mask.float())\n \n print(\"Drug encoded Layers shape: \", d_encoded_layers.shape)\n print(\"Protein encoded Layers shape: \", p_encoded_layers.shape)\n \n # repeat to have the same tensor size for aggregation \n d_aug = torch.unsqueeze(d_encoded_layers, 2).repeat(1, 1, self.max_p, 1) # repeat along protein size\n p_aug = torch.unsqueeze(p_encoded_layers, 1).repeat(1, self.max_d, 1, 1) # repeat along drug size\n \n print(\"Reshaped drug encoding shape: \", d_aug.shape)\n print(\"Reshaped protein encoding shape: \", p_aug.shape)\n \n i = d_aug * p_aug # interaction\n \n print(\"Interaction shape: \", i.shape)\n# if self.gpus != 0:\n# i_v = i.view(int(self.batch_size/self.gpus), -1, self.max_d, self.max_p)\n# else:\n i_v = i.view(self.batch_size, -1, self.max_d, self.max_p)\n print(i_v.shape)\n # batch_size x embed size x max_drug_seq_len x max_protein_seq_len\n i_v = torch.sum(i_v, dim = 1)\n print(i_v.shape)\n i_v = torch.unsqueeze(i_v, 1)\n print(i_v.shape)\n \n i_v = F.dropout(i_v, p = self.dropout_rate) \n \n #f = self.icnn2(self.icnn1(i_v))\n f = self.icnn(i_v)\n \n #print(f.shape)\n \n #f = self.dense_net(f)\n #print(f.shape)\n \n# f = f.view(int(self.batch_size/self.gpus), -1)\n f = f.view(self.batch_size, -1)\n# print(f.shape)\n \n #f_encode = torch.cat((d_encoded_layers[:,-1], p_encoded_layers[:,-1]), dim = 1)\n \n #score = self.decoder(torch.cat((f, f_encode), dim = 1))\n score = self.decoder(f)\n return score \n\nclass Single_Transformer_Embedding(nn.Sequential):\n def __init__(self, **config):\n super(Single_Transformer_Embedding, self).__init__()\n self.max_len = config[\"max_len\"]\n self.emb_size = config[\"emb_size\"]\n self.dropout_rate = config[\"dropout_rate\"]\n \n self.batch_size = config[\"batch_size\"]\n self.input_dim = config[\"input_dim\"]\n self.gpus = torch.cuda.device_count()\n self.n_layer = 2\n \n self.hidden_size = config[\"emb_size\"]\n self.intermediate_size = config[\"intermediate_size\"]\n self.num_attention_heads = config[\"num_attention_heads\"]\n self.attention_dropout = config[\"attention_probs_dropout_prob\"]\n self.hidden_dropout = config[\"hidden_dropout_prob\"]\n self.vocab_size = config['vocab_size']\n self.flatten_dim = config[\"flat_dim\"]\n \n self.emb = Embeddings(self.input_dim, self.emb_size, self.max_len, self.dropout_rate)\n \n self.encoder = Encoder_MultipleLayers(Encoder, self.n_layer, self.hidden_size, self.intermediate_size, self.num_attention_heads, self.attention_dropout, self.hidden_dropout)\n \n self.decoder = nn.Sequential(\n nn.Linear(self.hidden_size, self.vocab_size)\n )\n \n def forward(self, x):\n ex_mask = 0. * x\n \n emb = self.emb(x) # batch_size x seq_length x embed_size\n # set output_all_encoded_layers be false, to obtain the last layer hidden states only...\n \n encoded_layers = self.encoder(emb.float(), 0.)\n\n# encoded_layers = encoded_layers.view(self.batch_size, -1)\n embedding = self.decoder(encoded_layers)\n return embedding \n \n \nclass BIN_Transformer_Single(nn.Sequential):\n '''\n Simple transformer encoder\n '''\n \n def __init__(self, **config):\n super(BIN_Transformer_Single, self).__init__()\n self.max_d = config['max_drug_seq']\n self.max_p = config['max_protein_seq']\n self.max_len = config['max_len'] # drug and protein concatenated\n\n self.emb_size = config['emb_size']\n self.dropout_rate = config['dropout_rate']\n \n #densenet\n self.scale_down_ratio = config['scale_down_ratio']\n self.growth_rate = config['growth_rate']\n self.transition_rate = config['transition_rate']\n self.num_dense_blocks = config['num_dense_blocks']\n self.kernal_dense_size = config['kernal_dense_size']\n self.batch_size = config['batch_size']\n self.input_dim = config['input_dim']\n self.gpus = torch.cuda.device_count()\n self.n_layer = 2\n #encoder\n self.hidden_size = config['emb_size']\n self.intermediate_size = config['intermediate_size']\n self.num_attention_heads = config['num_attention_heads']\n self.attention_probs_dropout_prob = config['attention_probs_dropout_prob']\n self.hidden_dropout_prob = config['hidden_dropout_prob']\n self.vocab_size = config['vocab_size']\n \n self.flatten_dim = config['flat_dim'] \n \n # specialized embedding with positional one\n self.emb = Embeddings(self.input_dim, self.emb_size, self.max_len, self.dropout_rate)\n \n self.encoder = Encoder_MultipleLayers(Encoder, self.n_layer, self.hidden_size, self.intermediate_size, self.num_attention_heads, self.attention_probs_dropout_prob, self.hidden_dropout_prob)\n \n self.decoder = nn.Sequential(\n nn.Linear(self.flatten_dim, 512),\n nn.ReLU(True),\n \n nn.BatchNorm1d(512),\n nn.Linear(512, 64),\n nn.ReLU(True),\n \n nn.BatchNorm1d(64),\n nn.Linear(64, 32),\n nn.ReLU(True),\n \n #output layer\n nn.Linear(32, 1)\n )\n \n def forward(self, x, mask):\n \n ex_mask = mask.unsqueeze(1).unsqueeze(2)\n \n ex_mask = (1.0 - ex_mask) * -10000.0\n \n emb = self.emb(x) # batch_size x seq_length x embed_size\n # set output_all_encoded_layers be false, to obtain the last layer hidden states only...\n \n encoded_layers = self.encoder(emb.float(), ex_mask.float())\n print(\"Encoder dim: \", encoded_layers.shape)\n \n # repeat to have the same tensor size for aggregation \n# aug = torch.unsqueeze(encoded_layers, 2).repeat(1, 1, self.max_len, 1) # repeat along protein size\n# print(aug.shape)\n #score = self.decoder(torch.cat((f, f_encode), dim = 1))\n encoded_layers = encoded_layers.view(self.batch_size, -1)\n score = self.decoder(encoded_layers)\n return score \n \n# help classes \n \nclass LayerNorm(nn.Module):\n def __init__(self, hidden_size, variance_epsilon=1e-12):\n\n super(LayerNorm, self).__init__()\n self.gamma = nn.Parameter(torch.ones(hidden_size))\n self.beta = nn.Parameter(torch.zeros(hidden_size))\n self.variance_epsilon = variance_epsilon\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.gamma * x + self.beta\n\n\nclass Embeddings(nn.Module):\n \"\"\"Construct the embeddings from protein/target, position embeddings.\n \"\"\"\n def __init__(self, vocab_size, hidden_size, max_position_size, dropout_rate):\n super(Embeddings, self).__init__()\n self.word_embeddings = nn.Embedding(vocab_size, hidden_size)\n self.position_embeddings = nn.Embedding(max_position_size, hidden_size)\n\n self.LayerNorm = LayerNorm(hidden_size)\n self.dropout = nn.Dropout(dropout_rate)\n\n def forward(self, input_ids):\n seq_length = input_ids.size(1)\n position_ids = torch.arange(seq_length, dtype=torch.long, device=input_ids.device)\n position_ids = position_ids.unsqueeze(0).expand_as(input_ids)\n \n words_embeddings = self.word_embeddings(input_ids)\n position_embeddings = self.position_embeddings(position_ids)\n\n embeddings = words_embeddings + position_embeddings\n embeddings = self.LayerNorm(embeddings)\n embeddings = self.dropout(embeddings)\n return embeddings\n \n\nclass SelfAttention(nn.Module):\n def __init__(self, hidden_size, num_attention_heads, attention_probs_dropout_prob):\n super(SelfAttention, self).__init__()\n if hidden_size % num_attention_heads != 0:\n raise ValueError(\n \"The hidden size (%d) is not a multiple of the number of attention \"\n \"heads (%d)\" % (hidden_size, num_attention_heads))\n self.num_attention_heads = num_attention_heads\n self.attention_head_size = int(hidden_size / num_attention_heads)\n self.all_head_size = self.num_attention_heads * self.attention_head_size\n\n self.query = nn.Linear(hidden_size, self.all_head_size)\n self.key = nn.Linear(hidden_size, self.all_head_size)\n self.value = nn.Linear(hidden_size, self.all_head_size)\n\n self.dropout = nn.Dropout(attention_probs_dropout_prob)\n\n def transpose_for_scores(self, x):\n new_x_shape = x.size()[:-1] + (self.num_attention_heads, self.attention_head_size)\n x = x.view(*new_x_shape)\n return x.permute(0, 2, 1, 3)\n\n def forward(self, hidden_states, attention_mask):\n mixed_query_layer = self.query(hidden_states)\n mixed_key_layer = self.key(hidden_states)\n mixed_value_layer = self.value(hidden_states)\n\n query_layer = self.transpose_for_scores(mixed_query_layer)\n key_layer = self.transpose_for_scores(mixed_key_layer)\n value_layer = self.transpose_for_scores(mixed_value_layer)\n\n # Take the dot product between \"query\" and \"key\" to get the raw attention scores.\n attention_scores = torch.matmul(query_layer, key_layer.transpose(-1, -2))\n attention_scores = attention_scores / math.sqrt(self.attention_head_size)\n\n attention_scores = attention_scores + attention_mask\n\n # Normalize the attention scores to probabilities.\n attention_probs = nn.Softmax(dim=-1)(attention_scores)\n\n # This is actually dropping out entire tokens to attend to, which might\n # seem a bit unusual, but is taken from the original Transformer paper.\n attention_probs = self.dropout(attention_probs)\n\n context_layer = torch.matmul(attention_probs, value_layer)\n context_layer = context_layer.permute(0, 2, 1, 3).contiguous()\n new_context_layer_shape = context_layer.size()[:-2] + (self.all_head_size,)\n context_layer = context_layer.view(*new_context_layer_shape)\n return context_layer\n \n\nclass SelfOutput(nn.Module):\n def __init__(self, hidden_size, hidden_dropout_prob):\n super(SelfOutput, self).__init__()\n self.dense = nn.Linear(hidden_size, hidden_size)\n self.LayerNorm = LayerNorm(hidden_size)\n self.dropout = nn.Dropout(hidden_dropout_prob)\n\n def forward(self, hidden_states, input_tensor):\n hidden_states = self.dense(hidden_states)\n hidden_states = self.dropout(hidden_states)\n hidden_states = self.LayerNorm(hidden_states + input_tensor)\n return hidden_states \n \n \nclass Attention(nn.Module):\n def __init__(self, hidden_size, num_attention_heads, attention_probs_dropout_prob, hidden_dropout_prob):\n super(Attention, self).__init__()\n self.self = SelfAttention(hidden_size, num_attention_heads, attention_probs_dropout_prob)\n self.output = SelfOutput(hidden_size, hidden_dropout_prob)\n\n def forward(self, input_tensor, attention_mask):\n self_output = self.self(input_tensor, attention_mask)\n attention_output = self.output(self_output, input_tensor)\n return attention_output \n \nclass Intermediate(nn.Module):\n def __init__(self, hidden_size, intermediate_size):\n super(Intermediate, self).__init__()\n self.dense = nn.Linear(hidden_size, intermediate_size)\n\n def forward(self, hidden_states):\n hidden_states = self.dense(hidden_states)\n hidden_states = F.relu(hidden_states)\n return hidden_states\n\nclass Output(nn.Module):\n def __init__(self, intermediate_size, hidden_size, hidden_dropout_prob):\n super(Output, self).__init__()\n self.dense = nn.Linear(intermediate_size, hidden_size)\n self.LayerNorm = LayerNorm(hidden_size)\n self.dropout = nn.Dropout(hidden_dropout_prob)\n\n def forward(self, hidden_states, input_tensor):\n hidden_states = self.dense(hidden_states)\n hidden_states = self.dropout(hidden_states)\n hidden_states = self.LayerNorm(hidden_states + input_tensor)\n return hidden_states\n\nclass Encoder(nn.Module):\n def __init__(self, hidden_size, intermediate_size, num_attention_heads, attention_probs_dropout_prob, hidden_dropout_prob):\n super(Encoder, self).__init__()\n self.attention = Attention(hidden_size, num_attention_heads, attention_probs_dropout_prob, hidden_dropout_prob)\n self.intermediate = Intermediate(hidden_size, intermediate_size)\n self.output = Output(intermediate_size, hidden_size, hidden_dropout_prob)\n\n def forward(self, hidden_states, attention_mask):\n attention_output = self.attention(hidden_states, attention_mask)\n intermediate_output = self.intermediate(attention_output)\n layer_output = self.output(intermediate_output, attention_output)\n return layer_output \n\nclass LinearEncoder(nn.Module):\n def __init__(self, hidden_size, intermediate_size, num_attention_heads, attention_dropout, hidden_dropout):\n super(LinearEncoder, self).__init__()\n attention_head_size = int(hidden_size / num_attention_heads)\n self.attention = LinearMultiHeadAttn(num_attention_heads, hidden_size, attention_head_size, hidden_dropout, attention_dropout)\n \n def forward(self, hidden_states, attention_mask):\n attention_output = self.attention(hidden_states, attention_mask)\n return attention_output\n\n# class DPFPEncoder(nn.Module):\n# def __init__(self, hidden_size, intermediate_size, num_attention_heads, attention_dropout, hidden_dropout):\n# super(DPFPEncoder, self).__init__()\n# attention_head_size = int(hidden_size / num_attention_heads)\n# self.attention = DPFPMultiHeadAttn(num_attention_heads, hidden_size, attention_head_size, hidden_dropout, attention_dropout)\n \n# def forward(self, hidden_states, attention_mask):\n# attention_output = self.attention(hidden_states, attention_mask)\n# return attention_output\n\nclass Encoder_MultipleLayers(nn.Module):\n def __init__(self, encoder, n_layer, hidden_size, intermediate_size, num_attention_heads, attention_probs_dropout_prob, hidden_dropout_prob):\n super(Encoder_MultipleLayers, self).__init__()\n layer = encoder(hidden_size, intermediate_size, num_attention_heads, attention_probs_dropout_prob, hidden_dropout_prob)\n self.layer = nn.ModuleList([copy.deepcopy(layer) for _ in range(n_layer)]) \n\n def forward(self, hidden_states, attention_mask, output_all_encoded_layers=True):\n all_encoder_layers = []\n for layer_module in self.layer:\n hidden_states = layer_module(hidden_states, attention_mask)\n #if output_all_encoded_layers:\n # all_encoder_layers.append(hidden_states)\n #if not output_all_encoded_layers:\n # all_encoder_layers.append(hidden_states)\n return hidden_states\n",
"import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\n\n\ndef gelu(x):\n \"\"\"Implementation of the gelu activation function.\n For information: OpenAI GPT's gelu is slightly different (and gives slightly different results):\n 0.5 * x * (1 + torch.tanh(math.sqrt(2 / math.pi) * (x + 0.044715 * torch.pow(x, 3))))\n Also see https://arxiv.org/abs/1606.08415\n \"\"\"\n return x * 0.5 * (1.0 + torch.erf(x / math.sqrt(2.0)))\n\nclass TransformerEncoder(nn.Module):\n \"\"\"\n Transformer encoder block (MultiheadAttention -> LayerNorm -> FF1 -> FF2 -> LayerNorm)\n \n \n \"\"\"\n \n def __init__(\n self,\n embedding_dim,\n ff_intermediate_dim,\n num_heads,\n attention_dropout,\n output_dropout,\n add_bias_kv\n ):\n super().__init__()\n self.embedding_dim = embedding_dim\n self.ff_intermediate_dim = ff_intermediate_dim\n self.num_heads = num_heads\n self.attention_dropout = attention_dropout\n self.output_dropout = output_dropout\n self.add_bias_kv = add_bias_kv\n \n self.q_dim, self.k_dim, self.v_dim = embedding_dim\n \n self.q = nn.Linear(self.q_dim, embedding_dim)\n self.k = nn.Linear(self.k_dim, embedding_dim)\n self.v = nn.Linear(self.v_dim, embedding_dim)\n \n # Note: torch multiheadattention needs QKV input\n self.multihead_attention = nn.MultiheadAttention(embedding_dim, num_heads, attention_dropout, add_bias_kv = add_bias_kv)\n \n self.attn_layer_norm = nn.LayerNorm(embedding_dim)\n \n self.fc1 = nn.Linear(self.embedding_dim, self.ff_intermediate_dim)\n self.fc2 = nn.Linear(self.ff_intermediate_dim, self.embedding_dim)\n \n self.output_layer_norm = nn.LayerNorm(embedding_dim)\n\n def forward(\n self, \n x, \n mask = None\n ):\n query = self.q(x)\n key = self.k(x)\n value = self.v(x)\n \n attention = self.multihead_attention(query, key, value)\n \n normed_sum = self.attn_layer_norm(attention + x)\n \n x = self.fc1(normed_sum)\n x = self.fc2(x)\n \n normed_output = self.output_layer_norm(x)\n return normed_output\n \nclass MaskedLM(nn.Module):\n def __init__(\n self,\n embedding_dim,\n embedding_weights\n ):\n super(MaskedLM, self).__init__()\n \n self.fc1 = nn.Linear(embedding_dim, embedding_dim)\n self.act = gelu()\n self.layer_norm = nn.LayerNorm(embedding_dim)\n \n self.decoder = nn.Linear(embedding_weights.size(1), \n embedding_weights.size(0))\n self.decoder.weight = embedding_weights\n self.bias = nn.Parameter(torch.zeros(embedding_weights.size(0)))\n \n def forward(self, x):\n x = self.fc1(x)\n x = self.act(x)\n x = self.layer_norm(x)\n \n x = self.decoder(x) + self.bias\n return x\n \n \n "
] | [
[
"torch.nn.Softmax",
"torch.nn.functional.dropout",
"torch.zeros",
"torch.sum",
"torch.nn.Embedding",
"torch.nn.Dropout",
"torch.ones",
"torch.sqrt",
"torch.nn.functional.relu",
"torch.arange",
"torch.nn.BatchNorm1d",
"torch.nn.Conv2d",
"torch.unsqueeze",
"torch.nn.Linear",
"torch.cuda.device_count",
"numpy.random.seed",
"torch.manual_seed",
"torch.matmul",
"torch.nn.ReLU"
],
[
"torch.nn.Linear",
"torch.nn.MultiheadAttention",
"torch.nn.LayerNorm"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
ibme-qubic/oxasl | [
"e583103f3313aed2890b60190b6ca7b265a46e3c"
] | [
"oxasl/mask.py"
] | [
"\"\"\"\nOXASL - Module to generate a suitable mask for ASL data\n\nCopyright (c) 2008-2020 Univerisity of Oxford\n\"\"\"\nimport numpy as np\nimport scipy as sp\n\nimport fsl.wrappers as fsl\nfrom fsl.data.image import Image\n\nfrom oxasl import reg\nfrom oxasl.reporting import LightboxImage\n\ndef generate_mask(wsp):\n \"\"\"\n For compatibility\n \"\"\"\n run(wsp)\n\ndef run(wsp):\n \"\"\"\n Generate mask for ASL data\n\n - If a ready-made mask image is provided or has already been generated, this is returned\n - If a structural image is provided this will be used. Brain extraction and registration\n will be performed if required\n - If a calibration image is provided, this is used. It is assumed to be in the same space\n as the ASL data\n - If none of the above are present, the ASL data itself is averaged and brain extracted\n to produce the mask\n\n Required workspace attributes\n -----------------------------\n\n Formally there are no required attributes, however at least one image must be provided\n which enables a mask to be generated.\n\n Optional workspace attributes\n -----------------------------\n\n - ``asldata`` : ASL data image\n - ``mask`` : Existing brain mask\n - ``struc`` : Structural image (wholehead)\n - ``struc_brain``: Already brain-extracted structural image\n - ``asl2struc`` : Existring ASL->Structural space transformation matrix\n - ``calib`` : Calibration image\n - ``nativeref`` : ASL registration source image\n \"\"\"\n if wsp.rois is not None and wsp.rois.mask is not None:\n return\n\n wsp.sub(\"rois\")\n wsp.log.write(\"\\nGenerating ASL data mask\\n\")\n\n # Reporting\n page = wsp.report.page(\"mask\")\n page.heading(\"Mask generation\", level=0)\n\n if wsp.mask is not None:\n wsp.rois.mask_src = \"user\"\n mask_source = \"provided by user (assumed to be ASL space): %s\" % wsp.mask.name\n wsp.rois.mask = wsp.mask\n elif wsp.structural is not None and wsp.structural.struc is not None:\n # Preferred option is to use brain extracted structural\n wsp.rois.mask_src = \"struc\"\n page.heading(\"Brain extracted structural image\", level=1)\n page.image(\"struc_brain\", LightboxImage(wsp.structural.brain, bgimage=wsp.structural.struc))\n wsp.rois.mask_struc = wsp.structural.brain_mask\n wsp.rois.mask_asl = reg.change_space(wsp, wsp.structural.brain_mask, \"native\")\n wsp.rois.mask = Image(sp.ndimage.morphology.binary_fill_holes((wsp.rois.mask_asl.data > 0.25)).astype(np.int), header=wsp.rois.mask_asl.header)\n mask_source = \"generated from brain extracting structural image and registering to ASL space\"\n else:\n # Alternatively, use registration image (which will be BETed calibration or mean ASL image)\n wsp.rois.mask_src = \"nativeref\"\n wsp.rois.mask = Image((wsp.reg.nativeref.data != 0).astype(np.int), header=wsp.reg.nativeref.header)\n mask_source = \"generated from brain extracted registration ASL image\"\n\n wsp.log.write(\" - Mask %s\\n\" % mask_source)\n\n page.heading(\"Masked ASL brain image\", level=1)\n page.text(\"Mask was %s\" % mask_source)\n page.text(\"PW ASL image masked by ASL-space mask\")\n\n if wsp.asldata.iaf in (\"diff\", \"tc\", \"ct\"):\n page.image(\"mask_outline\", LightboxImage(wsp.rois.mask, bgimage=wsp.asldata.perf_weighted(), outline=True))\n else:\n page.image(\"mask_outline\", LightboxImage(wsp.rois.mask, bgimage=wsp.asldata.mean(), outline=True))\n"
] | [
[
"scipy.ndimage.morphology.binary_fill_holes"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [
"0.13",
"1.6",
"0.14",
"0.15",
"1.4",
"0.16",
"1.0",
"0.19",
"1.5",
"0.18",
"1.2",
"1.7",
"0.12",
"0.10",
"0.17",
"1.3"
],
"tensorflow": []
}
] |
skyf0cker/Statistical_learning_method | [
"8151f3b8595ac086f08d161dc0cb961946f4b7fc"
] | [
"lh/DecisionTree2.py"
] | [
"#!/usr/bin/env python\r\n# -*- coding: utf-8 -*-\r\n# @Date : 2019-02-03 15:17:08\r\n# @Author : Vophan Lee ([email protected])\r\n# @Link : https://www.jianshu.com/u/3e6114e983ad\r\n\r\nfrom sklearn.datasets import make_classification\r\nimport numpy as np\r\nimport math\r\n\r\n\r\nclass Decision_Tree(object):\r\n \"\"\"\r\n this is a class to build the decision tree\r\n \"\"\"\r\n\r\n feature_list = []\r\n gain_list = []\r\n dim_list = []\r\n index = 0\r\n\r\n def __init__(self):\r\n super(Decision_Tree, self).__init__()\r\n self.features = 5\r\n self.samples = 100\r\n self.data = make_classification(\r\n n_samples=self.samples, n_features=self.features, n_classes=2)\r\n self.empirical_entropy = self.cal_emp_entropy(self.data)\r\n\r\n def cal_emp_entropy(self, data):\r\n \"\"\"\r\n calculate the empirical entropy\r\n \"\"\"\r\n data_0 = []\r\n data_1 = []\r\n for i in enumerate(data[1]):\r\n if i[1] == 0:\r\n data_0.append(data[0][i[0]])\r\n else:\r\n data_1.append(data[0][i[0]])\r\n entropy = 0\r\n for data_ in [data_0, data_1]:\r\n entropy += - \\\r\n (len(data_) / len(data[0])) * \\\r\n math.log2(len(data_) / len(data[0]))\r\n return entropy\r\n\r\n def div_point(self, dim_data):\r\n \"\"\"\r\n decide the divided point of each feature,here we sopposed that dim_data is a continuous dataset\r\n dim_data: tuple\r\n \"\"\"\r\n def dichotomy(dim_data):\r\n div_points = np.zeros((1, self.samples)).reshape(self.samples)\r\n for i in enumerate(dim_data):\r\n if i[0] == len(dim_data) - 1:\r\n break\r\n div_points[i[0]] = (dim_data[i[0] + 1] + i[1]) / 2\r\n return div_points\r\n dim_data = list(dim_data)\r\n dim_data = np.array(dim_data)\r\n dim_data = dim_data[:, dim_data[0].argsort()]\r\n dim_data = tuple(dim_data)\r\n div_points = dichotomy(dim_data[1])\r\n information_gain_list = []\r\n for i in div_points:\r\n div_index = list(div_points).index(i) + 1\r\n front = dim_data[1][:div_index]\r\n behind = dim_data[1][div_index:]\r\n front_flag = dim_data[0][:div_index]\r\n behind_flag = dim_data[0][div_index:]\r\n front_data = (front, front_flag)\r\n behind_data = (behind, behind_flag)\r\n if len(front_data[0]) == 1 or ((front_data[1] == front_data[1][::-1]).all() and len(front_data[0]) != len(dim_data[0]) / 2):\r\n behind_entropy = self.cal_emp_entropy(behind_data)\r\n information_gain = self.empirical_entropy - \\\r\n (behind_entropy * (len(behind) / len(dim_data[0])))\r\n information_gain_list.append(information_gain)\r\n elif len(behind_data[0]) == 1 or ((behind_data[1] == behind_data[1][::-1]).all() and len(front_data[0]) != len(dim_data[0]) / 2):\r\n front_entropy = self.cal_emp_entropy(front_data)\r\n information_gain = self.empirical_entropy - \\\r\n (front_entropy * (len(front) / len(dim_data[0])))\r\n information_gain_list.append(information_gain)\r\n elif (front_data[1] == front_data[1][::-1]).all() and len(front_data[0]) == len(dim_data[0]) / 2:\r\n\r\n return -1, div_points[int(len(dim_data[0]) / 2 - 1)]\r\n else:\r\n front_entropy = self.cal_emp_entropy(front_data)\r\n behind_entropy = self.cal_emp_entropy(behind_data)\r\n information_gain = self.empirical_entropy - (front_entropy * (len(front) / len(\r\n dim_data[0])) + behind_entropy * (len(behind) / len(dim_data[0])))\r\n information_gain_list.append(information_gain)\r\n max_information_gain = max(information_gain_list)\r\n return max_information_gain, div_points[information_gain_list.index(max_information_gain)]\r\n\r\n def compare_features(self):\r\n \"\"\"\r\n here we choose a maximium information gain among all features\r\n \"\"\"\r\n gain_list_tmp = []\r\n point_list = []\r\n for i in range(self.features):\r\n information_gain, div_point = self.div_point((self.data[1], self.data[0].transpose()[i]))\r\n gain_list_tmp.append(information_gain)\r\n point_list.append(div_point)\r\n com_matrix = np.array([\r\n gain_list_tmp,\r\n point_list,\r\n range(self.features)\r\n ])\r\n com_matrix = com_matrix[:, com_matrix[0].argsort()]\r\n Decision_Tree.feature_list = list(com_matrix[1])\r\n Decision_Tree.gain_list = list(com_matrix[0])\r\n Decision_Tree.dim_list = list(com_matrix[2])\r\n\r\n def planet_tree(self, data):\r\n \"\"\"\r\n here is the process of planeting the tree\r\n data: without flag\r\n \"\"\"\r\n feature = Decision_Tree.feature_list[Decision_Tree.index]\r\n dim = Decision_Tree.dim_list[Decision_Tree.index]\r\n Decision_Tree.index += 1\r\n if Decision_Tree.gain_list[Decision_Tree.feature_list.index(feature)] == -1 or Decision_Tree.index >= len(Decision_Tree.feature_list) - 1:\r\n return tree_node([x for x in data.transpose()[int(dim)] if x < feature],\r\n [x for x in data.transpose()[int(dim)] if x > feature],\r\n feature)\r\n else:\r\n return tree_node(self.planet_tree([x for x in data[0] if x < feature]),self.planet_tree([x for x in data[0] if x > feature]), feature)\r\n\r\n\r\nclass tree_node(object):\r\n \"\"\"\r\n this is the node of the decision tree\r\n \"\"\"\r\n\r\n def __init__(self, left, right, data):\r\n self.left=left\r\n self.right=right\r\n self.data=data\r\n"
] | [
[
"numpy.array",
"sklearn.datasets.make_classification",
"numpy.zeros"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
jun-hyeok/SUP5001-41_Deep-Neural-Networks_2022Spring | [
"95bc0f3a7042debbc388c76d9bd43ad24aba2c88"
] | [
"DNN_HW5/main.py"
] | [
"# %% [markdown]\n# [](https://colab.research.google.com/github/jun-hyeok/SUP5001-41_Deep-Neural-Networks_2022Spring/blob/main/DNN_HW5/main.ipynb)\n\n# %% [markdown]\n# # DNN HW5 : #9\n#\n# 2022.03.23\n# 박준혁\n\n# %%\nimport numpy as np\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport torch.optim as optim\n\n# %% [markdown]\n# Create XOR dataset with torch.FloatTensor\n\n# %%\n# xor dataset\nx = torch.FloatTensor([[0, 0], [0, 1], [1, 0], [1, 1]])\ny = torch.FloatTensor([[0], [1], [1], [0]])\n\n# %% [markdown]\n# 1. NN model - 10 hidden layer with 4 nodes each\n\n# %%\n# neural network 10 hidden layers with 4 nodes each\nclass NN10(nn.Module):\n def __init__(self):\n super().__init__()\n self.fc1 = nn.Linear(2, 4, bias=True)\n self.fc2 = nn.Linear(4, 4)\n self.fc3 = nn.Linear(4, 4)\n self.fc4 = nn.Linear(4, 4)\n self.fc5 = nn.Linear(4, 4)\n self.fc6 = nn.Linear(4, 4)\n self.fc7 = nn.Linear(4, 4)\n self.fc8 = nn.Linear(4, 4)\n self.fc9 = nn.Linear(4, 4)\n self.fc10 = nn.Linear(4, 1)\n\n def forward(self, x):\n x = F.relu(self.fc1(x))\n x = F.relu(self.fc2(x))\n x = F.relu(self.fc3(x))\n x = F.relu(self.fc4(x))\n x = F.relu(self.fc5(x))\n x = F.relu(self.fc6(x))\n x = F.relu(self.fc7(x))\n x = F.relu(self.fc8(x))\n x = F.relu(self.fc9(x))\n x = F.sigmoid(self.fc10(x))\n return x\n\n\n# %%\nnn10 = NN10()\noptimizer10 = optim.SGD(nn10.parameters(), lr=0.1)\nepochs = 10000\nfor epoch in range(epochs):\n optimizer10.zero_grad()\n y_pred10 = nn10(x)\n ce10 = F.binary_cross_entropy(y_pred10, y)\n ce10.backward()\n optimizer10.step()\n if epoch % 1000 == 0:\n print(\"Epoch: {:4d}/{}\".format(epoch, epochs), end=\" \")\n print(\"Cost: {:.6f}\".format(ce10.item()))\n\n# %% [markdown]\n# 2. NN model - 2 hidden layer with 4 nodes each\n\n# %%\n# neural network 2 hidden layers with 4 nodes each\nclass NN02(nn.Module):\n def __init__(self):\n super().__init__()\n self.fc1 = nn.Linear(2, 4, bias=True)\n self.fc2 = nn.Linear(4, 4)\n self.fc3 = nn.Linear(4, 1)\n\n def forward(self, x):\n x = F.relu(self.fc1(x))\n x = F.relu(self.fc2(x))\n x = F.sigmoid(self.fc3(x))\n return x\n\n\n# %%\nnn02 = NN02()\noptimizer02 = optim.SGD(nn02.parameters(), lr=0.1)\nepochs = 10000\nfor epoch in range(epochs):\n optimizer02.zero_grad()\n y_pred02 = nn02(x)\n ce02 = F.binary_cross_entropy(y_pred02, y)\n ce02.backward()\n optimizer02.step()\n if epoch % 1000 == 0:\n print(\"Epoch: {:4d}/{}\".format(epoch, epochs), end=\" \")\n print(\"Cost: {:.6f}\".format(ce02.item()))\n"
] | [
[
"torch.nn.functional.binary_cross_entropy",
"torch.nn.Linear",
"torch.FloatTensor"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
Hacky-DH/pytorch | [
"80dc4be615854570aa39a7e36495897d8a040ecc",
"80dc4be615854570aa39a7e36495897d8a040ecc",
"80dc4be615854570aa39a7e36495897d8a040ecc",
"80dc4be615854570aa39a7e36495897d8a040ecc",
"80dc4be615854570aa39a7e36495897d8a040ecc",
"80dc4be615854570aa39a7e36495897d8a040ecc",
"80dc4be615854570aa39a7e36495897d8a040ecc",
"80dc4be615854570aa39a7e36495897d8a040ecc",
"80dc4be615854570aa39a7e36495897d8a040ecc",
"80dc4be615854570aa39a7e36495897d8a040ecc",
"80dc4be615854570aa39a7e36495897d8a040ecc",
"80dc4be615854570aa39a7e36495897d8a040ecc",
"80dc4be615854570aa39a7e36495897d8a040ecc",
"80dc4be615854570aa39a7e36495897d8a040ecc",
"80dc4be615854570aa39a7e36495897d8a040ecc",
"80dc4be615854570aa39a7e36495897d8a040ecc",
"80dc4be615854570aa39a7e36495897d8a040ecc",
"80dc4be615854570aa39a7e36495897d8a040ecc",
"80dc4be615854570aa39a7e36495897d8a040ecc",
"80dc4be615854570aa39a7e36495897d8a040ecc",
"80dc4be615854570aa39a7e36495897d8a040ecc",
"80dc4be615854570aa39a7e36495897d8a040ecc",
"80dc4be615854570aa39a7e36495897d8a040ecc",
"80dc4be615854570aa39a7e36495897d8a040ecc",
"80dc4be615854570aa39a7e36495897d8a040ecc",
"80dc4be615854570aa39a7e36495897d8a040ecc",
"80dc4be615854570aa39a7e36495897d8a040ecc",
"80dc4be615854570aa39a7e36495897d8a040ecc",
"80dc4be615854570aa39a7e36495897d8a040ecc",
"80dc4be615854570aa39a7e36495897d8a040ecc",
"80dc4be615854570aa39a7e36495897d8a040ecc",
"80dc4be615854570aa39a7e36495897d8a040ecc",
"80dc4be615854570aa39a7e36495897d8a040ecc",
"80dc4be615854570aa39a7e36495897d8a040ecc",
"80dc4be615854570aa39a7e36495897d8a040ecc"
] | [
"benchmarks/distributed/ddp/compare/compare_ddp.py",
"caffe2/quantization/server/tanh_dnnlowp_op_test.py",
"caffe2/python/lazy_dyndep_test.py",
"test/test_gen_backend_stubs.py",
"torch/jit/__init__.py",
"torch/utils/data/sampler.py",
"torch/package/package_importer.py",
"caffe2/python/operator_test/rms_norm_op_test.py",
"test/distributed/elastic/events/lib_test.py",
"benchmarks/operator_benchmark/pt/sum_test.py",
"torch/_tensor_str.py",
"benchmarks/operator_benchmark/pt/diag_test.py",
"caffe2/python/operator_test/integral_image_ops_test.py",
"benchmarks/distributed/rpc/parameter_server/launcher.py",
"test/distributed/elastic/rendezvous/api_test.py",
"torch/optim/optimizer.py",
"test/onnx/model_defs/srresnet.py",
"caffe2/python/operator_test/top_k_test.py",
"test/mobile/custom_build/prepare_model.py",
"caffe2/python/operator_test/sinusoid_position_encoding_op_test.py",
"benchmarks/operator_benchmark/pt/quantization_test.py",
"torch/cuda/_utils.py",
"caffe2/python/caffe_translator_test.py",
"caffe2/python/layers_test.py",
"benchmarks/operator_benchmark/pt_extension/setup.py",
"test/fx/quantization.py",
"torch/cuda/graphs.py",
"torch/testing/_internal/distributed/rpc/examples/reinforcement_learning_rpc_test.py",
"test/cpp_api_parity/sample_module.py",
"caffe2/python/operator_test/rmac_regions_op_test.py",
"caffe2/python/operator_test/adagrad_test_helper.py",
"torch/nn/intrinsic/quantized/modules/linear_relu.py",
"caffe2/python/operator_test/rand_quantization_op_speed_test.py",
"caffe2/python/operator_test/apmeter_test.py",
"torch/autograd/grad_mode.py"
] | [
"\"\"\"\nA simple tool to compare the performance of different impls of\nDistributedDataParallel on resnet50, three flavors:\n\n1. DistributedDataParallel, which has a python wrapper and C++ core to do\n gradient distribution and reduction. It's current production version.\n\n2. PythonDDP with async gradient reduction.\n\n3. PythonDDP with synchrous gradient reduction.\n\nExample::\n >>> modify configs in main func\n >>> python compare_ddp.py\n >>> Sample out: compare_ddp_sample.md\n\"\"\"\n\nimport numpy as np\nimport os\nimport pickle\nimport glob\nimport python_ddp\nimport torch\nimport torch.distributed as dist\nimport torch.multiprocessing as mp\nimport torch.nn as nn\nimport torch.optim as optim\nimport torchvision.models as models\n\nfrom collections import OrderedDict\nfrom enum import Enum\nfrom tabulate import tabulate\nfrom torch.nn.parallel import DistributedDataParallel as DDP\n\nclass DDPOption(Enum):\n DDP_CPP_CORE = 1\n PYTHON_DDP_SYNC_REDUCTION = 2\n PYTHON_DDP_ASYNC_REDUCTION = 3\n\nclass LatencyData:\n __slots__ = [\"buffer_size_in_M\", \"ddp_option\", \"rank\", \"metrics\"]\n\n def __init__(self, buffer_size_in_M, ddp_option, rank, metrics):\n self.buffer_size_in_M = buffer_size_in_M\n self.ddp_option = ddp_option\n self.rank = rank\n self.metrics = metrics\n\ndef serialize(buffer_size_in_M, ddp_option, rank, metrics,\n data_dir=\"./tmp\", ext=\"ddpraw\"):\n if not os.path.exists(data_dir):\n print(f'{data_dir} not exist, mkdir {data_dir}')\n os.mkdir(data_dir)\n file_name = \"buffer_size_{}M_rank{}_{}.{}\".format(\n buffer_size_in_M, rank, ddp_option, ext)\n file_path = os.path.join(data_dir, file_name)\n print(\"Writing metrics to file: '{}'\".format(file_path))\n data = LatencyData(buffer_size_in_M, ddp_option, rank, metrics)\n with open(file_path, \"wb\") as f:\n pickle.dump(data, f, pickle.HIGHEST_PROTOCOL)\n print(f\"Wrote metrics to '{file_path}''\")\n\ndef load_detailed_metrics(data_dir=\"./tmp\", ext=\"ddpraw\"):\n assert os.path.exists(data_dir)\n file_pattern = os.path.join(data_dir, f\"*.{ext}\")\n files = glob.glob(file_pattern)\n print(\"load_detailed_metrics found {} files\".format(len(files)))\n buffer_size_to_metrics = OrderedDict()\n for file_path in files:\n with open(file_path, \"rb\") as f:\n data = pickle.load(f)\n # Add data to buffer_size_to_metrics\n buffer_size = data.buffer_size_in_M\n if buffer_size not in buffer_size_to_metrics:\n buffer_size_to_metrics[buffer_size] = {}\n metrics = buffer_size_to_metrics.get(buffer_size)\n assert metrics is not None\n metrics[data.ddp_option] = data.metrics\n return buffer_size_to_metrics\n\ndef setup(rank, world_size):\n os.environ['MASTER_ADDR'] = 'localhost'\n os.environ['MASTER_PORT'] = '12355'\n\n # initialize the process group\n dist.init_process_group(\"gloo\", rank=rank, world_size=world_size)\n\ndef create_ddp_model(module, rank, pg, ddp_option, buffer_size_in_M):\n \"\"\"Helper to create DDPModel. \"\"\"\n if ddp_option == DDPOption.DDP_CPP_CORE:\n ddp_model = DDP(module, device_ids=[rank],\n process_group=pg,\n bucket_cap_mb=buffer_size_in_M)\n ddp_model._set_static_graph()\n return ddp_model\n elif ddp_option == DDPOption.PYTHON_DDP_SYNC_REDUCTION:\n M = 2 ** 20\n return python_ddp.PythonDDP(module, pg, False, buffer_size=buffer_size_in_M * M)\n elif ddp_option == DDPOption.PYTHON_DDP_ASYNC_REDUCTION:\n M = 2 ** 20\n return python_ddp.PythonDDP(module, pg, True, buffer_size=buffer_size_in_M * M)\n else:\n raise NotImplementedError\n\ndef run_ddp(rank, world_size, epochs, ddp_option, buffer_size_in_M, warmup_iterations=20):\n print(f'Invoked run_ddp rank {rank}')\n assert epochs > warmup_iterations\n\n # Setup\n print(\"setting up ... \")\n setup(rank, world_size)\n torch.manual_seed(rank)\n torch.cuda.manual_seed(rank)\n device = torch.device('cuda:%d' % rank)\n print('setup done')\n\n # Create ResNet50 module and wrap in DDP module.\n pg = dist.distributed_c10d._get_default_group()\n model = models.resnet50().to(device)\n ddp_model = create_ddp_model(model, rank, pg, ddp_option, buffer_size_in_M)\n assert ddp_model is not None\n\n loss_fn = nn.MSELoss()\n optimizer = optim.SGD(ddp_model.parameters(), lr=0.001)\n\n # Container to hold: event -> list of events in milliseconds\n MODEL_FORWARD = \"forward\"\n MODEL_BACKWARD = \"backward\"\n metrics = {MODEL_FORWARD: [], MODEL_BACKWARD: []}\n\n for epoch in range(epochs):\n if epoch % 10 == 0:\n print(f'Epoch {epoch}/{epochs} ...')\n\n start = torch.cuda.Event(enable_timing=True)\n end = torch.cuda.Event(enable_timing=True)\n\n # TODO(bowangbj): Switch to real training set from ImageNet.\n inputs = torch.rand([32, 3, 224, 224], device=device)\n labels = torch.rand([32, 1000], device=device)\n\n # Forward\n start.record()\n outputs = ddp_model(inputs)\n loss = loss_fn(outputs, labels)\n\n end.record()\n torch.cuda.synchronize()\n if epoch >= warmup_iterations:\n metrics[MODEL_FORWARD].append(start.elapsed_time(end))\n\n # Backward\n start.record()\n loss.backward()\n # Reduce all grad, this is needed for non-DDP_CPP_CORE since the hook\n # for all_reduce does not exist yet.\n if ddp_option != DDPOption.DDP_CPP_CORE:\n ddp_model.all_reduce_grads()\n end.record()\n torch.cuda.synchronize()\n if epoch >= warmup_iterations:\n metrics[MODEL_BACKWARD].append(start.elapsed_time(end))\n\n # Optimization\n optimizer.step()\n optimizer.zero_grad()\n\n if rank == 0:\n print(f\"\\nMetrics for GPU {rank}, ddp_option={ddp_option}, buffer_size={buffer_size_in_M}M\")\n print(f\"Skipped {warmup_iterations} CUDA warmpup iterations. \")\n for step, elapsed_milliseconds in metrics.items():\n A = np.array(elapsed_milliseconds)\n print(' {N} iterations, {step}, mean={mean} ms, median={median} ms, p90={p90} ms, p99={p99} ms'.format(\n N=len(A), step=step, mean=np.mean(A),\n median=np.percentile(A, 50), p90=np.percentile(A, 90),\n p99=np.percentile(A, 99)))\n\n # Serialize the raw data to be used to compute summary. Didn't choose to\n # maintain a global object holding the metrics b/c mp.spawn tries to\n # fork all the arguments before spawning new process thus it's infeasible\n # save global states in an object.\n serialize(buffer_size_in_M, ddp_option, rank, metrics)\n\ndef append_delta(row_list, base, exp):\n percent = 100 * ((exp - base) / base)\n row_list.append(percent)\n\ndef print_summary(buffer_size_to_metrics):\n # metrics: {ddp_option, Metrics}\n # Metrics: step -> [latency]\n for buffer_size, metrics in buffer_size_to_metrics.items():\n assert DDPOption.DDP_CPP_CORE in metrics.keys()\n baseline = metrics.get(DDPOption.DDP_CPP_CORE)\n print(f\"=== Summary for buffer_size: {buffer_size}M === \")\n for step in baseline.keys():\n # step takes value from [forward, backward]\n # compute latency for each step into a table, each row is looks like\n # [option, mean, diff, mean, diff, p90, diff, p95, diff, p99, diff]\n data = []\n baseline_latencies = baseline.get(step)\n assert baseline_latencies is not None\n A_baseline = np.array(baseline_latencies)\n for ddp_option, exp_metrics in metrics.items():\n exp_latencies = exp_metrics.get(step)\n assert exp_latencies is not None\n A_exp = np.array(exp_latencies)\n # Yield option, mean, p50, p90, p95, p99 and delta.\n row = [ddp_option]\n row.append(np.mean(A_exp))\n append_delta(row, np.mean(A_baseline), np.mean(A_exp))\n for px in [50, 90, 95, 99]:\n base = np.percentile(A_baseline, px)\n exp = np.percentile(A_exp, px)\n row.append(exp)\n append_delta(row, base, exp)\n data.append(row)\n\n # Output buffer_size, step as a table.\n print(tabulate(data,\n headers=[f\"DDP: [{step}]\", \"Mean\", \"delta%\",\n \"mean\", \"delta%\", \"p90\", \"delta%\",\n \"p95\", \"delta%%\", \"p99\", \"delta%\"]))\n print(\"\\n\")\n\ndef main():\n world_size = 2\n epochs = 120\n\n # resnet50 model facts:\n # total_param_count = 161\n # total_elements = 25557032 ~= 24.37M\n # param_max_elements = 2359296 ~= 2.25M\n # Try different bucket sizes.\n buffer_size_in_mbs = [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27]\n print(\"buffer_size_in_mbs: \" + str(buffer_size_in_mbs))\n for buffer_size_in_M in buffer_size_in_mbs:\n print(\"\\n\\n=== NEW EXPERIMENT: buffer_size={}M, {} epochs, world_size={} ===\".format(\n buffer_size_in_M, epochs, world_size))\n options = [\n DDPOption.DDP_CPP_CORE,\n DDPOption.PYTHON_DDP_ASYNC_REDUCTION,\n DDPOption.PYTHON_DDP_SYNC_REDUCTION\n ]\n for option in options:\n print(\"Measuring option: {} ... \".format(option))\n mp.spawn(run_ddp,\n args=(world_size, epochs, option, buffer_size_in_M),\n nprocs=world_size,\n join=True)\n\n print(\"\\n Generating summaries ... \")\n buffer_size_to_metrics = load_detailed_metrics(data_dir=\"./tmp\", ext=\"ddpraw\")\n print_summary(buffer_size_to_metrics)\n\nif __name__ == \"__main__\" :\n main()\n",
"\n\nimport collections\n\nimport caffe2.python.hypothesis_test_util as hu\nimport hypothesis.strategies as st\nimport numpy as np\nfrom caffe2.python import core, dyndep, workspace\nfrom hypothesis import given, settings\n\n\ndyndep.InitOpsLibrary(\"//caffe2/caffe2/quantization/server:dnnlowp_ops\")\nworkspace.GlobalInit([\"caffe2\", \"--caffe2_omp_num_threads=11\"])\n\n\nclass DNNLowPTanhOpTest(hu.HypothesisTestCase):\n @given(size=st.integers(1024, 2048), is_empty=st.booleans(), **hu.gcs_cpu_only)\n @settings(max_examples=10, deadline=None)\n def test_dnnlowp_tanh(self, size, is_empty, gc, dc):\n if is_empty:\n size = 0\n\n X = (np.random.rand(size) * 10 - 5).astype(np.float32)\n\n Output = collections.namedtuple(\"Output\", [\"Y\", \"op_type\", \"engine\"])\n outputs = []\n\n op_engine_list = [(\"Tanh\", \"\"), (\"Tanh\", \"DNNLOWP\"), (\"Int8Tanh\", \"DNNLOWP\")]\n\n for op_type, engine in op_engine_list:\n net = core.Net(\"test_net\")\n\n if engine == \"DNNLOWP\":\n quantize = core.CreateOperator(\n \"Quantize\",\n [\"X\"],\n [\"X_q\"],\n engine=engine,\n device_option=gc,\n followed_by=\"Tanh\",\n )\n net.Proto().op.extend([quantize])\n\n tanh = core.CreateOperator(\n op_type,\n [\"X_q\" if engine == \"DNNLOWP\" else \"X\"],\n [\"Y_q\" if engine == \"DNNLOWP\" else \"Y\"],\n engine=engine,\n device_option=gc,\n )\n net.Proto().op.extend([tanh])\n\n if engine == \"DNNLOWP\":\n dequantize = core.CreateOperator(\n \"Dequantize\", [\"Y_q\"], [\"Y\"], engine=engine, device_option=gc\n )\n net.Proto().op.extend([dequantize])\n\n self.ws.create_blob(\"X\").feed(X, device_option=gc)\n self.ws.run(net)\n outputs.append(\n Output(Y=self.ws.blobs[\"Y\"].fetch(), op_type=op_type, engine=engine)\n )\n\n for o in outputs:\n np.testing.assert_allclose(o.Y, outputs[0].Y, atol=0.02, rtol=0)\n",
"#!/usr/bin/env python3\n\n\n\n\n\n\nfrom hypothesis import given, settings\nimport hypothesis.strategies as st\nfrom multiprocessing import Process\n\nimport numpy as np\nimport tempfile\nimport shutil\n\nimport caffe2.python.hypothesis_test_util as hu\nimport unittest\n\nop_engine = 'GLOO'\n\nclass TemporaryDirectory:\n def __enter__(self):\n self.tmpdir = tempfile.mkdtemp()\n return self.tmpdir\n\n def __exit__(self, type, value, traceback):\n shutil.rmtree(self.tmpdir)\n\n\ndef allcompare_process(filestore_dir, process_id, data, num_procs):\n from caffe2.python import core, data_parallel_model, workspace, lazy_dyndep\n from caffe2.python.model_helper import ModelHelper\n from caffe2.proto import caffe2_pb2\n lazy_dyndep.RegisterOpsLibrary(\"@/caffe2/caffe2/distributed:file_store_handler_ops\")\n\n workspace.RunOperatorOnce(\n core.CreateOperator(\n \"FileStoreHandlerCreate\", [], [\"store_handler\"], path=filestore_dir\n )\n )\n rendezvous = dict(\n kv_handler=\"store_handler\",\n shard_id=process_id,\n num_shards=num_procs,\n engine=op_engine,\n exit_nets=None\n )\n\n model = ModelHelper()\n model._rendezvous = rendezvous\n\n workspace.FeedBlob(\"test_data\", data)\n\n data_parallel_model._RunComparison(\n model, \"test_data\", core.DeviceOption(caffe2_pb2.CPU, 0)\n )\n\n\nclass TestLazyDynDepAllCompare(hu.HypothesisTestCase):\n @given(\n d=st.integers(1, 5), n=st.integers(2, 11), num_procs=st.integers(1, 8)\n )\n @settings(deadline=None)\n def test_allcompare(self, d, n, num_procs):\n dims = []\n for _ in range(d):\n dims.append(np.random.randint(1, high=n))\n test_data = np.random.ranf(size=tuple(dims)).astype(np.float32)\n\n with TemporaryDirectory() as tempdir:\n processes = []\n for idx in range(num_procs):\n process = Process(\n target=allcompare_process,\n args=(tempdir, idx, test_data, num_procs)\n )\n processes.append(process)\n process.start()\n\n while len(processes) > 0:\n process = processes.pop()\n process.join()\n\nclass TestLazyDynDepError(unittest.TestCase):\n def test_errorhandler(self):\n from caffe2.python import core, lazy_dyndep\n import tempfile\n\n with tempfile.NamedTemporaryFile() as f:\n lazy_dyndep.RegisterOpsLibrary(f.name)\n\n def handler(e):\n raise ValueError(\"test\")\n lazy_dyndep.SetErrorHandler(handler)\n with self.assertRaises(ValueError, msg=\"test\"):\n core.RefreshRegisteredOperators()\n\n def test_importaftererror(self):\n from caffe2.python import core, lazy_dyndep\n import tempfile\n\n with tempfile.NamedTemporaryFile() as f:\n lazy_dyndep.RegisterOpsLibrary(f.name)\n\n def handler(e):\n raise ValueError(\"test\")\n lazy_dyndep.SetErrorHandler(handler)\n with self.assertRaises(ValueError):\n core.RefreshRegisteredOperators()\n\n def handlernoop(e):\n raise\n lazy_dyndep.SetErrorHandler(handlernoop)\n lazy_dyndep.RegisterOpsLibrary(\"@/caffe2/caffe2/distributed:file_store_handler_ops\")\n core.RefreshRegisteredOperators()\n\n def test_workspacecreatenet(self):\n from caffe2.python import workspace, lazy_dyndep\n import tempfile\n\n with tempfile.NamedTemporaryFile() as f:\n lazy_dyndep.RegisterOpsLibrary(f.name)\n called = False\n\n def handler(e):\n raise ValueError(\"test\")\n lazy_dyndep.SetErrorHandler(handler)\n with self.assertRaises(ValueError, msg=\"test\"):\n workspace.CreateNet(\"fake\")\n\n\nif __name__ == \"__main__\":\n unittest.main()\n",
"import os\nimport tempfile\n\nfrom torch.testing._internal.common_utils import TestCase, run_tests\nimport tools.codegen.gen_backend_stubs\n\npath = os.path.dirname(os.path.realpath(__file__))\ngen_backend_stubs_path = os.path.join(path, '../tools/codegen/gen_backend_stubs.py')\n\n# gen_backend_stubs.py is an integration point that is called directly by external backends.\n# The tests here are to confirm that badly formed inputs result in reasonable error messages.\nclass TestGenBackendStubs(TestCase):\n\n def assert_success_from_gen_backend_stubs(self, yaml_str: str) -> str:\n with tempfile.NamedTemporaryFile(mode='w') as fp:\n fp.write(yaml_str)\n fp.flush()\n tools.codegen.gen_backend_stubs.run(fp.name, '', True)\n\n def get_errors_from_gen_backend_stubs(self, yaml_str: str) -> str:\n with tempfile.NamedTemporaryFile(mode='w') as fp:\n fp.write(yaml_str)\n fp.flush()\n try:\n tools.codegen.gen_backend_stubs.run(fp.name, '', True)\n except AssertionError as e:\n # Scrub out the temp file name from any error messages to simplify assertions.\n return str(e).replace(fp.name, '')\n self.fail('Expected gen_backend_stubs to raise an AssertionError, but it did not.')\n\n def test_valid_single_op(self):\n yaml_str = '''\\\nbackend: XLA\ncpp_namespace: torch_xla\nsupported:\n- abs'''\n self.assert_success_from_gen_backend_stubs(yaml_str)\n\n def test_valid_multiple_ops(self):\n yaml_str = '''\\\nbackend: XLA\ncpp_namespace: torch_xla\nsupported:\n- add.Tensor\n- abs'''\n self.assert_success_from_gen_backend_stubs(yaml_str)\n\n def test_valid_zero_ops(self):\n yaml_str = '''\\\nbackend: XLA\ncpp_namespace: torch_xla\nsupported:'''\n self.assert_success_from_gen_backend_stubs(yaml_str)\n\n def test_valid_zero_ops_doesnt_require_backend_dispatch_key(self):\n yaml_str = '''\\\nbackend: BAD_XLA\ncpp_namespace: torch_xla\nsupported:'''\n # External codegen on a yaml file with no operators is effectively a no-op,\n # so there's no reason to parse the backend\n self.assert_success_from_gen_backend_stubs(yaml_str)\n\n def test_valid_with_autograd_ops(self):\n yaml_str = '''\\\nbackend: XLA\ncpp_namespace: torch_xla\nsupported:\n- abs\nautograd:\n- add.Tensor'''\n # External codegen on a yaml file with no operators is effectively a no-op,\n # so there's no reason to parse the backend\n self.assert_success_from_gen_backend_stubs(yaml_str)\n\n def test_missing_backend(self):\n yaml_str = '''\\\ncpp_namespace: torch_xla\nsupported:\n- abs'''\n output_error = self.get_errors_from_gen_backend_stubs(yaml_str)\n self.assertExpectedInline(output_error, '''You must provide a value for \"backend\"''')\n\n def test_empty_backend(self):\n yaml_str = '''\\\nbackend:\ncpp_namespace: torch_xla\nsupported:\n- abs'''\n output_error = self.get_errors_from_gen_backend_stubs(yaml_str)\n self.assertExpectedInline(output_error, '''You must provide a value for \"backend\"''')\n\n def test_backend_invalid_dispatch_key(self):\n yaml_str = '''\\\nbackend: NOT_XLA\ncpp_namespace: torch_xla\nsupported:\n- abs'''\n output_error = self.get_errors_from_gen_backend_stubs(yaml_str)\n self.assertExpectedInline(output_error, '''\\\nunknown dispatch key NOT_XLA\n The provided value for \"backend\" must be a valid DispatchKey, but got NOT_XLA.''') # noqa: B950\n\n def test_missing_cpp_namespace(self):\n yaml_str = '''\\\nbackend: XLA\nsupported:\n- abs'''\n output_error = self.get_errors_from_gen_backend_stubs(yaml_str)\n self.assertExpectedInline(output_error, '''You must provide a value for \"cpp_namespace\"''')\n\n def test_whitespace_cpp_namespace(self):\n yaml_str = '''\\\nbackend: XLA\ncpp_namespace:\\t\nsupported:\n- abs'''\n output_error = self.get_errors_from_gen_backend_stubs(yaml_str)\n self.assertExpectedInline(output_error, '''You must provide a value for \"cpp_namespace\"''')\n\n # supported is a single item (it should be a list)\n def test_nonlist_supported(self):\n yaml_str = '''\\\nbackend: XLA\ncpp_namespace: torch_xla\nsupported: abs'''\n output_error = self.get_errors_from_gen_backend_stubs(yaml_str)\n self.assertExpectedInline(output_error, '''expected \"supported\" to be a list, but got: abs (of type <class 'str'>)''')\n\n # supported contains an op that isn't in native_functions.yaml\n def test_supported_invalid_op(self):\n yaml_str = '''\\\nbackend: XLA\ncpp_namespace: torch_xla\nsupported:\n- abs_BAD'''\n output_error = self.get_errors_from_gen_backend_stubs(yaml_str)\n self.assertExpectedInline(output_error, '''Found an invalid operator name: abs_BAD''')\n\n # The backend is valid, but doesn't have a valid autograd key. They can't override autograd kernels in that case.\n # Only using Vulkan here because it has a valid backend key but not an autograd key- if this changes we can update the test.\n def test_backend_has_no_autograd_key_but_provides_entries(self):\n yaml_str = '''\\\nbackend: Vulkan\ncpp_namespace: torch_vulkan\nsupported:\n- add\nautograd:\n- sub'''\n output_error = self.get_errors_from_gen_backend_stubs(yaml_str)\n self.assertExpectedInline(output_error, '''Found an invalid operator name: add''') # noqa: B950\n\n # in an operator group, currently all operators must either be registered to the backend or autograd kernel.\n # Here, functional and out mismatch\n def test_backend_autograd_kernel_mismatch_out_functional(self):\n yaml_str = '''\\\nbackend: XLA\ncpp_namespace: torch_xla\nsupported:\n- add.Tensor\nautograd:\n- add.out'''\n output_error = self.get_errors_from_gen_backend_stubs(yaml_str)\n self.assertExpectedInline(output_error, '''Currently, all variants of an op must either be registered to a backend key, or to a backend's autograd key. They cannot be mix and matched. If this is something you need, feel free to create an issue! add is listed under \"supported\", but add_out is listed under \"autograd\".''') # noqa: B950\n\n # in an operator group, currently all operators must either be registered to the backend or autograd kernel.\n # Here, functional and inplace mismatch\n def test_backend_autograd_kernel_mismatch_functional_inplace(self):\n yaml_str = '''\\\nbackend: XLA\ncpp_namespace: torch_xla\nsupported:\n- add.Tensor\nautograd:\n- add_.Tensor'''\n output_error = self.get_errors_from_gen_backend_stubs(yaml_str)\n self.assertExpectedInline(output_error, '''Currently, all variants of an op must either be registered to a backend key, or to a backend's autograd key. They cannot be mix and matched. If this is something you need, feel free to create an issue! add is listed under \"supported\", but add_ is listed under \"autograd\".''') # noqa: B950\n\n # Currently, the same operator can't be listed under both 'supported' and 'autograd', which would\n # involve registering the same kernel to both the XLA and AutogradXLA keys.\n # If we need that functionality in the future, we'll need to augment the codegen.\n def test_op_appears_in_supported_and_autograd_lists(self):\n yaml_str = '''\\\nbackend: XLA\ncpp_namespace: torch_xla\nsupported:\n- add.Tensor\nautograd:\n- add.Tensor'''\n output_error = self.get_errors_from_gen_backend_stubs(yaml_str)\n self.assertExpectedInline(output_error, '''Currently, all variants of an op must either be registered to a backend key, or to a backend's autograd key. They cannot be mix and matched. If this is something you need, feel free to create an issue! add is listed under \"supported\", but add is listed under \"autograd\".''') # noqa: B950\n\n # unrecognized extra yaml key\n def test_unrecognized_key(self):\n yaml_str = '''\\\nbackend: XLA\ncpp_namespace: torch_xla\nsupported:\n- abs\ninvalid_key: invalid_val'''\n output_error = self.get_errors_from_gen_backend_stubs(yaml_str)\n self.assertExpectedInline(output_error, ''' contains unexpected keys: invalid_key. Only the following keys are supported: backend, cpp_namespace, extra_headers, supported, autograd''') # noqa: B950\n\n\nif __name__ == '__main__':\n run_tests()\n",
"import torch._C\n\nfrom contextlib import contextmanager\nfrom typing import Iterator\n\nfrom torch.utils import set_module\n\n# These are imported so users can access them from the `torch.jit` module\nfrom torch._jit_internal import (\n Final,\n Future,\n _IgnoreContextManager,\n _overload,\n _overload_method,\n ignore,\n _isinstance,\n is_scripting,\n export,\n unused,\n)\nfrom torch.jit._script import (\n script,\n Attribute,\n ScriptModule,\n script_method,\n RecursiveScriptClass,\n RecursiveScriptModule,\n ScriptWarning,\n interface,\n CompilationUnit,\n ScriptFunction,\n _ScriptProfile,\n _unwrap_optional,\n)\nfrom torch.jit._trace import (\n trace,\n trace_module,\n TracedModule,\n TracerWarning,\n TracingCheckError,\n is_tracing,\n ONNXTracedModule,\n TopLevelTracedModule,\n _unique_state_dict,\n _flatten,\n _script_if_tracing,\n _get_trace_graph,\n)\nfrom torch.jit._async import fork, wait\nfrom torch.jit._serialization import save, load\nfrom torch.jit._fuser import optimized_execution, fuser, last_executed_optimized_graph\nfrom torch.jit._freeze import freeze, optimize_for_inference, run_frozen_optimizations\n\n# For backwards compatibility\n_fork = fork\n_wait = wait\n\n\ndef export_opnames(m):\n r\"\"\"\n Generates new bytecode for a Script module and returns what the op list\n would be for a Script Module based off the current code base. If you\n have a LiteScriptModule and want to get the currently present\n list of ops call _export_operator_list instead.\n \"\"\"\n return torch._C._export_opnames(m._c)\n\n\n# torch.jit.Error\nError = torch._C.JITException\nset_module(Error, \"torch.jit\")\n# This is not perfect but works in common cases\nError.__name__ = \"Error\"\nError.__qualname__ = \"Error\"\n\n# for use in python if using annotate\ndef annotate(the_type, the_value):\n \"\"\"\n This method is a pass-through function that returns `the_value`, used to hint TorchScript\n compiler the type of `the_value`. It is a no-op when running outside of TorchScript.\n\n Though TorchScript can infer correct type for most Python expressions, there are some cases where\n type inference can be wrong, including:\n\n - Empty containers like `[]` and `{}`, which TorchScript assumes to be container of `Tensor`\n - Optional types like `Optional[T]` but assigned a valid value of type `T`, TorchScript would assume\n it is type `T` rather than `Optional[T]`\n\n Note that `annotate()` does not help in `__init__` method of `torch.nn.Module` subclasses because it\n is executed in eager mode. To annotate types of `torch.nn.Module` attributes,\n use :meth:`~torch.jit.Annotate` instead.\n\n Example:\n\n .. testcode::\n\n import torch\n from typing import Dict\n\n @torch.jit.script\n def fn():\n # Telling TorchScript that this empty dictionary is a (str -> int) dictionary\n # instead of default dictionary type of (str -> Tensor).\n d = torch.jit.annotate(Dict[str, int], {})\n\n # Without `torch.jit.annotate` above, following statement would fail because of\n # type mismatch.\n d[\"name\"] = 20\n\n .. testcleanup::\n\n del fn\n\n Args:\n the_type: Python type that should be passed to TorchScript compiler as type hint for `the_value`\n the_value: Value or expression to hint type for.\n\n Returns:\n `the_value` is passed back as return value.\n \"\"\"\n return the_value\n\n\ndef script_if_tracing(fn):\n \"\"\"\n Compiles ``fn`` when it is first called during tracing. ``torch.jit.script``\n has a non-negligible start up time when it is first called due to\n lazy-initializations of many compiler builtins. Therefore you should not use\n it in library code. However, you may want to have parts of your library work\n in tracing even if they use control flow. In these cases, you should use\n ``@torch.jit.script_if_tracing`` to substitute for\n ``torch.jit.script``.\n\n Args:\n fn: A function to compile.\n\n Returns:\n If called during tracing, a :class:`ScriptFunction` created by `torch.jit.script` is returned.\n Otherwise, the original function `fn` is returned.\n \"\"\"\n\n return _script_if_tracing(fn)\n\n\n# for torch.jit.isinstance\ndef isinstance(obj, target_type):\n \"\"\"\n This function provides for conatiner type refinement in TorchScript. It can refine\n parameterized containers of the List, Dict, Tuple, and Optional types. E.g. ``List[str]``,\n ``Dict[str, List[torch.Tensor]]``, ``Optional[Tuple[int,str,int]]``. It can also\n refine basic types such as bools and ints that are available in TorchScript.\n\n Args:\n obj: object to refine the type of\n target_type: type to try to refine obj to\n Returns:\n ``bool``: True if obj was successfully refined to the type of target_type,\n False otherwise with no new type refinement\n\n\n Example (using ``torch.jit.isinstance`` for type refinement):\n .. testcode::\n\n import torch\n from typing import Any, Dict, List\n\n class MyModule(torch.nn.Module):\n def __init__(self):\n super(MyModule, self).__init__()\n\n def forward(self, input: Any): # note the Any type\n if torch.jit.isinstance(input, List[torch.Tensor]):\n for t in input:\n y = t.clamp(0, 0.5)\n elif torch.jit.isinstance(input, Dict[str, str]):\n for val in input.values():\n print(val)\n\n m = torch.jit.script(MyModule())\n x = [torch.rand(3,3), torch.rand(4,3)]\n m(x)\n y = {\"key1\":\"val1\",\"key2\":\"val2\"}\n m(y)\n \"\"\"\n return _isinstance(obj, target_type)\n\n\n# Context manager for globally hiding source ranges when printing graphs.\n# Note that these functions are exposed to Python as static members of the\n# Graph class, so mypy checks need to be skipped.\n@contextmanager\ndef _hide_source_ranges() -> Iterator[None]:\n old_enable_source_ranges = torch._C.Graph.global_print_source_ranges # type: ignore[attr-defined]\n try:\n torch._C.Graph.set_global_print_source_ranges(False) # type: ignore[attr-defined]\n yield\n finally:\n torch._C.Graph.set_global_print_source_ranges(old_enable_source_ranges) # type: ignore[attr-defined]\n\n\nif not torch._C._jit_init():\n raise RuntimeError(\"JIT initialization failed\")\n",
"import torch\nfrom torch import Tensor\n\nfrom typing import Iterator, Optional, Sequence, List, TypeVar, Generic, Sized\n\nT_co = TypeVar('T_co', covariant=True)\n\nclass Sampler(Generic[T_co]):\n r\"\"\"Base class for all Samplers.\n\n Every Sampler subclass has to provide an :meth:`__iter__` method, providing a\n way to iterate over indices of dataset elements, and a :meth:`__len__` method\n that returns the length of the returned iterators.\n\n .. note:: The :meth:`__len__` method isn't strictly required by\n :class:`~torch.utils.data.DataLoader`, but is expected in any\n calculation involving the length of a :class:`~torch.utils.data.DataLoader`.\n \"\"\"\n\n def __init__(self, data_source: Optional[Sized]) -> None:\n pass\n\n def __iter__(self) -> Iterator[T_co]:\n raise NotImplementedError\n\n # NOTE [ Lack of Default `__len__` in Python Abstract Base Classes ]\n #\n # Many times we have an abstract class representing a collection/iterable of\n # data, e.g., `torch.utils.data.Sampler`, with its subclasses optionally\n # implementing a `__len__` method. In such cases, we must make sure to not\n # provide a default implementation, because both straightforward default\n # implementations have their issues:\n #\n # + `return NotImplemented`:\n # Calling `len(subclass_instance)` raises:\n # TypeError: 'NotImplementedType' object cannot be interpreted as an integer\n #\n # + `raise NotImplementedError()`:\n # This prevents triggering some fallback behavior. E.g., the built-in\n # `list(X)` tries to call `len(X)` first, and executes a different code\n # path if the method is not found or `NotImplemented` is returned, while\n # raising an `NotImplementedError` will propagate and and make the call\n # fail where it could have use `__iter__` to complete the call.\n #\n # Thus, the only two sensible things to do are\n #\n # + **not** provide a default `__len__`.\n #\n # + raise a `TypeError` instead, which is what Python uses when users call\n # a method that is not defined on an object.\n # (@ssnl verifies that this works on at least Python 3.7.)\n\n\nclass SequentialSampler(Sampler[int]):\n r\"\"\"Samples elements sequentially, always in the same order.\n\n Args:\n data_source (Dataset): dataset to sample from\n \"\"\"\n data_source: Sized\n\n def __init__(self, data_source: Sized) -> None:\n self.data_source = data_source\n\n def __iter__(self) -> Iterator[int]:\n return iter(range(len(self.data_source)))\n\n def __len__(self) -> int:\n return len(self.data_source)\n\n\nclass RandomSampler(Sampler[int]):\n r\"\"\"Samples elements randomly. If without replacement, then sample from a shuffled dataset.\n If with replacement, then user can specify :attr:`num_samples` to draw.\n\n Args:\n data_source (Dataset): dataset to sample from\n replacement (bool): samples are drawn on-demand with replacement if ``True``, default=``False``\n num_samples (int): number of samples to draw, default=`len(dataset)`. This argument\n is supposed to be specified only when `replacement` is ``True``.\n generator (Generator): Generator used in sampling.\n \"\"\"\n data_source: Sized\n replacement: bool\n\n def __init__(self, data_source: Sized, replacement: bool = False,\n num_samples: Optional[int] = None, generator=None) -> None:\n self.data_source = data_source\n self.replacement = replacement\n self._num_samples = num_samples\n self.generator = generator\n\n if not isinstance(self.replacement, bool):\n raise TypeError(\"replacement should be a boolean value, but got \"\n \"replacement={}\".format(self.replacement))\n\n if self._num_samples is not None and not replacement:\n raise ValueError(\"With replacement=False, num_samples should not be specified, \"\n \"since a random permute will be performed.\")\n\n if not isinstance(self.num_samples, int) or self.num_samples <= 0:\n raise ValueError(\"num_samples should be a positive integer \"\n \"value, but got num_samples={}\".format(self.num_samples))\n\n @property\n def num_samples(self) -> int:\n # dataset size might change at runtime\n if self._num_samples is None:\n return len(self.data_source)\n return self._num_samples\n\n def __iter__(self) -> Iterator[int]:\n n = len(self.data_source)\n if self.generator is None:\n self.generator = torch.Generator()\n self.generator.manual_seed(int(torch.empty((), dtype=torch.int64).random_().item()))\n\n if self.replacement:\n for _ in range(self.num_samples // 32):\n yield from torch.randint(high=n, size=(32,), dtype=torch.int64, generator=self.generator).tolist()\n yield from torch.randint(high=n, size=(self.num_samples % 32,), dtype=torch.int64, generator=self.generator).tolist()\n else:\n yield from torch.randperm(n, generator=self.generator).tolist()\n\n def __len__(self) -> int:\n return self.num_samples\n\n\nclass SubsetRandomSampler(Sampler[int]):\n r\"\"\"Samples elements randomly from a given list of indices, without replacement.\n\n Args:\n indices (sequence): a sequence of indices\n generator (Generator): Generator used in sampling.\n \"\"\"\n indices: Sequence[int]\n\n def __init__(self, indices: Sequence[int], generator=None) -> None:\n self.indices = indices\n self.generator = generator\n\n def __iter__(self) -> Iterator[int]:\n return (self.indices[i] for i in torch.randperm(len(self.indices), generator=self.generator))\n\n def __len__(self) -> int:\n return len(self.indices)\n\n\nclass WeightedRandomSampler(Sampler[int]):\n r\"\"\"Samples elements from ``[0,..,len(weights)-1]`` with given probabilities (weights).\n\n Args:\n weights (sequence) : a sequence of weights, not necessary summing up to one\n num_samples (int): number of samples to draw\n replacement (bool): if ``True``, samples are drawn with replacement.\n If not, they are drawn without replacement, which means that when a\n sample index is drawn for a row, it cannot be drawn again for that row.\n generator (Generator): Generator used in sampling.\n\n Example:\n >>> list(WeightedRandomSampler([0.1, 0.9, 0.4, 0.7, 3.0, 0.6], 5, replacement=True))\n [4, 4, 1, 4, 5]\n >>> list(WeightedRandomSampler([0.9, 0.4, 0.05, 0.2, 0.3, 0.1], 5, replacement=False))\n [0, 1, 4, 3, 2]\n \"\"\"\n weights: Tensor\n num_samples: int\n replacement: bool\n\n def __init__(self, weights: Sequence[float], num_samples: int,\n replacement: bool = True, generator=None) -> None:\n if not isinstance(num_samples, int) or isinstance(num_samples, bool) or \\\n num_samples <= 0:\n raise ValueError(\"num_samples should be a positive integer \"\n \"value, but got num_samples={}\".format(num_samples))\n if not isinstance(replacement, bool):\n raise ValueError(\"replacement should be a boolean value, but got \"\n \"replacement={}\".format(replacement))\n self.weights = torch.as_tensor(weights, dtype=torch.double)\n self.num_samples = num_samples\n self.replacement = replacement\n self.generator = generator\n\n def __iter__(self) -> Iterator[int]:\n rand_tensor = torch.multinomial(self.weights, self.num_samples, self.replacement, generator=self.generator)\n return iter(rand_tensor.tolist())\n\n def __len__(self) -> int:\n return self.num_samples\n\n\nclass BatchSampler(Sampler[List[int]]):\n r\"\"\"Wraps another sampler to yield a mini-batch of indices.\n\n Args:\n sampler (Sampler or Iterable): Base sampler. Can be any iterable object\n batch_size (int): Size of mini-batch.\n drop_last (bool): If ``True``, the sampler will drop the last batch if\n its size would be less than ``batch_size``\n\n Example:\n >>> list(BatchSampler(SequentialSampler(range(10)), batch_size=3, drop_last=False))\n [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9]]\n >>> list(BatchSampler(SequentialSampler(range(10)), batch_size=3, drop_last=True))\n [[0, 1, 2], [3, 4, 5], [6, 7, 8]]\n \"\"\"\n\n def __init__(self, sampler: Sampler[int], batch_size: int, drop_last: bool) -> None:\n # Since collections.abc.Iterable does not check for `__getitem__`, which\n # is one way for an object to be an iterable, we don't do an `isinstance`\n # check here.\n if not isinstance(batch_size, int) or isinstance(batch_size, bool) or \\\n batch_size <= 0:\n raise ValueError(\"batch_size should be a positive integer value, \"\n \"but got batch_size={}\".format(batch_size))\n if not isinstance(drop_last, bool):\n raise ValueError(\"drop_last should be a boolean value, but got \"\n \"drop_last={}\".format(drop_last))\n self.sampler = sampler\n self.batch_size = batch_size\n self.drop_last = drop_last\n\n def __iter__(self) -> Iterator[List[int]]:\n batch = []\n for idx in self.sampler:\n batch.append(idx)\n if len(batch) == self.batch_size:\n yield batch\n batch = []\n if len(batch) > 0 and not self.drop_last:\n yield batch\n\n def __len__(self) -> int:\n # Can only be called if self.sampler has __len__ implemented\n # We cannot enforce this condition, so we turn off typechecking for the\n # implementation below.\n # Somewhat related: see NOTE [ Lack of Default `__len__` in Python Abstract Base Classes ]\n if self.drop_last:\n return len(self.sampler) // self.batch_size # type: ignore[arg-type]\n else:\n return (len(self.sampler) + self.batch_size - 1) // self.batch_size # type: ignore[arg-type]\n",
"import builtins\nimport importlib\nimport inspect\nimport io\nimport linecache\nimport os.path\nimport types\nfrom contextlib import contextmanager\nfrom pathlib import Path\nfrom typing import cast, Any, BinaryIO, Callable, Dict, List, Optional, Union\nfrom weakref import WeakValueDictionary\n\nimport torch\nfrom torch.serialization import _get_restore_location, _maybe_decode_ascii\n\nfrom ._directory_reader import DirectoryReader\nfrom ._importlib import (\n _calc___package__,\n _normalize_line_endings,\n _normalize_path,\n _resolve_name,\n _sanity_check,\n)\nfrom ._mangling import PackageMangler, demangle\nfrom ._package_unpickler import PackageUnpickler\nfrom .file_structure_representation import Directory, _create_directory_from_file_list\nfrom .glob_group import GlobPattern\nfrom .importer import Importer\n\n\nclass PackageImporter(Importer):\n \"\"\"Importers allow you to load code written to packages by :class:`PackageExporter`.\n Code is loaded in a hermetic way, using files from the package\n rather than the normal python import system. This allows\n for the packaging of PyTorch model code and data so that it can be run\n on a server or used in the future for transfer learning.\n\n The importer for packages ensures that code in the module can only be loaded from\n within the package, except for modules explicitly listed as external during export.\n The file ``extern_modules`` in the zip archive lists all the modules that a package externally depends on.\n This prevents \"implicit\" dependencies where the package runs locally because it is importing\n a locally-installed package, but then fails when the package is copied to another machine.\n \"\"\"\n\n \"\"\"The dictionary of already loaded modules from this package, equivalent to ``sys.modules`` but\n local to this importer.\n \"\"\"\n modules: Dict[str, types.ModuleType]\n\n def __init__(\n self,\n file_or_buffer: Union[str, torch._C.PyTorchFileReader, Path, BinaryIO],\n module_allowed: Callable[[str], bool] = lambda module_name: True,\n ):\n \"\"\"Open ``file_or_buffer`` for importing. This checks that the imported package only requires modules\n allowed by ``module_allowed``\n\n Args:\n file_or_buffer: a file-like object (has to implement :meth:`read`, :meth:`readline`, :meth:`tell`, and :meth:`seek`),\n a string, or an ``os.PathLike`` object containing a filename.\n module_allowed (Callable[[str], bool], optional): A method to determine if a externally provided module\n should be allowed. Can be used to ensure packages loaded do not depend on modules that the server\n does not support. Defaults to allowing anything.\n\n Raises:\n ImportError: If the package will use a disallowed module.\n \"\"\"\n self.zip_reader: Any\n if isinstance(file_or_buffer, torch._C.PyTorchFileReader):\n self.filename = \"<pytorch_file_reader>\"\n self.zip_reader = file_or_buffer\n elif isinstance(file_or_buffer, (Path, str)):\n self.filename = str(file_or_buffer)\n if not os.path.isdir(self.filename):\n self.zip_reader = torch._C.PyTorchFileReader(self.filename)\n else:\n self.zip_reader = DirectoryReader(self.filename)\n else:\n self.filename = \"<binary>\"\n self.zip_reader = torch._C.PyTorchFileReader(file_or_buffer)\n\n self.root = _PackageNode(None)\n self.modules = {}\n self.extern_modules = self._read_extern()\n\n for extern_module in self.extern_modules:\n if not module_allowed(extern_module):\n raise ImportError(\n f\"package '{file_or_buffer}' needs the external module '{extern_module}' \"\n f\"but that module has been disallowed\"\n )\n self._add_extern(extern_module)\n\n for fname in self.zip_reader.get_all_records():\n self._add_file(fname)\n\n self.patched_builtins = builtins.__dict__.copy()\n self.patched_builtins[\"__import__\"] = self.__import__\n # Allow packaged modules to reference their PackageImporter\n self.modules[\"torch_package_importer\"] = self # type: ignore[assignment]\n\n self._mangler = PackageMangler()\n\n # used for reduce deserializaiton\n self.storage_context: Any = None\n self.last_map_location = None\n\n # used for torch.serialization._load\n self.Unpickler = lambda *args, **kwargs: PackageUnpickler(self, *args, **kwargs)\n\n def import_module(self, name: str, package=None):\n \"\"\"Load a module from the package if it hasn't already been loaded, and then return\n the module. Modules are loaded locally\n to the importer and will appear in ``self.modules`` rather than ``sys.modules``.\n\n Args:\n name (str): Fully qualified name of the module to load.\n package ([type], optional): Unused, but present to match the signature of importlib.import_module. Defaults to ``None``.\n\n Returns:\n types.ModuleType: The (possibly already) loaded module.\n \"\"\"\n return self._gcd_import(name)\n\n def load_binary(self, package: str, resource: str) -> bytes:\n \"\"\"Load raw bytes.\n\n Args:\n package (str): The name of module package (e.g. ``\"my_package.my_subpackage\"``).\n resource (str): The unique name for the resource.\n\n Returns:\n bytes: The loaded data.\n \"\"\"\n\n path = self._zipfile_path(package, resource)\n return self.zip_reader.get_record(path)\n\n def load_text(\n self,\n package: str,\n resource: str,\n encoding: str = \"utf-8\",\n errors: str = \"strict\",\n ) -> str:\n \"\"\"Load a string.\n\n Args:\n package (str): The name of module package (e.g. ``\"my_package.my_subpackage\"``).\n resource (str): The unique name for the resource.\n encoding (str, optional): Passed to ``decode``. Defaults to ``'utf-8'``.\n errors (str, optional): Passed to ``decode``. Defaults to ``'strict'``.\n\n Returns:\n str: The loaded text.\n \"\"\"\n data = self.load_binary(package, resource)\n return data.decode(encoding, errors)\n\n def load_pickle(self, package: str, resource: str, map_location=None) -> Any:\n \"\"\"Unpickles the resource from the package, loading any modules that are needed to construct the objects\n using :meth:`import_module`.\n\n Args:\n package (str): The name of module package (e.g. ``\"my_package.my_subpackage\"``).\n resource (str): The unique name for the resource.\n map_location: Passed to `torch.load` to determine how tensors are mapped to devices. Defaults to ``None``.\n\n Returns:\n Any: The unpickled object.\n \"\"\"\n pickle_file = self._zipfile_path(package, resource)\n restore_location = _get_restore_location(map_location)\n loaded_storages = {}\n loaded_reduces = {}\n storage_context = torch._C.DeserializationStorageContext()\n\n def load_tensor(data_type, size, key, location, restore_location):\n name = f\"{int(key)}.storage\"\n dtype = data_type(0).dtype\n\n if storage_context.has_storage(name):\n storage = storage_context.get_storage(name, dtype).storage()\n else:\n tensor = self.zip_reader.get_storage_from_record(\n \".data/\" + name, size, dtype\n )\n if isinstance(self.zip_reader, torch._C.PyTorchFileReader):\n storage_context.add_storage(name, tensor)\n storage = tensor.storage()\n loaded_storages[key] = restore_location(storage, location)\n\n def persistent_load(saved_id):\n assert isinstance(saved_id, tuple)\n typename = _maybe_decode_ascii(saved_id[0])\n data = saved_id[1:]\n\n if typename == \"storage\":\n data_type, key, location, size = data\n if key not in loaded_storages:\n load_tensor(\n data_type,\n size,\n key,\n _maybe_decode_ascii(location),\n restore_location,\n )\n storage = loaded_storages[key]\n return storage\n elif typename == \"reduce_package\":\n # to fix BC breaking change, objects on this load path\n # will be loaded multiple times erroneously\n if len(data) == 2:\n func, args = data\n return func(self, *args)\n reduce_id, func, args = data\n if reduce_id not in loaded_reduces:\n loaded_reduces[reduce_id] = func(self, *args)\n return loaded_reduces[reduce_id]\n else:\n f\"Unknown typename for persistent_load, expected 'storage' or 'reduce_package' but got '{typename}'\"\n\n # Load the data (which may in turn use `persistent_load` to load tensors)\n data_file = io.BytesIO(self.zip_reader.get_record(pickle_file))\n unpickler = self.Unpickler(data_file)\n unpickler.persistent_load = persistent_load\n\n @contextmanager\n def set_deserialization_context():\n # to let reduce_package access deserializaiton context\n self.storage_context = storage_context\n self.last_map_location = map_location\n try:\n yield\n finally:\n self.storage_context = None\n self.last_map_location = None\n\n with set_deserialization_context():\n result = unpickler.load()\n\n # TODO from zdevito:\n # This stateful weird function will need to be removed in our efforts\n # to unify the format. It has a race condition if multiple python\n # threads try to read independent files\n torch._utils._validate_loaded_sparse_tensors()\n\n return result\n\n def id(self):\n \"\"\"\n Returns internal identifier that torch.package uses to distinguish :class:`PackageImporter` instances.\n Looks like::\n\n <torch_package_0>\n \"\"\"\n return self._mangler.parent_name()\n\n def file_structure(\n self, *, include: \"GlobPattern\" = \"**\", exclude: \"GlobPattern\" = ()\n ) -> Directory:\n \"\"\"Returns a file structure representation of package's zipfile.\n\n Args:\n include (Union[List[str], str]): An optional string e.g. ``\"my_package.my_subpackage\"``, or optional list of strings\n for the names of the files to be inluded in the zipfile representation. This can also be\n a glob-style pattern, as described in :meth:`PackageExporter.mock`\n\n exclude (Union[List[str], str]): An optional pattern that excludes files whose name match the pattern.\n\n Returns:\n :class:`Directory`\n \"\"\"\n return _create_directory_from_file_list(\n self.filename, self.zip_reader.get_all_records(), include, exclude\n )\n\n def _read_extern(self):\n return (\n self.zip_reader.get_record(\".data/extern_modules\")\n .decode(\"utf-8\")\n .splitlines(keepends=False)\n )\n\n def _make_module(\n self, name: str, filename: Optional[str], is_package: bool, parent: str\n ):\n mangled_filename = self._mangler.mangle(filename) if filename else None\n spec = importlib.machinery.ModuleSpec(\n name,\n self, # type: ignore[arg-type]\n origin=\"<package_importer>\",\n is_package=is_package,\n )\n module = importlib.util.module_from_spec(spec)\n self.modules[name] = module\n module.__name__ = self._mangler.mangle(name)\n ns = module.__dict__\n ns[\"__spec__\"] = spec\n ns[\"__loader__\"] = self\n ns[\"__file__\"] = mangled_filename\n ns[\"__cached__\"] = None\n ns[\"__builtins__\"] = self.patched_builtins\n ns[\"__torch_package__\"] = True\n\n # Add this module to our private global registry. It should be unique due to mangling.\n assert module.__name__ not in _package_imported_modules\n _package_imported_modules[module.__name__] = module\n\n # pre-emptively install on the parent to prevent IMPORT_FROM from trying to\n # access sys.modules\n self._install_on_parent(parent, name, module)\n\n if filename is not None:\n assert mangled_filename is not None\n # pre-emptively install the source in `linecache` so that stack traces,\n # `inspect`, etc. work.\n assert filename not in linecache.cache # type: ignore[attr-defined]\n linecache.lazycache(mangled_filename, ns)\n\n code = self._compile_source(filename, mangled_filename)\n exec(code, ns)\n\n return module\n\n def _load_module(self, name: str, parent: str):\n cur: _PathNode = self.root\n for atom in name.split(\".\"):\n if not isinstance(cur, _PackageNode) or atom not in cur.children:\n raise ModuleNotFoundError(\n f'No module named \"{name}\" in self-contained archive \"{self.filename}\"'\n f\" and the module is also not in the list of allowed external modules: {self.extern_modules}\",\n name=name,\n )\n cur = cur.children[atom]\n if isinstance(cur, _ExternNode):\n module = self.modules[name] = importlib.import_module(name)\n return module\n return self._make_module(name, cur.source_file, isinstance(cur, _PackageNode), parent) # type: ignore[attr-defined]\n\n def _compile_source(self, fullpath: str, mangled_filename: str):\n source = self.zip_reader.get_record(fullpath)\n source = _normalize_line_endings(source)\n return compile(source, mangled_filename, \"exec\", dont_inherit=True)\n\n # note: named `get_source` so that linecache can find the source\n # when this is the __loader__ of a module.\n def get_source(self, module_name) -> str:\n # linecache calls `get_source` with the `module.__name__` as the argument, so we must demangle it here.\n module = self.import_module(demangle(module_name))\n return self.zip_reader.get_record(demangle(module.__file__)).decode(\"utf-8\")\n\n # note: named `get_resource_reader` so that importlib.resources can find it.\n # This is otherwise considered an internal method.\n def get_resource_reader(self, fullname):\n try:\n package = self._get_package(fullname)\n except ImportError:\n return None\n if package.__loader__ is not self:\n return None\n return _PackageResourceReader(self, fullname)\n\n def _install_on_parent(self, parent: str, name: str, module: types.ModuleType):\n if not parent:\n return\n # Set the module as an attribute on its parent.\n parent_module = self.modules[parent]\n if parent_module.__loader__ is self:\n setattr(parent_module, name.rpartition(\".\")[2], module)\n\n # note: copied from cpython's import code, with call to create module replaced with _make_module\n def _do_find_and_load(self, name):\n path = None\n parent = name.rpartition(\".\")[0]\n if parent:\n if parent not in self.modules:\n self._gcd_import(parent)\n # Crazy side-effects!\n if name in self.modules:\n return self.modules[name]\n parent_module = self.modules[parent]\n try:\n path = parent_module.__path__ # type: ignore[attr-defined]\n except AttributeError:\n msg = (_ERR_MSG + \"; {!r} is not a package\").format(name, parent)\n raise ModuleNotFoundError(msg, name=name) from None\n\n module = self._load_module(name, parent)\n\n self._install_on_parent(parent, name, module)\n\n return module\n\n # note: copied from cpython's import code\n def _find_and_load(self, name):\n module = self.modules.get(name, _NEEDS_LOADING)\n if module is _NEEDS_LOADING:\n return self._do_find_and_load(name)\n\n if module is None:\n message = \"import of {} halted; \" \"None in sys.modules\".format(name)\n raise ModuleNotFoundError(message, name=name)\n\n # To handle https://github.com/pytorch/pytorch/issues/57490, where std's\n # creation of fake submodules via the hacking of sys.modules is not import\n # friendly\n if name == \"os\":\n self.modules[\"os.path\"] = cast(Any, module).path\n elif name == \"typing\":\n self.modules[\"typing.io\"] = cast(Any, module).io\n self.modules[\"typing.re\"] = cast(Any, module).re\n\n return module\n\n def _gcd_import(self, name, package=None, level=0):\n \"\"\"Import and return the module based on its name, the package the call is\n being made from, and the level adjustment.\n\n This function represents the greatest common denominator of functionality\n between import_module and __import__. This includes setting __package__ if\n the loader did not.\n\n \"\"\"\n _sanity_check(name, package, level)\n if level > 0:\n name = _resolve_name(name, package, level)\n\n return self._find_and_load(name)\n\n # note: copied from cpython's import code\n def _handle_fromlist(self, module, fromlist, *, recursive=False):\n \"\"\"Figure out what __import__ should return.\n\n The import_ parameter is a callable which takes the name of module to\n import. It is required to decouple the function from assuming importlib's\n import implementation is desired.\n\n \"\"\"\n module_name = demangle(module.__name__)\n # The hell that is fromlist ...\n # If a package was imported, try to import stuff from fromlist.\n if hasattr(module, \"__path__\"):\n for x in fromlist:\n if not isinstance(x, str):\n if recursive:\n where = module_name + \".__all__\"\n else:\n where = \"``from list''\"\n raise TypeError(\n f\"Item in {where} must be str, \" f\"not {type(x).__name__}\"\n )\n elif x == \"*\":\n if not recursive and hasattr(module, \"__all__\"):\n self._handle_fromlist(module, module.__all__, recursive=True)\n elif not hasattr(module, x):\n from_name = \"{}.{}\".format(module_name, x)\n try:\n self._gcd_import(from_name)\n except ModuleNotFoundError as exc:\n # Backwards-compatibility dictates we ignore failed\n # imports triggered by fromlist for modules that don't\n # exist.\n if (\n exc.name == from_name\n and self.modules.get(from_name, _NEEDS_LOADING) is not None\n ):\n continue\n raise\n return module\n\n def __import__(self, name, globals=None, locals=None, fromlist=(), level=0):\n if level == 0:\n module = self._gcd_import(name)\n else:\n globals_ = globals if globals is not None else {}\n package = _calc___package__(globals_)\n module = self._gcd_import(name, package, level)\n if not fromlist:\n # Return up to the first dot in 'name'. This is complicated by the fact\n # that 'name' may be relative.\n if level == 0:\n return self._gcd_import(name.partition(\".\")[0])\n elif not name:\n return module\n else:\n # Figure out where to slice the module's name up to the first dot\n # in 'name'.\n cut_off = len(name) - len(name.partition(\".\")[0])\n # Slice end needs to be positive to alleviate need to special-case\n # when ``'.' not in name``.\n module_name = demangle(module.__name__)\n return self.modules[module_name[: len(module_name) - cut_off]]\n else:\n return self._handle_fromlist(module, fromlist)\n\n def _get_package(self, package):\n \"\"\"Take a package name or module object and return the module.\n\n If a name, the module is imported. If the passed or imported module\n object is not a package, raise an exception.\n \"\"\"\n if hasattr(package, \"__spec__\"):\n if package.__spec__.submodule_search_locations is None:\n raise TypeError(\"{!r} is not a package\".format(package.__spec__.name))\n else:\n return package\n else:\n module = self.import_module(package)\n if module.__spec__.submodule_search_locations is None:\n raise TypeError(\"{!r} is not a package\".format(package))\n else:\n return module\n\n def _zipfile_path(self, package, resource=None):\n package = self._get_package(package)\n assert package.__loader__ is self\n name = demangle(package.__name__)\n if resource is not None:\n resource = _normalize_path(resource)\n return f\"{name.replace('.', '/')}/{resource}\"\n else:\n return f\"{name.replace('.', '/')}\"\n\n def _get_or_create_package(\n self, atoms: List[str]\n ) -> \"Union[_PackageNode, _ExternNode]\":\n cur = self.root\n for i, atom in enumerate(atoms):\n node = cur.children.get(atom, None)\n if node is None:\n node = cur.children[atom] = _PackageNode(None)\n if isinstance(node, _ExternNode):\n return node\n if isinstance(node, _ModuleNode):\n name = \".\".join(atoms[:i])\n raise ImportError(\n f\"inconsistent module structure. module {name} is not a package, but has submodules\"\n )\n assert isinstance(node, _PackageNode)\n cur = node\n return cur\n\n def _add_file(self, filename: str):\n \"\"\"Assembles a Python module out of the given file. Will ignore files in the .data directory.\n\n Args:\n filename (str): the name of the file inside of the package archive to be added\n \"\"\"\n *prefix, last = filename.split(\"/\")\n if len(prefix) > 1 and prefix[0] == \".data\":\n return\n package = self._get_or_create_package(prefix)\n if isinstance(package, _ExternNode):\n raise ImportError(\n f\"inconsistent module structure. package contains a module file {filename}\"\n f\" that is a subpackage of a module marked external.\"\n )\n if last == \"__init__.py\":\n package.source_file = filename\n elif last.endswith(\".py\"):\n package_name = last[: -len(\".py\")]\n package.children[package_name] = _ModuleNode(filename)\n\n def _add_extern(self, extern_name: str):\n *prefix, last = extern_name.split(\".\")\n package = self._get_or_create_package(prefix)\n if isinstance(package, _ExternNode):\n return # the shorter extern covers this extern case\n package.children[last] = _ExternNode()\n\n\n_NEEDS_LOADING = object()\n_ERR_MSG_PREFIX = \"No module named \"\n_ERR_MSG = _ERR_MSG_PREFIX + \"{!r}\"\n\n\nclass _PathNode:\n pass\n\n\nclass _PackageNode(_PathNode):\n def __init__(self, source_file: Optional[str]):\n self.source_file = source_file\n self.children: Dict[str, _PathNode] = {}\n\n\nclass _ModuleNode(_PathNode):\n __slots__ = [\"source_file\"]\n\n def __init__(self, source_file: str):\n self.source_file = source_file\n\n\nclass _ExternNode(_PathNode):\n pass\n\n\n# A private global registry of all modules that have been package-imported.\n_package_imported_modules: WeakValueDictionary = WeakValueDictionary()\n\n# `inspect` by default only looks in `sys.modules` to find source files for classes.\n# Patch it to check our private registry of package-imported modules as well.\n_orig_getfile = inspect.getfile\n\n\ndef patched_getfile(object):\n if inspect.isclass(object):\n if object.__module__ in _package_imported_modules:\n return _package_imported_modules[object.__module__].__file__\n return _orig_getfile(object)\n\n\ninspect.getfile = patched_getfile\n\n\nclass _PackageResourceReader:\n \"\"\"Private class used to support PackageImporter.get_resource_reader().\n\n Confirms to the importlib.abc.ResourceReader interface. Allowed to access\n the innards of PackageImporter.\n \"\"\"\n\n def __init__(self, importer, fullname):\n self.importer = importer\n self.fullname = fullname\n\n def open_resource(self, resource):\n from io import BytesIO\n\n return BytesIO(self.importer.load_binary(self.fullname, resource))\n\n def resource_path(self, resource):\n # The contract for resource_path is that it either returns a concrete\n # file system path or raises FileNotFoundError.\n if isinstance(\n self.importer.zip_reader, DirectoryReader\n ) and self.importer.zip_reader.has_record(\n os.path.join(self.fullname, resource)\n ):\n return os.path.join(\n self.importer.zip_reader.directory, self.fullname, resource\n )\n raise FileNotFoundError\n\n def is_resource(self, name):\n path = self.importer._zipfile_path(self.fullname, name)\n return self.importer.zip_reader.has_record(path)\n\n def contents(self):\n from pathlib import Path\n\n filename = self.fullname.replace(\".\", \"/\")\n\n fullname_path = Path(self.importer._zipfile_path(self.fullname))\n files = self.importer.zip_reader.get_all_records()\n subdirs_seen = set()\n for filename in files:\n try:\n relative = Path(filename).relative_to(fullname_path)\n except ValueError:\n continue\n # If the path of the file (which is relative to the top of the zip\n # namespace), relative to the package given when the resource\n # reader was created, has a parent, then it's a name in a\n # subdirectory and thus we skip it.\n parent_name = relative.parent.name\n if len(parent_name) == 0:\n yield relative.name\n elif parent_name not in subdirs_seen:\n subdirs_seen.add(parent_name)\n yield parent_name\n",
"\n\nfrom caffe2.python import core\nfrom hypothesis import given, settings\n\nimport caffe2.python.hypothesis_test_util as hu\nimport hypothesis.strategies as st\nimport numpy as np\n\nimport unittest\n\n\nclass TestRMSNormOp(hu.HypothesisTestCase):\n @given(\n M=st.integers(0, 8),\n N=st.integers(1, 16),\n eps=st.floats(0, 1e-3),\n dtype=st.sampled_from([np.float32, np.float64]),\n **hu.gcs,\n )\n @settings(deadline=None)\n def test_rms_norm(self, M, N, eps, dtype, gc, dc):\n X = (np.random.randn(M, N) * 2.0 + 1.0).astype(dtype)\n gamma = np.random.randn(N).astype(dtype)\n beta = np.random.randn(N).astype(dtype)\n\n op = core.CreateOperator(\n \"RMSNorm\",\n [\"X\", \"gamma\", \"beta\"],\n [\"Y\", \"rrms\"],\n eps=eps,\n )\n\n def rms_norm_ref(X, gamma, beta):\n rrms = 1.0 / np.sqrt(np.mean(np.square(X), axis=1) + eps)\n Y = X * np.expand_dims(rrms, axis=1) * gamma + beta\n return Y, rrms\n\n inputs = [X, gamma, beta]\n self.assertReferenceChecks(gc, op, inputs, rms_norm_ref)\n self.assertDeviceChecks(dc, op, inputs, [0, 1])\n for i in range(len(inputs)):\n self.assertGradientChecks(gc, op, inputs, i, [0])\n\n\nif __name__ == \"__main__\":\n unittest.main()\n",
"#!/usr/bin/env python3\n\n# Copyright (c) Facebook, Inc. and its affiliates.\n# All rights reserved.\n#\n# This source code is licensed under the BSD-style license found in the\n# LICENSE file in the root directory of this source tree.abs\n\nimport json\nimport logging\nimport unittest\nfrom dataclasses import asdict\nfrom unittest.mock import patch\n\nfrom torch.distributed.elastic.events import (\n Event,\n EventSource,\n NodeState,\n RdzvEvent,\n _get_or_create_logger,\n construct_and_record_rdzv_event,\n)\nfrom torch.testing._internal.common_utils import run_tests\n\n\nclass EventLibTest(unittest.TestCase):\n def assert_event(self, actual_event, expected_event):\n self.assertEqual(actual_event.name, expected_event.name)\n self.assertEqual(actual_event.source, expected_event.source)\n self.assertEqual(actual_event.timestamp, expected_event.timestamp)\n self.assertDictEqual(actual_event.metadata, expected_event.metadata)\n\n @patch(\"torch.distributed.elastic.events.get_logging_handler\")\n def test_get_or_create_logger(self, logging_handler_mock):\n logging_handler_mock.return_value = logging.NullHandler()\n logger = _get_or_create_logger(\"test_destination\")\n self.assertIsNotNone(logger)\n self.assertEqual(1, len(logger.handlers))\n self.assertIsInstance(logger.handlers[0], logging.NullHandler)\n\n def test_event_created(self):\n event = Event(\n name=\"test_event\",\n source=EventSource.AGENT,\n metadata={\"key1\": \"value1\", \"key2\": 2},\n )\n self.assertEqual(\"test_event\", event.name)\n self.assertEqual(EventSource.AGENT, event.source)\n self.assertDictEqual({\"key1\": \"value1\", \"key2\": 2}, event.metadata)\n\n def test_event_deser(self):\n event = Event(\n name=\"test_event\",\n source=EventSource.AGENT,\n metadata={\"key1\": \"value1\", \"key2\": 2, \"key3\": 1.0},\n )\n json_event = event.serialize()\n deser_event = Event.deserialize(json_event)\n self.assert_event(event, deser_event)\n\nclass RdzvEventLibTest(unittest.TestCase):\n @patch(\"torch.distributed.elastic.events.record_rdzv_event\")\n @patch(\"torch.distributed.elastic.events.get_logging_handler\")\n def test_construct_and_record_rdzv_event(self, get_mock, record_mock):\n get_mock.return_value = logging.StreamHandler()\n construct_and_record_rdzv_event(\n run_id=\"test_run_id\",\n message=\"test_message\",\n node_state=NodeState.RUNNING,\n )\n record_mock.assert_called_once()\n\n @patch(\"torch.distributed.elastic.events.record_rdzv_event\")\n @patch(\"torch.distributed.elastic.events.get_logging_handler\")\n def test_construct_and_record_rdzv_event_does_not_run_if_invalid_dest(self, get_mock, record_mock):\n get_mock.return_value = logging.NullHandler()\n construct_and_record_rdzv_event(\n run_id=\"test_run_id\",\n message=\"test_message\",\n node_state=NodeState.RUNNING,\n )\n record_mock.assert_not_called()\n\n def assert_rdzv_event(self, actual_event: RdzvEvent, expected_event: RdzvEvent):\n self.assertEqual(actual_event.name, expected_event.name)\n self.assertEqual(actual_event.run_id, expected_event.run_id)\n self.assertEqual(actual_event.message, expected_event.message)\n self.assertEqual(actual_event.hostname, expected_event.hostname)\n self.assertEqual(actual_event.pid, expected_event.pid)\n self.assertEqual(actual_event.node_state, expected_event.node_state)\n self.assertEqual(actual_event.master_endpoint, expected_event.master_endpoint)\n self.assertEqual(actual_event.rank, expected_event.rank)\n self.assertEqual(actual_event.local_id, expected_event.local_id)\n self.assertEqual(actual_event.error_trace, expected_event.error_trace)\n\n def get_test_rdzv_event(self) -> RdzvEvent:\n return RdzvEvent(\n name=\"test_name\",\n run_id=\"test_run_id\",\n message=\"test_message\",\n hostname=\"test_hostname\",\n pid=1,\n node_state=NodeState.RUNNING,\n master_endpoint=\"test_master_endpoint\",\n rank=3,\n local_id=4,\n error_trace=\"test_error_trace\",\n )\n\n def test_rdzv_event_created(self):\n event = self.get_test_rdzv_event()\n self.assertEqual(event.name, \"test_name\")\n self.assertEqual(event.run_id, \"test_run_id\")\n self.assertEqual(event.message, \"test_message\")\n self.assertEqual(event.hostname, \"test_hostname\")\n self.assertEqual(event.pid, 1)\n self.assertEqual(event.node_state, NodeState.RUNNING)\n self.assertEqual(event.master_endpoint, \"test_master_endpoint\")\n self.assertEqual(event.rank, 3)\n self.assertEqual(event.local_id, 4)\n self.assertEqual(event.error_trace, \"test_error_trace\")\n\n\n def test_rdzv_event_deserialize(self):\n event = self.get_test_rdzv_event()\n json_event = event.serialize()\n deserialized_event = RdzvEvent.deserialize(json_event)\n self.assert_rdzv_event(event, deserialized_event)\n self.assert_rdzv_event(event, RdzvEvent.deserialize(event))\n\n def test_rdzv_event_str(self):\n event = self.get_test_rdzv_event()\n self.assertEqual(str(event), json.dumps(asdict(event)))\n\n\nif __name__ == \"__main__\":\n run_tests()\n",
"import operator_benchmark as op_bench\nimport torch\n\n\"\"\"Microbenchmarks for sum reduction operator.\"\"\"\n\n# Configs for PT add operator\nsum_configs = op_bench.cross_product_configs(\n R=[64, 256], # Length of reduced dimension\n V=[32, 512], # Length of other dimension\n dim=[0, 1],\n contiguous=[True, False],\n device=['cpu', 'cuda'],\n tags=['short']\n) + op_bench.cross_product_configs(\n R=[1024, 8192],\n V=[512, 1024],\n dim=[0, 1],\n contiguous=[True, False],\n device=['cpu', 'cuda'],\n tags=['long']\n)\n\n\nclass SumBenchmark(op_bench.TorchBenchmarkBase):\n def init(self, R, V, dim, contiguous, device):\n shape = (R, V) if dim == 0 else (V, R)\n tensor = torch.rand(shape, device=device)\n\n if not contiguous:\n storage = torch.empty([s * 2 for s in shape], device=device)\n storage[::2, ::2] = tensor\n self.input_tensor = storage[::2, ::2]\n else:\n self.input_tensor = tensor\n\n self.inputs = {\n \"input_tensor\": self.input_tensor,\n \"dim\": dim\n }\n self.set_module_name(\"sum\")\n\n def forward(self, input_tensor, dim: int):\n return input_tensor.sum(dim=dim)\n\nop_bench.generate_pt_test(sum_configs, SumBenchmark)\n\nif __name__ == \"__main__\":\n op_bench.benchmark_runner.main()\n",
"import math\nimport torch\nfrom torch._six import inf\nfrom typing import Optional\n\n\nclass __PrinterOptions(object):\n precision: int = 4\n threshold: float = 1000\n edgeitems: int = 3\n linewidth: int = 80\n sci_mode: Optional[bool] = None\n\n\nPRINT_OPTS = __PrinterOptions()\n\n\n# We could use **kwargs, but this will give better docs\ndef set_printoptions(\n precision=None,\n threshold=None,\n edgeitems=None,\n linewidth=None,\n profile=None,\n sci_mode=None\n):\n r\"\"\"Set options for printing. Items shamelessly taken from NumPy\n\n Args:\n precision: Number of digits of precision for floating point output\n (default = 4).\n threshold: Total number of array elements which trigger summarization\n rather than full `repr` (default = 1000).\n edgeitems: Number of array items in summary at beginning and end of\n each dimension (default = 3).\n linewidth: The number of characters per line for the purpose of\n inserting line breaks (default = 80). Thresholded matrices will\n ignore this parameter.\n profile: Sane defaults for pretty printing. Can override with any of\n the above options. (any one of `default`, `short`, `full`)\n sci_mode: Enable (True) or disable (False) scientific notation. If\n None (default) is specified, the value is defined by\n `torch._tensor_str._Formatter`. This value is automatically chosen\n by the framework.\n \"\"\"\n if profile is not None:\n if profile == \"default\":\n PRINT_OPTS.precision = 4\n PRINT_OPTS.threshold = 1000\n PRINT_OPTS.edgeitems = 3\n PRINT_OPTS.linewidth = 80\n elif profile == \"short\":\n PRINT_OPTS.precision = 2\n PRINT_OPTS.threshold = 1000\n PRINT_OPTS.edgeitems = 2\n PRINT_OPTS.linewidth = 80\n elif profile == \"full\":\n PRINT_OPTS.precision = 4\n PRINT_OPTS.threshold = inf\n PRINT_OPTS.edgeitems = 3\n PRINT_OPTS.linewidth = 80\n\n if precision is not None:\n PRINT_OPTS.precision = precision\n if threshold is not None:\n PRINT_OPTS.threshold = threshold\n if edgeitems is not None:\n PRINT_OPTS.edgeitems = edgeitems\n if linewidth is not None:\n PRINT_OPTS.linewidth = linewidth\n PRINT_OPTS.sci_mode = sci_mode\n\n\nclass _Formatter(object):\n def __init__(self, tensor):\n self.floating_dtype = tensor.dtype.is_floating_point\n self.int_mode = True\n self.sci_mode = False\n self.max_width = 1\n\n with torch.no_grad():\n tensor_view = tensor.reshape(-1)\n\n if not self.floating_dtype:\n for value in tensor_view:\n value_str = '{}'.format(value)\n self.max_width = max(self.max_width, len(value_str))\n\n else:\n nonzero_finite_vals = torch.masked_select(tensor_view, torch.isfinite(tensor_view) & tensor_view.ne(0))\n\n if nonzero_finite_vals.numel() == 0:\n # no valid number, do nothing\n return\n\n # Convert to double for easy calculation. HalfTensor overflows with 1e8, and there's no div() on CPU.\n nonzero_finite_abs = nonzero_finite_vals.abs().double()\n nonzero_finite_min = nonzero_finite_abs.min().double()\n nonzero_finite_max = nonzero_finite_abs.max().double()\n\n for value in nonzero_finite_vals:\n if value != torch.ceil(value):\n self.int_mode = False\n break\n\n if self.int_mode:\n # in int_mode for floats, all numbers are integers, and we append a decimal to nonfinites\n # to indicate that the tensor is of floating type. add 1 to the len to account for this.\n if nonzero_finite_max / nonzero_finite_min > 1000. or nonzero_finite_max > 1.e8:\n self.sci_mode = True\n for value in nonzero_finite_vals:\n value_str = ('{{:.{}e}}').format(PRINT_OPTS.precision).format(value)\n self.max_width = max(self.max_width, len(value_str))\n else:\n for value in nonzero_finite_vals:\n value_str = ('{:.0f}').format(value)\n self.max_width = max(self.max_width, len(value_str) + 1)\n else:\n # Check if scientific representation should be used.\n if nonzero_finite_max / nonzero_finite_min > 1000.\\\n or nonzero_finite_max > 1.e8\\\n or nonzero_finite_min < 1.e-4:\n self.sci_mode = True\n for value in nonzero_finite_vals:\n value_str = ('{{:.{}e}}').format(PRINT_OPTS.precision).format(value)\n self.max_width = max(self.max_width, len(value_str))\n else:\n for value in nonzero_finite_vals:\n value_str = ('{{:.{}f}}').format(PRINT_OPTS.precision).format(value)\n self.max_width = max(self.max_width, len(value_str))\n\n if PRINT_OPTS.sci_mode is not None:\n self.sci_mode = PRINT_OPTS.sci_mode\n\n def width(self):\n return self.max_width\n\n def format(self, value):\n if self.floating_dtype:\n if self.sci_mode:\n ret = ('{{:{}.{}e}}').format(self.max_width, PRINT_OPTS.precision).format(value)\n elif self.int_mode:\n ret = '{:.0f}'.format(value)\n if not (math.isinf(value) or math.isnan(value)):\n ret += '.'\n else:\n ret = ('{{:.{}f}}').format(PRINT_OPTS.precision).format(value)\n else:\n ret = '{}'.format(value)\n return (self.max_width - len(ret)) * ' ' + ret\n\n\ndef _scalar_str(self, formatter1, formatter2=None):\n if formatter2 is not None:\n real_str = _scalar_str(self.real, formatter1)\n imag_str = (_scalar_str(self.imag, formatter2) + \"j\").lstrip()\n # handles negative numbers, +0.0, -0.0\n if imag_str[0] == '+' or imag_str[0] == '-':\n return real_str + imag_str\n else:\n return real_str + \"+\" + imag_str\n else:\n return formatter1.format(self.item())\n\ndef _vector_str(self, indent, summarize, formatter1, formatter2=None):\n # length includes spaces and comma between elements\n element_length = formatter1.width() + 2\n if formatter2 is not None:\n # width for imag_formatter + an extra j for complex\n element_length += formatter2.width() + 1\n\n elements_per_line = max(1, int(math.floor((PRINT_OPTS.linewidth - indent) / (element_length))))\n char_per_line = element_length * elements_per_line\n\n def _val_formatter(val, formatter1=formatter1, formatter2=formatter2):\n if formatter2 is not None:\n real_str = formatter1.format(val.real)\n imag_str = (formatter2.format(val.imag) + \"j\").lstrip()\n # handles negative numbers, +0.0, -0.0\n if imag_str[0] == '+' or imag_str[0] == '-':\n return real_str + imag_str\n else:\n return real_str + \"+\" + imag_str\n else:\n return formatter1.format(val)\n\n if summarize and self.size(0) > 2 * PRINT_OPTS.edgeitems:\n data = ([_val_formatter(val) for val in self[:PRINT_OPTS.edgeitems].tolist()] +\n [' ...'] +\n [_val_formatter(val) for val in self[-PRINT_OPTS.edgeitems:].tolist()])\n else:\n data = [_val_formatter(val) for val in self.tolist()]\n\n data_lines = [data[i:i + elements_per_line] for i in range(0, len(data), elements_per_line)]\n lines = [', '.join(line) for line in data_lines]\n return '[' + (',' + '\\n' + ' ' * (indent + 1)).join(lines) + ']'\n\n# formatter2 is only used for printing complex tensors.\n# For complex tensors, formatter1 and formatter2 are the formatters for tensor.real\n# and tensor.imag respesectively\ndef _tensor_str_with_formatter(self, indent, summarize, formatter1, formatter2=None):\n dim = self.dim()\n\n if dim == 0:\n return _scalar_str(self, formatter1, formatter2)\n\n if dim == 1:\n return _vector_str(self, indent, summarize, formatter1, formatter2)\n\n if summarize and self.size(0) > 2 * PRINT_OPTS.edgeitems:\n slices = ([_tensor_str_with_formatter(self[i], indent + 1, summarize, formatter1, formatter2)\n for i in range(0, PRINT_OPTS.edgeitems)] +\n ['...'] +\n [_tensor_str_with_formatter(self[i], indent + 1, summarize, formatter1, formatter2)\n for i in range(len(self) - PRINT_OPTS.edgeitems, len(self))])\n else:\n slices = [_tensor_str_with_formatter(self[i], indent + 1, summarize, formatter1, formatter2)\n for i in range(0, self.size(0))]\n\n tensor_str = (',' + '\\n' * (dim - 1) + ' ' * (indent + 1)).join(slices)\n return '[' + tensor_str + ']'\n\ndef _tensor_str(self, indent):\n if self.numel() == 0:\n return '[]'\n\n if self.has_names():\n # There are two main codepaths (possibly more) that tensor printing goes through:\n # - tensor data can fit comfortably on screen\n # - tensor data needs to be summarized\n # Some of the codepaths don't fully support named tensors, so we send in\n # an unnamed tensor to the formatting code as a workaround.\n self = self.rename(None)\n\n summarize = self.numel() > PRINT_OPTS.threshold\n\n # handle the negative bit\n if self.is_neg():\n self = self.resolve_neg()\n\n if self.dtype is torch.float16 or self.dtype is torch.bfloat16:\n self = self.float()\n\n if self.dtype.is_complex:\n # handle the conjugate bit\n self = self.resolve_conj()\n real_formatter = _Formatter(get_summarized_data(self.real) if summarize else self.real)\n imag_formatter = _Formatter(get_summarized_data(self.imag) if summarize else self.imag)\n return _tensor_str_with_formatter(self, indent, summarize, real_formatter, imag_formatter)\n else:\n formatter = _Formatter(get_summarized_data(self) if summarize else self)\n return _tensor_str_with_formatter(self, indent, summarize, formatter)\n\ndef _add_suffixes(tensor_str, suffixes, indent, force_newline):\n tensor_strs = [tensor_str]\n last_line_len = len(tensor_str) - tensor_str.rfind('\\n') + 1\n for suffix in suffixes:\n suffix_len = len(suffix)\n if force_newline or last_line_len + suffix_len + 2 > PRINT_OPTS.linewidth:\n tensor_strs.append(',\\n' + ' ' * indent + suffix)\n last_line_len = indent + suffix_len\n force_newline = False\n else:\n tensor_strs.append(', ' + suffix)\n last_line_len += suffix_len + 2\n tensor_strs.append(')')\n return ''.join(tensor_strs)\n\n\ndef get_summarized_data(self):\n dim = self.dim()\n if dim == 0:\n return self\n if dim == 1:\n if self.size(0) > 2 * PRINT_OPTS.edgeitems:\n return torch.cat((self[:PRINT_OPTS.edgeitems], self[-PRINT_OPTS.edgeitems:]))\n else:\n return self\n if self.size(0) > 2 * PRINT_OPTS.edgeitems:\n start = [self[i] for i in range(0, PRINT_OPTS.edgeitems)]\n end = ([self[i]\n for i in range(len(self) - PRINT_OPTS.edgeitems, len(self))])\n return torch.stack([get_summarized_data(x) for x in (start + end)])\n else:\n return torch.stack([get_summarized_data(x) for x in self])\n\ndef _str_intern(inp):\n prefix = 'tensor('\n indent = len(prefix)\n suffixes = []\n\n # This is used to extract the primal value and thus disable the forward AD\n # within this function.\n # TODO(albanD) This needs to be updated when more than one level is supported\n self, tangent = torch.autograd.forward_ad.unpack_dual(inp)\n\n # Note [Print tensor device]:\n # A general logic here is we only print device when it doesn't match\n # the device specified in default tensor type.\n # Currently torch.set_default_tensor_type() only supports CPU/CUDA, thus\n # torch._C._get_default_device() only returns either cpu or cuda.\n # In other cases, we don't have a way to set them as default yet,\n # and we should always print out device for them.\n if self.device.type != torch._C._get_default_device()\\\n or (self.device.type == 'cuda' and torch.cuda.current_device() != self.device.index):\n suffixes.append('device=\\'' + str(self.device) + '\\'')\n\n # TODO: add an API to map real -> complex dtypes\n _default_complex_dtype = torch.cdouble if torch.get_default_dtype() == torch.double else torch.cfloat\n has_default_dtype = self.dtype in (torch.get_default_dtype(), _default_complex_dtype, torch.int64, torch.bool)\n if self.is_sparse:\n suffixes.append('size=' + str(tuple(self.shape)))\n suffixes.append('nnz=' + str(self._nnz()))\n if not has_default_dtype:\n suffixes.append('dtype=' + str(self.dtype))\n indices_prefix = 'indices=tensor('\n indices = self._indices().detach()\n indices_str = _tensor_str(indices, indent + len(indices_prefix))\n if indices.numel() == 0:\n indices_str += ', size=' + str(tuple(indices.shape))\n values_prefix = 'values=tensor('\n values = self._values().detach()\n values_str = _tensor_str(values, indent + len(values_prefix))\n if values.numel() == 0:\n values_str += ', size=' + str(tuple(values.shape))\n tensor_str = indices_prefix + indices_str + '),\\n' + ' ' * indent + values_prefix + values_str + ')'\n elif self.is_sparse_csr:\n suffixes.append('size=' + str(tuple(self.shape)))\n suffixes.append('nnz=' + str(self._nnz()))\n if not has_default_dtype:\n suffixes.append('dtype=' + str(self.dtype))\n crow_indices_prefix = 'crow_indices=tensor('\n crow_indices = self.crow_indices().detach()\n crow_indices_str = _tensor_str(crow_indices, indent + len(crow_indices_prefix))\n if crow_indices.numel() == 0:\n crow_indices_str += ', size=' + str(tuple(crow_indices.shape))\n col_indices_prefix = 'col_indices=tensor('\n col_indices = self.col_indices().detach()\n col_indices_str = _tensor_str(col_indices, indent + len(col_indices_prefix))\n if col_indices.numel() == 0:\n col_indices_str += ', size=' + str(tuple(col_indices.shape))\n values_prefix = 'values=tensor('\n values = self.values().detach()\n values_str = _tensor_str(values, indent + len(values_prefix))\n if values.numel() == 0:\n values_str += ', size=' + str(tuple(values.shape))\n tensor_str = crow_indices_prefix + crow_indices_str + '),\\n' + ' ' * indent +\\\n col_indices_prefix + col_indices_str + '),\\n' + ' ' * indent +\\\n values_prefix + values_str + ')'\n elif self.is_quantized:\n suffixes.append('size=' + str(tuple(self.shape)))\n if not has_default_dtype:\n suffixes.append('dtype=' + str(self.dtype))\n suffixes.append('quantization_scheme=' + str(self.qscheme()))\n if self.qscheme() == torch.per_tensor_affine or self.qscheme() == torch.per_tensor_symmetric:\n suffixes.append('scale=' + str(self.q_scale()))\n suffixes.append('zero_point=' + str(self.q_zero_point()))\n elif self.qscheme() == torch.per_channel_affine or self.qscheme() == torch.per_channel_symmetric \\\n or self.qscheme() == torch.per_channel_affine_float_qparams:\n suffixes.append('scale=' + str(self.q_per_channel_scales()))\n suffixes.append('zero_point=' + str(self.q_per_channel_zero_points()))\n suffixes.append('axis=' + str(self.q_per_channel_axis()))\n tensor_str = _tensor_str(self.dequantize(), indent)\n else:\n if self.is_meta:\n suffixes.append('size=' + str(tuple(self.shape)))\n if self.dtype != torch.get_default_dtype():\n suffixes.append('dtype=' + str(self.dtype))\n # TODO: This implies that ellipses is valid syntax for allocating\n # a meta tensor, which it could be, but it isn't right now\n tensor_str = '...'\n else:\n if self.numel() == 0 and not self.is_sparse:\n # Explicitly print the shape if it is not (0,), to match NumPy behavior\n if self.dim() != 1:\n suffixes.append('size=' + str(tuple(self.shape)))\n\n # In an empty tensor, there are no elements to infer if the dtype\n # should be int64, so it must be shown explicitly.\n if self.dtype != torch.get_default_dtype():\n suffixes.append('dtype=' + str(self.dtype))\n tensor_str = '[]'\n else:\n if not has_default_dtype:\n suffixes.append('dtype=' + str(self.dtype))\n\n if self.layout != torch.strided:\n tensor_str = _tensor_str(self.to_dense(), indent)\n else:\n tensor_str = _tensor_str(self, indent)\n\n if self.layout != torch.strided:\n suffixes.append('layout=' + str(self.layout))\n\n # Use inp here to get the original grad_fn and not the one generated by the forward grad\n # unpacking.\n if inp.grad_fn is not None:\n name = type(inp.grad_fn).__name__\n if name == 'CppFunction':\n name = inp.grad_fn.name().rsplit('::', 1)[-1]\n suffixes.append('grad_fn=<{}>'.format(name))\n elif inp.requires_grad:\n suffixes.append('requires_grad=True')\n\n if self.has_names():\n suffixes.append('names={}'.format(self.names))\n\n if tangent is not None:\n suffixes.append('tangent={}'.format(tangent))\n\n return _add_suffixes(prefix + tensor_str, suffixes, indent, force_newline=self.is_sparse)\n\ndef _str(self):\n with torch.no_grad():\n return _str_intern(self)\n",
"import operator_benchmark as op_bench\nimport torch\n\n\n\"\"\"Microbenchmarks for diag operator\"\"\"\n\n\n# Configs for PT diag operator\ndiag_configs_short = op_bench.config_list(\n attr_names=['dim', 'M', 'N', 'diagonal', 'out'],\n attrs=[\n [1, 64, 64, 0, True],\n [2, 128, 128, -10, False],\n [1, 256, 256, 20, True],\n ],\n cross_product_configs={\n 'device': ['cpu', 'cuda'],\n },\n tags=['short'],\n)\n\n\nclass DiagBenchmark(op_bench.TorchBenchmarkBase):\n def init(self, dim, M, N, diagonal, out, device):\n self.inputs = {\n \"input\": torch.rand(M, N, device=device) if dim == 2 else torch.rand(M, device=device),\n \"diagonal\": diagonal,\n \"out\": out,\n \"out_tensor\": torch.tensor((),)\n }\n self.set_module_name('diag')\n\n def forward(self, input, diagonal: int, out: bool, out_tensor):\n if out:\n return torch.diag(input, diagonal=diagonal, out=out_tensor)\n else:\n return torch.diag(input, diagonal=diagonal)\n\n\nop_bench.generate_pt_test(diag_configs_short, DiagBenchmark)\n\n\nif __name__ == \"__main__\":\n op_bench.benchmark_runner.main()\n",
"\n\n\n\n\nfrom caffe2.python import core\nimport caffe2.python.hypothesis_test_util as hu\nimport caffe2.python.serialized_test.serialized_test_util as serial\nimport hypothesis.strategies as st\nfrom hypothesis import given, settings\nimport numpy as np\n\n\nclass TestIntegralImageOps(serial.SerializedTestCase):\n @given(batch_size=st.integers(1, 3),\n height=st.integers(7, 10),\n width=st.integers(7, 10),\n channels=st.integers(1, 8),\n **hu.gcs)\n @settings(deadline=10000)\n def test_integral_image_ops(self, batch_size, height, width, channels, gc, dc):\n N = batch_size\n C = channels\n H = height\n W = width\n\n im = np.random.rand(N, C, H, W).astype(np.float32)\n op = core.CreateOperator(\"IntegralImage\",\n [\"im\"], [\"y\"])\n\n def integral_image(im):\n y = np.random.rand(N, C, H + 1, W + 1).astype(np.float32)\n for i1 in range(N):\n for i2 in range(C):\n for i3 in range(W + 1):\n y[i1, i2, 0, i3] = 0\n for i3 in range(H + 1):\n y[i1, i2, i3, 0] = 0\n for i3 in range(1, H + 1):\n for i4 in range(1, W + 1):\n y[i1, i2, i3, i4] = im[i1, i2, i3 - 1, i4 - 1] + \\\n y[i1, i2, i3 - 1, i4] + \\\n y[i1, i2, i3, i4 - 1] - \\\n y[i1, i2, i3 - 1, i4 - 1]\n\n return [y]\n\n self.assertDeviceChecks(dc, op, [im], [0])\n self.assertReferenceChecks(gc, op, [im], integral_image)\n\n @given(batch_size=st.integers(1, 3),\n height=st.integers(7, 10),\n width=st.integers(7, 10),\n channels=st.integers(1, 8),\n **hu.gcs)\n @settings(deadline=10000)\n def test_integral_image_gradient_ops(self, batch_size, height, width,\n channels, gc, dc):\n N = batch_size\n C = channels\n H = height\n W = width\n\n X = np.random.rand(N, C, H, W).astype(np.float32)\n dY = np.random.rand(N, C, H + 1, W + 1).astype(np.float32)\n op = core.CreateOperator(\n \"IntegralImageGradient\",\n [\"X\", \"dY\"],\n [\"dX\"])\n\n def integral_image_gradient(X, dY):\n dX = np.random.rand(N, C, H, W).astype(np.float32)\n dX1 = np.random.rand(N, C, H + 1, W).astype(np.float32)\n #H+1,W+1=>H+1, W\n for i1 in range(N):\n for i2 in range(C):\n for i3 in range(H + 1):\n dX1[i1, i2, i3, 0] = dY[i1, i2, i3, 0]\n for i4 in range(1, W):\n dX1[i1, i2, i3, i4] = dY[i1, i2, i3, i4] + \\\n dX1[i1, i2, i3, i4 - 1]\n\n #H+1,W=>H,W\n for i1 in range(N):\n for i2 in range(C):\n for i3 in range(W):\n dX[i1, i2, 0, i3] = dX1[i1, i2, 0, i3]\n for i4 in range(1, H):\n dX[i1, i2, i4, i3] = dX1[i1, i2, i4, i3] + \\\n dX[i1, i2, i4 - 1, i3]\n return [dX]\n\n self.assertDeviceChecks(dc, op, [X, dY], [0])\n self.assertReferenceChecks(gc, op, [X, dY], integral_image_gradient)\n",
"import argparse\nimport json\nimport os\nfrom pathlib import Path\n\nfrom data import data_map\nfrom metrics.ProcessedMetricsPrinter import ProcessedMetricsPrinter\nfrom models import model_map\nfrom server import server_map\nfrom trainer import (\n criterion_map,\n ddp_hook_map,\n ddp_model_map,\n hook_state_map,\n iteration_step_map,\n preprocess_data_map,\n trainer_map,\n)\n\nimport torch\nimport torch.distributed as c10d\nimport torch.distributed.rpc as rpc\nimport torch.multiprocessing as mp\nfrom torch.distributed.rpc import TensorPipeRpcBackendOptions\nfrom torch.futures import wait_all\nfrom torch.utils.data import DataLoader\n\n\ndef get_name(rank, args):\n r\"\"\"\n A function that gets the name for the rank\n argument\n Args:\n rank (int): process number in the world\n args (parser): benchmark configurations\n \"\"\"\n t_count = args.ntrainer + args.ncudatrainer\n s_count = args.nserver + args.ncudaserver\n if rank < t_count:\n return f\"trainer{rank}\"\n elif rank < (t_count + s_count):\n return f\"server{rank}\"\n else:\n return \"master\"\n\n\ndef get_server_rank(args, rank):\n r\"\"\"\n A function that gets the server rank for\n the rank argument.\n Args:\n args (parser): benchmark configurations\n rank (int): trainer rank\n \"\"\"\n s_offset = args.ntrainer + args.ncudatrainer\n tps = args.ntrainer // args.nserver\n return rank // tps + s_offset\n\n\ndef get_cuda_server_rank(args, rank):\n r\"\"\"\n A function that gets the cudaserver rank for\n the rank argument.\n Args:\n args (parser): benchmark configurations\n rank (int): trainer rank\n \"\"\"\n s_offset = args.ntrainer + args.ncudatrainer + args.nserver\n t_index = rank - args.ntrainer\n ctps = args.ncudatrainer // args.ncudaserver\n return t_index // ctps + s_offset\n\n\ndef get_server_rref(server_rank, args, extra_args):\n r\"\"\"\n A function that creates a RRef to the server.\n Args:\n server_rank (int): process number in the world\n args (parser): benchmark configurations\n extra_args (dict): configurations added by the user\n \"\"\"\n server = server_map[args.server]\n name = get_name(\n server_rank,\n args\n )\n if extra_args is not None:\n server_args = extra_args.values()\n else:\n server_args = []\n if server_rank >= args.ntrainer + args.ncudatrainer + args.nserver:\n trainer_count = args.ncudatrainer / args.ncudaserver\n use_cuda_rpc = True\n else:\n trainer_count = args.ntrainer / args.nserver\n use_cuda_rpc = False\n return rpc.remote(\n name,\n server,\n args=(\n server_rank,\n trainer_count,\n use_cuda_rpc,\n *server_args,\n ),\n )\n\n\ndef run_trainer(\n args, extra_args, data, rank, server_rref\n):\n r\"\"\"\n A function that runs obtains a trainer instance and calls\n the train method.\n Args:\n args (parser): benchmark configurations\n extra_args (dict): configurations added by the user\n data (list): training samples\n rank (int): process number in the world\n server_rrefs (dict): a dictionary containing server RRefs\n \"\"\"\n trainer_class = trainer_map[args.trainer]\n if extra_args is not None:\n trainer_args = extra_args.values()\n else:\n trainer_args = []\n trainer_count = args.ntrainer + args.ncudatrainer\n store = c10d.FileStore(args.filestore, trainer_count)\n if args.backend == \"gloo\":\n process_group = c10d.ProcessGroupGloo(\n store, rank, trainer_count\n )\n elif args.backend == \"nccl\":\n process_group = c10d.ProcessGroupNCCL(\n store, rank, trainer_count\n )\n elif args.backend == \"multi\":\n process_group = c10d.ProcessGroupNCCL(\n store, rank, trainer_count\n )\n if c10d.is_initialized() is False:\n c10d.init_process_group(backend=\"gloo\", rank=rank, world_size=trainer_count)\n\n model = load_model(args)\n preprocess_data = preprocess_data_map[args.preprocess_data]\n create_criterion = criterion_map[args.create_criterion]\n create_ddp_model = ddp_model_map[args.create_ddp_model]\n iteration_step = iteration_step_map[args.iteration_step]\n hook_state_class = hook_state_map[args.hook_state]\n hook = ddp_hook_map[args.ddp_hook]\n # check if this a cudatrainer\n use_cuda_rpc = rank >= args.ntrainer\n trainer = trainer_class(\n process_group,\n use_cuda_rpc,\n server_rref,\n args.backend,\n args.epochs,\n preprocess_data,\n create_criterion,\n create_ddp_model,\n hook_state_class,\n hook,\n iteration_step,\n *trainer_args\n )\n trainer.train(model, data)\n metrics = trainer.get_metrics()\n return [rank, metrics]\n\n\ndef call_trainers(args, extra_args, train_data, server_rrefs):\n r\"\"\"\n A function that starts the trainers. Each trainer is started\n using an rpc_async request.\n Args:\n args (parser): benchmark configurations\n extra_args (dict): configurations added by the user\n train_data (list): training samples\n server_rrefs (dict): a dictionary containing server RRefs\n \"\"\"\n futs = []\n for trainer_rank in range(0, args.ntrainer + args.ncudatrainer):\n trainer_name = get_name(\n trainer_rank,\n args\n )\n server_rref = None\n if server_rrefs:\n if trainer_rank >= args.ntrainer:\n server_rank = get_cuda_server_rank(args, trainer_rank)\n else:\n server_rank = get_server_rank(args, trainer_rank)\n server_rref = server_rrefs[server_rank]\n fut = rpc.rpc_async(\n trainer_name,\n run_trainer,\n args=(\n args,\n extra_args,\n train_data[trainer_rank],\n trainer_rank,\n server_rref,\n ),\n timeout=args.rpc_timeout\n )\n futs.append(fut)\n return futs\n\n\ndef benchmark_warmup(\n args, extra_args, data, server_rrefs\n):\n r\"\"\"\n A function that runs the training algorithm. The goal of this\n function is to warm the rpc. The server states are reset.\n Args:\n args (parser): benchmark configurations\n extra_args (dict): configurations added by the user\n data (list): training samples\n server_rrefs (dict): a dictionary containing server RRefs\n \"\"\"\n futs = call_trainers(args, extra_args, data, server_rrefs)\n wait_all(futs)\n for server_rref in server_rrefs.values():\n server_rref.rpc_sync().reset_state(server_rref)\n print(\"benchmark warmup done\\n\")\n\n\ndef split_list(arr, n):\n r\"\"\"\n A function that splits a list into n lists\n Args:\n arr (list): training samples\n n (int): number of output lists\n \"\"\"\n return [arr[i::n] for i in range(n)]\n\n\ndef get_server_metrics(server_rrefs):\n r\"\"\"\n A function that calls the remote server to obtain metrics\n collected during the benchmark run.\n Args:\n server_rrefs (dict): a dictionary containing server RRefs\n \"\"\"\n rank_metrics = []\n for rank, server_rref in server_rrefs.items():\n metrics = server_rref.rpc_sync().get_metrics(server_rref)\n rank_metrics.append([rank, metrics])\n return rank_metrics\n\n\ndef run_master(rank, data, args, extra_configs, rpc_backend_options):\n r\"\"\"\n A function that runs the master process in the world. This function\n obtains remote references to initialized servers, splits the data,\n runs the trainers, and prints metrics.\n Args:\n rank (int): process number in the world\n data (list): training samples\n args (parser): benchmark configurations\n extra_configs (dict): configurations added by the user\n rpc_backend_options (rpc): configurations/options for the rpc TODO: fix\n \"\"\"\n world_size = args.ntrainer + args.ncudatrainer + args.nserver + args.ncudaserver + 1\n rpc.init_rpc(\n get_name(\n rank,\n args\n ),\n rank=rank,\n world_size=world_size,\n rpc_backend_options=rpc_backend_options\n )\n server_rrefs = {}\n for i in range(\n args.ntrainer + args.ncudatrainer, world_size - 1\n ):\n server_rrefs[i] = get_server_rref(i, args, extra_configs[\"server_config\"])\n train_data = split_list(\n list(DataLoader(data, batch_size=args.batch_size)),\n args.ntrainer + args.ncudatrainer\n )\n\n # warmup run the benchmark\n benchmark_warmup(\n args, extra_configs[\"trainer_config\"], train_data, server_rrefs\n )\n # run the benchmark\n trainer_futs = call_trainers(\n args, extra_configs[\"trainer_config\"], train_data, server_rrefs\n )\n # collect metrics and print\n metrics_printer = ProcessedMetricsPrinter()\n rank_metrics_list = wait_all(trainer_futs)\n metrics_printer.print_metrics(\"trainer\", rank_metrics_list)\n rank_metrics_list = get_server_metrics(server_rrefs)\n metrics_printer.print_metrics(\"server\", rank_metrics_list)\n\n\ndef run_benchmark(rank, args, data):\n r\"\"\"\n A function that runs the benchmark.\n Args:\n rank (int): process number in the world\n args (parser): configuration args\n data (list): training samples\n \"\"\"\n\n config = load_extra_configs(args)\n\n torch.manual_seed(args.torch_seed)\n torch.cuda.manual_seed_all(args.cuda_seed)\n torch.backends.cudnn.benchmark = True\n torch.backends.cudnn.deterministic = True\n\n world_size = args.ntrainer + args.ncudatrainer + args.nserver + args.ncudaserver + 1\n os.environ['MASTER_ADDR'] = args.master_addr\n os.environ['MASTER_PORT'] = args.master_port\n rpc_backend_options = TensorPipeRpcBackendOptions(rpc_timeout=args.rpc_timeout)\n if rank == world_size - 1:\n # master = [ntrainer + ncudatrainer + nserver + ncudaserver, ntrainer + ncudatrainer + nserver + ncudaserver]\n run_master(rank, data, args, config, rpc_backend_options)\n elif rank >= args.ntrainer + args.ncudatrainer:\n # parameter_servers = [ntrainer + ncudatrainer, ntrainer + ncudatrainer + nserver + ncudaserver)\n rpc.init_rpc(\n get_name(\n rank,\n args\n ),\n rank=rank,\n world_size=world_size,\n rpc_backend_options=rpc_backend_options\n )\n else:\n # trainers = [0, ntrainer + ncudatrainer)\n if rank >= args.ntrainer:\n server_rank = get_cuda_server_rank(args, rank)\n server_name = get_name(server_rank, args)\n rpc_backend_options.set_device_map(\n server_name,\n {rank: server_rank}\n )\n trainer_name = get_name(\n rank,\n args\n )\n rpc.init_rpc(\n trainer_name,\n rank=rank,\n world_size=world_size,\n rpc_backend_options=rpc_backend_options\n )\n rpc.shutdown()\n\n\ndef get_json_config(file_name, id):\n r\"\"\"\n A function that loads a json configuration from a file.\n Args:\n file_name (str): name of configuration file to load\n id (str): configuration that will be loaded\n \"\"\"\n with open(os.path.join(Path(__file__).parent, file_name), \"r\") as f:\n json_config = json.load(f)[id]\n return json_config\n\n\ndef load_extra_configs(args):\n r\"\"\"\n A function that creates a dictionary that contains any extra configurations\n set by the user. The dictionary will contain two keys trainer_config and\n server_config, with default values None.\n Args:\n args (parser): launcher configurations\n \"\"\"\n trainer_config_file = args.trainer_config_path\n server_config_file = args.server_config_path\n configurations = {\n \"trainer_config\": None,\n \"server_config\": None\n }\n if args.trainer is not None and trainer_config_file is not None:\n configurations[\"trainer_config\"] = get_json_config(trainer_config_file, args.trainer)\n if args.server is not None and server_config_file is not None:\n configurations[\"server_config\"] = get_json_config(server_config_file, args.server)\n return configurations\n\n\ndef load_data(args):\n r\"\"\"\n A function that creates an instance of the data class.\n Args:\n args (parser): launcher configurations\n \"\"\"\n data_config_file = args.data_config_path\n data_config = get_json_config(data_config_file, args.data)\n data_class = data_map[data_config[\"data_class\"]]\n return data_class(**data_config[\"configurations\"])\n\n\ndef load_model(args):\n r\"\"\"\n A function that creates an instance of the model class.\n Args:\n args (parser): launcher configurations\n \"\"\"\n model_config_file = args.model_config_path\n model_config = get_json_config(model_config_file, args.model)\n model_class = model_map[model_config[\"model_class\"]]\n return model_class(**model_config[\"configurations\"])\n\n\ndef main(args):\n r\"\"\"\n A function that creates multiple processes to run the benchmark.\n Args:\n args (parser): launcher configurations\n \"\"\"\n # CPU and RPC trainer checks\n if args.ntrainer > 0 and args.ncudatrainer > 0:\n assert args.nserver > 0 and args.ncudaserver > 0\n if args.nserver > 0:\n assert args.ntrainer > 0\n assert args.ntrainer % args.nserver == 0\n if args.ncudaserver > 0:\n assert args.ncudatrainer > 0\n assert args.ncudatrainer % args.ncudaserver == 0\n\n world_size = (\n args.ntrainer + args.ncudatrainer + args.nserver + args.ncudaserver + 1\n )\n\n data = load_data(args)\n\n mp.spawn(\n run_benchmark,\n args=(\n args,\n data,\n ),\n nprocs=world_size,\n join=True\n )\n\n\nif __name__ == \"__main__\":\n parser = argparse.ArgumentParser(description=\"RPC server Benchmark\")\n parser.add_argument(\n \"--master_addr\",\n type=str,\n help=\"IP address of the machine that will host the process with rank 0\"\n )\n parser.add_argument(\n \"--master_port\",\n type=str,\n help=\"A free port on the machine that will host the process with rank 0\"\n )\n parser.add_argument(\n \"--trainer\",\n type=str,\n help=\"trainer map key to get trainer class for benchmark run\"\n )\n parser.add_argument(\n \"--ntrainer\",\n type=int,\n help=\"trainer count for benchmark run\"\n )\n parser.add_argument(\n \"--ncudatrainer\",\n type=int,\n help=\"cudatrainer count for benchmark run\"\n )\n parser.add_argument(\n \"--filestore\",\n type=str,\n help=\"filestore location for process group\"\n )\n parser.add_argument(\n \"--server\",\n type=str,\n help=\"server map key to get trainer class for benchmark run\"\n )\n parser.add_argument(\n \"--nserver\",\n type=int,\n help=\"server count for benchmark run\"\n )\n parser.add_argument(\n \"--ncudaserver\",\n type=int,\n help=\"cudaserver count for benchmark run\"\n )\n parser.add_argument(\n \"--rpc_timeout\",\n type=int,\n help=\"timeout in seconds to use for RPC\"\n )\n parser.add_argument(\n \"--backend\",\n type=str,\n help=\"distributed communication backend to use for benchmark run\"\n )\n parser.add_argument(\n \"--epochs\",\n type=int,\n help=\"epoch count for training\"\n )\n parser.add_argument(\n \"--batch_size\",\n type=int,\n help=\"number of training examples used in one iteration\"\n )\n parser.add_argument(\n \"--data\",\n type=str,\n help=\"id for data configuration\"\n )\n parser.add_argument(\n \"--model\",\n type=str,\n help=\"id for model configuration\"\n )\n parser.add_argument(\n \"--data_config_path\",\n type=str,\n help=\"path to data configuration file\"\n )\n parser.add_argument(\n \"--model_config_path\",\n type=str,\n help=\"path to model configuration file\"\n )\n parser.add_argument(\n \"--server_config_path\",\n type=str,\n help=\"path to server configuration file\"\n )\n parser.add_argument(\n \"--trainer_config_path\",\n type=str,\n help=\"path to trainer configuration file\"\n )\n parser.add_argument(\n \"--torch_seed\",\n type=int,\n help=\"seed for generating random numbers to a non-deterministic random number\"\n )\n parser.add_argument(\n \"--cuda_seed\",\n type=int,\n help=\"seed for generating random numbers to a random number for the current GPU\"\n )\n parser.add_argument(\n \"--preprocess_data\",\n type=str,\n help=\"this function will be used to preprocess data before training\"\n )\n parser.add_argument(\n \"--create_criterion\",\n type=str,\n help=\"this function will be used to create the criterion used for model loss calculation\"\n )\n parser.add_argument(\n \"--create_ddp_model\",\n type=str,\n help=\"this function will be used to create the ddp model used during training\"\n )\n parser.add_argument(\n \"--hook_state\",\n type=str,\n help=\"this will be the state class used when registering the ddp communication hook\"\n )\n parser.add_argument(\n \"--ddp_hook\",\n type=str,\n default=\"allreduce_hook\",\n help=\"ddp communication hook\"\n )\n parser.add_argument(\n \"--iteration_step\",\n type=str,\n help=\"this will be the function called for each iteration of training\"\n )\n args = parser.parse_args()\n print(f\"{args}\\n\")\n main(args)\n",
"# Copyright (c) Facebook, Inc. and its affiliates.\n# All rights reserved.\n#\n# This source code is licensed under the BSD-style license found in the\n# LICENSE file in the root directory of this source tree.\n\nfrom typing import Any, Dict, SupportsInt, Tuple, cast\nfrom unittest import TestCase\n\nfrom torch.distributed import Store\nfrom torch.distributed.elastic.rendezvous import (\n RendezvousHandler,\n RendezvousHandlerRegistry,\n RendezvousParameters,\n)\n\n\nclass RendezvousParametersTest(TestCase):\n def setUp(self) -> None:\n self._backend = \"dummy_backend\"\n self._endpoint = \"dummy_endpoint\"\n self._run_id = \"dummy_run_id\"\n self._min_nodes = 3\n self._max_nodes = 6\n self._kwargs: Dict[str, Any] = {}\n\n def _create_params(self) -> RendezvousParameters:\n return RendezvousParameters(\n backend=self._backend,\n endpoint=self._endpoint,\n run_id=self._run_id,\n min_nodes=self._min_nodes,\n max_nodes=self._max_nodes,\n **self._kwargs,\n )\n\n def test_init_initializes_params(self) -> None:\n self._kwargs[\"dummy_param\"] = \"x\"\n\n params = self._create_params()\n\n self.assertEqual(params.backend, self._backend)\n self.assertEqual(params.endpoint, self._endpoint)\n self.assertEqual(params.run_id, self._run_id)\n self.assertEqual(params.min_nodes, self._min_nodes)\n self.assertEqual(params.max_nodes, self._max_nodes)\n\n self.assertEqual(params.get(\"dummy_param\"), \"x\")\n\n def test_init_initializes_params_if_min_nodes_equals_to_1(self) -> None:\n self._min_nodes = 1\n\n params = self._create_params()\n\n self.assertEqual(params.min_nodes, self._min_nodes)\n self.assertEqual(params.max_nodes, self._max_nodes)\n\n def test_init_initializes_params_if_min_and_max_nodes_are_equal(self) -> None:\n self._max_nodes = 3\n\n params = self._create_params()\n\n self.assertEqual(params.min_nodes, self._min_nodes)\n self.assertEqual(params.max_nodes, self._max_nodes)\n\n def test_init_raises_error_if_backend_is_none_or_empty(self) -> None:\n for backend in [None, \"\"]:\n with self.subTest(backend=backend):\n self._backend = backend # type: ignore[assignment]\n\n with self.assertRaisesRegex(\n ValueError,\n r\"^The rendezvous backend name must be a non-empty string.$\",\n ):\n self._create_params()\n\n def test_init_raises_error_if_min_nodes_is_less_than_1(self) -> None:\n for min_nodes in [0, -1, -5]:\n with self.subTest(min_nodes=min_nodes):\n self._min_nodes = min_nodes\n\n with self.assertRaisesRegex(\n ValueError,\n rf\"^The minimum number of rendezvous nodes \\({min_nodes}\\) must be greater \"\n rf\"than zero.$\",\n ):\n self._create_params()\n\n def test_init_raises_error_if_max_nodes_is_less_than_min_nodes(self) -> None:\n for max_nodes in [2, 1, -2]:\n with self.subTest(max_nodes=max_nodes):\n self._max_nodes = max_nodes\n\n with self.assertRaisesRegex(\n ValueError,\n rf\"^The maximum number of rendezvous nodes \\({max_nodes}\\) must be greater \"\n \"than or equal to the minimum number of rendezvous nodes \"\n rf\"\\({self._min_nodes}\\).$\",\n ):\n self._create_params()\n\n def test_get_returns_none_if_key_does_not_exist(self) -> None:\n params = self._create_params()\n\n self.assertIsNone(params.get(\"dummy_param\"))\n\n def test_get_returns_default_if_key_does_not_exist(self) -> None:\n params = self._create_params()\n\n self.assertEqual(params.get(\"dummy_param\", default=\"x\"), \"x\")\n\n def test_get_as_bool_returns_none_if_key_does_not_exist(self) -> None:\n params = self._create_params()\n\n self.assertIsNone(params.get_as_bool(\"dummy_param\"))\n\n def test_get_as_bool_returns_default_if_key_does_not_exist(self) -> None:\n params = self._create_params()\n\n self.assertTrue(params.get_as_bool(\"dummy_param\", default=True))\n\n def test_get_as_bool_returns_true_if_value_represents_true(self) -> None:\n for value in [\"1\", \"True\", \"tRue\", \"T\", \"t\", \"yEs\", \"Y\", 1, True]:\n with self.subTest(value=value):\n self._kwargs[\"dummy_param\"] = value\n\n params = self._create_params()\n\n self.assertTrue(params.get_as_bool(\"dummy_param\"))\n\n def test_get_as_bool_returns_false_if_value_represents_false(self) -> None:\n for value in [\"0\", \"False\", \"faLse\", \"F\", \"f\", \"nO\", \"N\", 0, False]:\n with self.subTest(value=value):\n self._kwargs[\"dummy_param\"] = value\n\n params = self._create_params()\n\n self.assertFalse(params.get_as_bool(\"dummy_param\"))\n\n def test_get_as_bool_raises_error_if_value_is_invalid(self) -> None:\n for value in [\"01\", \"Flse\", \"Ture\", \"g\", \"4\", \"_\", \"truefalse\", 2, -1]:\n with self.subTest(value=value):\n self._kwargs[\"dummy_param\"] = value\n\n params = self._create_params()\n\n with self.assertRaisesRegex(\n ValueError,\n r\"^The rendezvous configuration option 'dummy_param' does not represent a \"\n r\"valid boolean value.$\",\n ):\n params.get_as_bool(\"dummy_param\")\n\n def test_get_as_int_returns_none_if_key_does_not_exist(self) -> None:\n params = self._create_params()\n\n self.assertIsNone(params.get_as_int(\"dummy_param\"))\n\n def test_get_as_int_returns_default_if_key_does_not_exist(self) -> None:\n params = self._create_params()\n\n self.assertEqual(params.get_as_int(\"dummy_param\", default=5), 5)\n\n def test_get_as_int_returns_integer_if_value_represents_integer(self) -> None:\n for value in [\"0\", \"-10\", \"5\", \" 4\", \"4 \", \" 4 \", 0, -4, 3]:\n with self.subTest(value=value):\n self._kwargs[\"dummy_param\"] = value\n\n params = self._create_params()\n\n self.assertEqual(params.get_as_int(\"dummy_param\"), int(cast(SupportsInt, value)))\n\n def test_get_as_int_raises_error_if_value_is_invalid(self) -> None:\n for value in [\"a\", \"0a\", \"3b\", \"abc\"]:\n with self.subTest(value=value):\n self._kwargs[\"dummy_param\"] = value\n\n params = self._create_params()\n\n with self.assertRaisesRegex(\n ValueError,\n r\"^The rendezvous configuration option 'dummy_param' does not represent a \"\n r\"valid integer value.$\",\n ):\n params.get_as_int(\"dummy_param\")\n\n\nclass _DummyRendezvousHandler(RendezvousHandler):\n def __init__(self, params: RendezvousParameters) -> None:\n self.params = params\n\n def get_backend(self) -> str:\n return \"dummy_backend\"\n\n def next_rendezvous(self) -> Tuple[Store, int, int]:\n raise NotImplementedError()\n\n def is_closed(self) -> bool:\n return False\n\n def set_closed(self) -> None:\n pass\n\n def num_nodes_waiting(self) -> int:\n return 0\n\n def get_run_id(self) -> str:\n return \"\"\n\n def shutdown(self) -> bool:\n return False\n\n\nclass RendezvousHandlerRegistryTest(TestCase):\n def setUp(self) -> None:\n self._params = RendezvousParameters(\n backend=\"dummy_backend\",\n endpoint=\"dummy_endpoint\",\n run_id=\"dummy_run_id\",\n min_nodes=1,\n max_nodes=1,\n )\n\n self._registry = RendezvousHandlerRegistry()\n\n @staticmethod\n def _create_handler(params: RendezvousParameters) -> RendezvousHandler:\n return _DummyRendezvousHandler(params)\n\n def test_register_registers_once_if_called_twice_with_same_creator(self) -> None:\n self._registry.register(\"dummy_backend\", self._create_handler)\n self._registry.register(\"dummy_backend\", self._create_handler)\n\n def test_register_raises_error_if_called_twice_with_different_creators(self) -> None:\n self._registry.register(\"dummy_backend\", self._create_handler)\n\n other_create_handler = lambda p: _DummyRendezvousHandler(p) # noqa: E731\n\n with self.assertRaisesRegex(\n ValueError,\n r\"^The rendezvous backend 'dummy_backend' cannot be registered with \"\n rf\"'{other_create_handler}' as it is already registered with '{self._create_handler}'.$\",\n ):\n self._registry.register(\"dummy_backend\", other_create_handler)\n\n def test_create_handler_returns_handler(self) -> None:\n self._registry.register(\"dummy_backend\", self._create_handler)\n\n handler = self._registry.create_handler(self._params)\n\n self.assertIsInstance(handler, _DummyRendezvousHandler)\n\n self.assertIs(handler.params, self._params)\n\n def test_create_handler_raises_error_if_backend_is_not_registered(self) -> None:\n with self.assertRaisesRegex(\n ValueError,\n r\"^The rendezvous backend 'dummy_backend' is not registered. Did you forget to call \"\n r\"`register`\\?$\",\n ):\n self._registry.create_handler(self._params)\n\n def test_create_handler_raises_error_if_backend_names_do_not_match(self) -> None:\n self._registry.register(\"dummy_backend_2\", self._create_handler)\n\n with self.assertRaisesRegex(\n RuntimeError,\n r\"^The rendezvous backend 'dummy_backend' does not match the requested backend \"\n r\"'dummy_backend_2'.$\",\n ):\n self._params.backend = \"dummy_backend_2\"\n\n self._registry.create_handler(self._params)\n",
"from collections import defaultdict, abc as container_abcs\n\nimport torch\nfrom copy import deepcopy\nfrom itertools import chain\nimport warnings\nimport functools\n\n\nclass _RequiredParameter(object):\n \"\"\"Singleton class representing a required parameter for an Optimizer.\"\"\"\n def __repr__(self):\n return \"<required parameter>\"\n\nrequired = _RequiredParameter()\n\n\nclass Optimizer(object):\n r\"\"\"Base class for all optimizers.\n\n .. warning::\n Parameters need to be specified as collections that have a deterministic\n ordering that is consistent between runs. Examples of objects that don't\n satisfy those properties are sets and iterators over values of dictionaries.\n\n Args:\n params (iterable): an iterable of :class:`torch.Tensor` s or\n :class:`dict` s. Specifies what Tensors should be optimized.\n defaults: (dict): a dict containing default values of optimization\n options (used when a parameter group doesn't specify them).\n \"\"\"\n\n def __init__(self, params, defaults):\n torch._C._log_api_usage_once(\"python.optimizer\")\n self.defaults = defaults\n\n self._hook_for_profile()\n\n if isinstance(params, torch.Tensor):\n raise TypeError(\"params argument given to the optimizer should be \"\n \"an iterable of Tensors or dicts, but got \" +\n torch.typename(params))\n\n self.state = defaultdict(dict)\n self.param_groups = []\n\n param_groups = list(params)\n if len(param_groups) == 0:\n raise ValueError(\"optimizer got an empty parameter list\")\n if not isinstance(param_groups[0], dict):\n param_groups = [{'params': param_groups}]\n\n for param_group in param_groups:\n self.add_param_group(param_group)\n\n def __getstate__(self):\n return {\n 'defaults': self.defaults,\n 'state': self.state,\n 'param_groups': self.param_groups,\n }\n\n def __setstate__(self, state):\n self.__dict__.update(state)\n self._hook_for_profile() # To support multiprocessing pickle/unpickle.\n\n def __repr__(self):\n format_string = self.__class__.__name__ + ' ('\n for i, group in enumerate(self.param_groups):\n format_string += '\\n'\n format_string += 'Parameter Group {0}\\n'.format(i)\n for key in sorted(group.keys()):\n if key != 'params':\n format_string += ' {0}: {1}\\n'.format(key, group[key])\n format_string += ')'\n return format_string\n\n def _hook_for_profile(self):\n self._zero_grad_profile_name = \"Optimizer.zero_grad#{}.zero_grad\".format(self.__class__.__name__)\n\n def profile_hook_step(func):\n\n @functools.wraps(func)\n def wrapper(*args, **kwargs):\n obj, *_ = args\n profile_name = \"Optimizer.step#{}.step\".format(obj.__class__.__name__)\n with torch.autograd.profiler.record_function(profile_name):\n return func(*args, **kwargs)\n return wrapper\n\n hooked = getattr(self.__class__.step, \"hooked\", None)\n if not hooked:\n self.__class__.step = profile_hook_step(self.__class__.step)\n self.__class__.step.hooked = True\n\n def state_dict(self):\n r\"\"\"Returns the state of the optimizer as a :class:`dict`.\n\n It contains two entries:\n\n * state - a dict holding current optimization state. Its content\n differs between optimizer classes.\n * param_groups - a list containing all parameter groups where each\n parameter group is a dict\n \"\"\"\n # Save order indices instead of Tensors\n param_mappings = {}\n start_index = 0\n\n def pack_group(group):\n nonlocal start_index\n packed = {k: v for k, v in group.items() if k != 'params'}\n param_mappings.update({id(p): i for i, p in enumerate(group['params'], start_index)\n if id(p) not in param_mappings})\n packed['params'] = [param_mappings[id(p)] for p in group['params']]\n start_index += len(packed['params'])\n return packed\n param_groups = [pack_group(g) for g in self.param_groups]\n # Remap state to use order indices as keys\n packed_state = {(param_mappings[id(k)] if isinstance(k, torch.Tensor) else k): v\n for k, v in self.state.items()}\n return {\n 'state': packed_state,\n 'param_groups': param_groups,\n }\n\n def load_state_dict(self, state_dict):\n r\"\"\"Loads the optimizer state.\n\n Args:\n state_dict (dict): optimizer state. Should be an object returned\n from a call to :meth:`state_dict`.\n \"\"\"\n # deepcopy, to be consistent with module API\n state_dict = deepcopy(state_dict)\n # Validate the state_dict\n groups = self.param_groups\n saved_groups = state_dict['param_groups']\n\n if len(groups) != len(saved_groups):\n raise ValueError(\"loaded state dict has a different number of \"\n \"parameter groups\")\n param_lens = (len(g['params']) for g in groups)\n saved_lens = (len(g['params']) for g in saved_groups)\n if any(p_len != s_len for p_len, s_len in zip(param_lens, saved_lens)):\n raise ValueError(\"loaded state dict contains a parameter group \"\n \"that doesn't match the size of optimizer's group\")\n\n # Update the state\n id_map = {old_id: p for old_id, p in\n zip(chain.from_iterable((g['params'] for g in saved_groups)),\n chain.from_iterable((g['params'] for g in groups)))}\n\n def cast(param, value):\n r\"\"\"Make a deep copy of value, casting all tensors to device of param.\"\"\"\n if isinstance(value, torch.Tensor):\n # Floating-point types are a bit special here. They are the only ones\n # that are assumed to always match the type of params.\n if param.is_floating_point():\n value = value.to(param.dtype)\n value = value.to(param.device)\n return value\n elif isinstance(value, dict):\n return {k: cast(param, v) for k, v in value.items()}\n elif isinstance(value, container_abcs.Iterable):\n return type(value)(cast(param, v) for v in value)\n else:\n return value\n\n # Copy state assigned to params (and cast tensors to appropriate types).\n # State that is not assigned to params is copied as is (needed for\n # backward compatibility).\n state = defaultdict(dict)\n for k, v in state_dict['state'].items():\n if k in id_map:\n param = id_map[k]\n state[param] = cast(param, v)\n else:\n state[k] = v\n\n # Update parameter groups, setting their 'params' value\n def update_group(group, new_group):\n new_group['params'] = group['params']\n return new_group\n param_groups = [\n update_group(g, ng) for g, ng in zip(groups, saved_groups)]\n self.__setstate__({'state': state, 'param_groups': param_groups})\n\n def zero_grad(self, set_to_none: bool = False):\n r\"\"\"Sets the gradients of all optimized :class:`torch.Tensor` s to zero.\n\n Args:\n set_to_none (bool): instead of setting to zero, set the grads to None.\n This will in general have lower memory footprint, and can modestly improve performance.\n However, it changes certain behaviors. For example:\n 1. When the user tries to access a gradient and perform manual ops on it,\n a None attribute or a Tensor full of 0s will behave differently.\n 2. If the user requests ``zero_grad(set_to_none=True)`` followed by a backward pass, ``.grad``\\ s\n are guaranteed to be None for params that did not receive a gradient.\n 3. ``torch.optim`` optimizers have a different behavior if the gradient is 0 or None\n (in one case it does the step with a gradient of 0 and in the other it skips\n the step altogether).\n \"\"\"\n if not hasattr(self, \"_zero_grad_profile_name\"):\n self._hook_for_profile()\n with torch.autograd.profiler.record_function(self._zero_grad_profile_name):\n for group in self.param_groups:\n for p in group['params']:\n if p.grad is not None:\n if set_to_none:\n p.grad = None\n else:\n if p.grad.grad_fn is not None:\n p.grad.detach_()\n else:\n p.grad.requires_grad_(False)\n p.grad.zero_()\n\n def step(self, closure):\n r\"\"\"Performs a single optimization step (parameter update).\n\n Args:\n closure (callable): A closure that reevaluates the model and\n returns the loss. Optional for most optimizers.\n\n .. note::\n Unless otherwise specified, this function should not modify the\n ``.grad`` field of the parameters.\n \"\"\"\n raise NotImplementedError\n\n def add_param_group(self, param_group):\n r\"\"\"Add a param group to the :class:`Optimizer` s `param_groups`.\n\n This can be useful when fine tuning a pre-trained network as frozen layers can be made\n trainable and added to the :class:`Optimizer` as training progresses.\n\n Args:\n param_group (dict): Specifies what Tensors should be optimized along with group\n specific optimization options.\n \"\"\"\n assert isinstance(param_group, dict), \"param group must be a dict\"\n\n params = param_group['params']\n if isinstance(params, torch.Tensor):\n param_group['params'] = [params]\n elif isinstance(params, set):\n raise TypeError('optimizer parameters need to be organized in ordered collections, but '\n 'the ordering of tensors in sets will change between runs. Please use a list instead.')\n else:\n param_group['params'] = list(params)\n\n for param in param_group['params']:\n if not isinstance(param, torch.Tensor):\n raise TypeError(\"optimizer can only optimize Tensors, \"\n \"but one of the params is \" + torch.typename(param))\n if not param.is_leaf:\n raise ValueError(\"can't optimize a non-leaf Tensor\")\n\n for name, default in self.defaults.items():\n if default is required and name not in param_group:\n raise ValueError(\"parameter group didn't specify a value of required optimization parameter \" +\n name)\n else:\n param_group.setdefault(name, default)\n\n params = param_group['params']\n if len(params) != len(set(params)):\n warnings.warn(\"optimizer contains a parameter group with duplicate parameters; \"\n \"in future, this will cause an error; \"\n \"see github.com/pytorch/pytorch/issues/40967 for more information\", stacklevel=3)\n\n param_set = set()\n for group in self.param_groups:\n param_set.update(set(group['params']))\n\n if not param_set.isdisjoint(set(param_group['params'])):\n raise ValueError(\"some parameters appear in more than one parameter group\")\n\n self.param_groups.append(param_group)\n",
"import math\n\nfrom torch import nn\nfrom torch.nn import init\n\n\ndef _initialize_orthogonal(conv):\n prelu_gain = math.sqrt(2)\n init.orthogonal(conv.weight, gain=prelu_gain)\n if conv.bias is not None:\n conv.bias.data.zero_()\n\n\nclass ResidualBlock(nn.Module):\n def __init__(self, n_filters):\n super(ResidualBlock, self).__init__()\n self.conv1 = nn.Conv2d(n_filters, n_filters, kernel_size=3, padding=1, bias=False)\n self.bn1 = nn.BatchNorm2d(n_filters)\n self.prelu = nn.PReLU(n_filters)\n self.conv2 = nn.Conv2d(n_filters, n_filters, kernel_size=3, padding=1, bias=False)\n self.bn2 = nn.BatchNorm2d(n_filters)\n\n # Orthogonal initialisation\n _initialize_orthogonal(self.conv1)\n _initialize_orthogonal(self.conv2)\n\n def forward(self, x):\n residual = self.prelu(self.bn1(self.conv1(x)))\n residual = self.bn2(self.conv2(residual))\n return x + residual\n\n\nclass UpscaleBlock(nn.Module):\n def __init__(self, n_filters):\n super(UpscaleBlock, self).__init__()\n self.upscaling_conv = nn.Conv2d(n_filters, 4 * n_filters, kernel_size=3, padding=1)\n self.upscaling_shuffler = nn.PixelShuffle(2)\n self.upscaling = nn.PReLU(n_filters)\n _initialize_orthogonal(self.upscaling_conv)\n\n def forward(self, x):\n return self.upscaling(self.upscaling_shuffler(self.upscaling_conv(x)))\n\n\nclass SRResNet(nn.Module):\n def __init__(self, rescale_factor, n_filters, n_blocks):\n super(SRResNet, self).__init__()\n self.rescale_levels = int(math.log(rescale_factor, 2))\n self.n_filters = n_filters\n self.n_blocks = n_blocks\n\n self.conv1 = nn.Conv2d(3, n_filters, kernel_size=9, padding=4)\n self.prelu1 = nn.PReLU(n_filters)\n\n for residual_block_num in range(1, n_blocks + 1):\n residual_block = ResidualBlock(self.n_filters)\n self.add_module('residual_block' + str(residual_block_num), nn.Sequential(residual_block))\n\n self.skip_conv = nn.Conv2d(n_filters, n_filters, kernel_size=3, padding=1, bias=False)\n self.skip_bn = nn.BatchNorm2d(n_filters)\n\n for upscale_block_num in range(1, self.rescale_levels + 1):\n upscale_block = UpscaleBlock(self.n_filters)\n self.add_module('upscale_block' + str(upscale_block_num), nn.Sequential(upscale_block))\n\n self.output_conv = nn.Conv2d(n_filters, 3, kernel_size=9, padding=4)\n\n # Orthogonal initialisation\n _initialize_orthogonal(self.conv1)\n _initialize_orthogonal(self.skip_conv)\n _initialize_orthogonal(self.output_conv)\n\n def forward(self, x):\n x_init = self.prelu1(self.conv1(x))\n x = self.residual_block1(x_init)\n for residual_block_num in range(2, self.n_blocks + 1):\n x = getattr(self, 'residual_block' + str(residual_block_num))(x)\n x = self.skip_bn(self.skip_conv(x)) + x_init\n for upscale_block_num in range(1, self.rescale_levels + 1):\n x = getattr(self, 'upscale_block' + str(upscale_block_num))(x)\n return self.output_conv(x)\n",
"\n\n\n\n\nimport hypothesis.strategies as st\nimport numpy as np\n\nfrom caffe2.python import core\nfrom hypothesis import given, settings\nimport caffe2.python.hypothesis_test_util as hu\nimport caffe2.python.serialized_test.serialized_test_util as serial\n\n\nclass TestTopK(serial.SerializedTestCase):\n\n def top_k_ref(self, X, k, flatten_indices, axis=-1):\n in_dims = X.shape\n out_dims = list(in_dims)\n out_dims[axis] = k\n out_dims = tuple(out_dims)\n if axis == -1:\n axis = len(in_dims) - 1\n prev_dims = 1\n next_dims = 1\n for i in range(axis):\n prev_dims *= in_dims[i]\n for i in range(axis + 1, len(in_dims)):\n next_dims *= in_dims[i]\n n = in_dims[axis]\n X_flat = X.reshape((prev_dims, n, next_dims))\n\n values_ref = np.ndarray(\n shape=(prev_dims, k, next_dims), dtype=np.float32)\n values_ref.fill(0)\n indices_ref = np.ndarray(\n shape=(prev_dims, k, next_dims), dtype=np.int64)\n indices_ref.fill(-1)\n flatten_indices_ref = np.ndarray(\n shape=(prev_dims, k, next_dims), dtype=np.int64)\n flatten_indices_ref.fill(-1)\n for i in range(prev_dims):\n for j in range(next_dims):\n kv = []\n for x in range(n):\n val = X_flat[i, x, j]\n y = x * next_dims + i * in_dims[axis] * next_dims + j\n kv.append((val, x, y))\n cnt = 0\n for val, x, y in sorted(\n kv, key=lambda x: (x[0], -x[1]), reverse=True):\n values_ref[i, cnt, j] = val\n indices_ref[i, cnt, j] = x\n flatten_indices_ref[i, cnt, j] = y\n cnt += 1\n if cnt >= k or cnt >= n:\n break\n\n values_ref = values_ref.reshape(out_dims)\n indices_ref = indices_ref.reshape(out_dims)\n flatten_indices_ref = flatten_indices_ref.flatten()\n\n if flatten_indices:\n return (values_ref, indices_ref, flatten_indices_ref)\n else:\n return (values_ref, indices_ref)\n\n @serial.given(\n X=hu.tensor(),\n flatten_indices=st.booleans(),\n seed=st.integers(0, 10),\n **hu.gcs\n )\n def test_top_k(self, X, flatten_indices, seed, gc, dc):\n X = X.astype(dtype=np.float32)\n np.random.seed(seed)\n # `k` can be larger than the total size\n k = np.random.randint(1, X.shape[-1] + 4)\n\n output_list = [\"Values\", \"Indices\"]\n if flatten_indices:\n output_list.append(\"FlattenIndices\")\n op = core.CreateOperator(\"TopK\", [\"X\"], output_list,\n k=k, device_option=gc)\n\n def bind_ref(X_loc):\n return self.top_k_ref(X_loc, k, flatten_indices)\n\n self.assertReferenceChecks(gc, op, [X], bind_ref)\n self.assertDeviceChecks(dc, op, [X], [0])\n\n @given(bs=st.integers(1, 3), n=st.integers(1, 1), k=st.integers(1, 1),\n flatten_indices=st.booleans(), **hu.gcs)\n def test_top_k_1(self, bs, n, k, flatten_indices, gc, dc):\n X = np.random.rand(bs, n).astype(dtype=np.float32)\n output_list = [\"Values\", \"Indices\"]\n if flatten_indices:\n output_list.append(\"FlattenIndices\")\n op = core.CreateOperator(\"TopK\", [\"X\"], output_list,\n k=k, device_option=gc)\n\n def bind_ref(X_loc):\n return self.top_k_ref(X_loc, k, flatten_indices)\n\n self.assertReferenceChecks(gc, op, [X], bind_ref)\n self.assertDeviceChecks(dc, op, [X], [0])\n\n @given(bs=st.integers(1, 3), n=st.integers(1, 10000), k=st.integers(1, 1),\n flatten_indices=st.booleans(), **hu.gcs)\n def test_top_k_2(self, bs, n, k, flatten_indices, gc, dc):\n X = np.random.rand(bs, n).astype(dtype=np.float32)\n\n output_list = [\"Values\", \"Indices\"]\n if flatten_indices:\n output_list.append(\"FlattenIndices\")\n op = core.CreateOperator(\"TopK\", [\"X\"], output_list,\n k=k, device_option=gc)\n\n def bind_ref(X_loc):\n return self.top_k_ref(X_loc, k, flatten_indices)\n\n self.assertReferenceChecks(gc, op, [X], bind_ref)\n self.assertDeviceChecks(dc, op, [X], [0])\n\n @given(bs=st.integers(1, 3), n=st.integers(1, 10000),\n k=st.integers(1, 1024), flatten_indices=st.booleans(), **hu.gcs)\n def test_top_k_3(self, bs, n, k, flatten_indices, gc, dc):\n X = np.random.rand(bs, n).astype(dtype=np.float32)\n output_list = [\"Values\", \"Indices\"]\n if flatten_indices:\n output_list.append(\"FlattenIndices\")\n op = core.CreateOperator(\"TopK\", [\"X\"], output_list,\n k=k, device_option=gc)\n\n def bind_ref(X_loc):\n return self.top_k_ref(X_loc, k, flatten_indices)\n\n self.assertReferenceChecks(gc, op, [X], bind_ref)\n self.assertDeviceChecks(dc, op, [X], [0])\n\n @given(bs=st.integers(1, 3), n=st.integers(100, 10000),\n flatten_indices=st.booleans(), **hu.gcs)\n @settings(deadline=10000)\n def test_top_k_4(self, bs, n, flatten_indices, gc, dc):\n k = np.random.randint(n // 3, 3 * n // 4)\n X = np.random.rand(bs, n).astype(dtype=np.float32)\n\n output_list = [\"Values\", \"Indices\"]\n if flatten_indices:\n output_list.append(\"FlattenIndices\")\n op = core.CreateOperator(\"TopK\", [\"X\"], output_list,\n k=k, device_option=gc)\n\n def bind_ref(X_loc):\n return self.top_k_ref(X_loc, k, flatten_indices)\n\n self.assertReferenceChecks(gc, op, [X], bind_ref)\n self.assertDeviceChecks(dc, op, [X], [0])\n\n @given(bs=st.integers(1, 3), n=st.integers(1, 1024),\n flatten_indices=st.booleans(), **hu.gcs)\n def test_top_k_5(self, bs, n, flatten_indices, gc, dc):\n k = n\n X = np.random.rand(bs, n).astype(dtype=np.float32)\n\n output_list = [\"Values\", \"Indices\"]\n if flatten_indices:\n output_list.append(\"FlattenIndices\")\n op = core.CreateOperator(\"TopK\", [\"X\"], output_list,\n k=k, device_option=gc)\n\n def bind_ref(X_loc):\n return self.top_k_ref(X_loc, k, flatten_indices)\n\n self.assertReferenceChecks(gc, op, [X], bind_ref)\n self.assertDeviceChecks(dc, op, [X], [0])\n\n @given(bs=st.integers(1, 3), n=st.integers(1, 5000),\n flatten_indices=st.booleans(), **hu.gcs)\n @settings(deadline=10000)\n def test_top_k_6(self, bs, n, flatten_indices, gc, dc):\n k = n\n X = np.random.rand(bs, n).astype(dtype=np.float32)\n\n output_list = [\"Values\", \"Indices\"]\n if flatten_indices:\n output_list.append(\"FlattenIndices\")\n op = core.CreateOperator(\"TopK\", [\"X\"], output_list,\n k=k, device_option=gc)\n\n def bind_ref(X_loc):\n return self.top_k_ref(X_loc, k, flatten_indices)\n\n self.assertReferenceChecks(gc, op, [X], bind_ref)\n self.assertDeviceChecks(dc, op, [X], [0])\n\n @given(X=hu.tensor(dtype=np.float32), k=st.integers(1, 5),\n axis=st.integers(-1, 5), flatten_indices=st.booleans(),\n **hu.gcs)\n def test_top_k_axis(self, X, k, axis, flatten_indices, gc, dc):\n dims = X.shape\n if axis >= len(dims):\n axis %= len(dims)\n\n output_list = [\"Values\", \"Indices\"]\n if flatten_indices:\n output_list.append(\"FlattenIndices\")\n op = core.CreateOperator(\n \"TopK\", [\"X\"], output_list, k=k, axis=axis, device_option=gc)\n\n def bind_ref(X_loc):\n return self.top_k_ref(X_loc, k, flatten_indices, axis)\n\n self.assertReferenceChecks(gc, op, [X], bind_ref)\n self.assertDeviceChecks(dc, op, [X], [0])\n\n @given(X=hu.tensor(dtype=np.float32), k=st.integers(1, 5),\n axis=st.integers(-1, 5), **hu.gcs)\n @settings(deadline=10000)\n def test_top_k_grad(self, X, k, axis, gc, dc):\n dims = X.shape\n if axis >= len(dims):\n axis %= len(dims)\n\n input_axis = len(dims) - 1 if axis == -1 else axis\n prev_dims = 1\n next_dims = 1\n for i in range(input_axis):\n prev_dims *= dims[i]\n for i in range(input_axis + 1, len(dims)):\n next_dims *= dims[i]\n\n X_flat = X.reshape((prev_dims, dims[input_axis], next_dims))\n for i in range(prev_dims):\n for j in range(next_dims):\n # this try to make sure adding stepsize (0.05)\n # will not change TopK selections at all\n X_flat[i, :, j] = np.arange(dims[axis], dtype=np.float32) / 5\n np.random.shuffle(X_flat[i, :, j])\n X = X_flat.reshape(dims)\n\n op = core.CreateOperator(\n \"TopK\", [\"X\"], [\"Values\", \"Indices\"], k=k, axis=axis,\n device_option=gc)\n\n self.assertGradientChecks(gc, op, [X], 0, [0], stepsize=0.05)\n",
"\"\"\"\nThis is a script for end-to-end mobile custom build test purpose. It prepares\nMobileNetV2 TorchScript model, and dumps root ops used by the model for custom\nbuild script to create a tailored build which only contains these used ops.\n\"\"\"\n\nimport torch\nimport torchvision\nimport yaml\n\n# Download and trace the model.\nmodel = torchvision.models.mobilenet_v2(pretrained=True)\nmodel.eval()\nexample = torch.rand(1, 3, 224, 224)\ntraced_script_module = torch.jit.trace(model, example)\n\n# Save traced TorchScript model.\ntraced_script_module.save(\"MobileNetV2.pt\")\n\n# Dump root ops used by the model (for custom build optimization).\nops = torch.jit.export_opnames(traced_script_module)\n\n# Besides the ops used by the model, custom c++ client code might use some extra\n# ops, too. For example, the dummy predictor.cpp driver in this test suite calls\n# `aten::ones` to create all-one-tensor for testing purpose, which is not used\n# by the MobileNetV2 model itself.\n#\n# This is less a problem for Android, where we expect users to use the limited\n# set of Java APIs. To actually solve this problem, we probably need ask users\n# to run code analyzer against their client code to dump these extra root ops.\n# So it will require more work to switch to custom build with dynamic dispatch -\n# in static dispatch case these extra ops will be kept by linker automatically.\n#\n# For CI purpose this one-off hack is probably fine? :)\nEXTRA_CI_ROOT_OPS = ['aten::ones']\n\nops.extend(EXTRA_CI_ROOT_OPS)\nwith open('MobileNetV2.yaml', 'w') as output:\n yaml.dump(ops, output)\n",
"\n\n\n\n\nfrom caffe2.python import core\nfrom hypothesis import given, settings\nimport caffe2.python.hypothesis_test_util as hu\nimport caffe2.python.serialized_test.serialized_test_util as serial\nimport hypothesis.strategies as st\nimport numpy as np\nimport math\n\nMAX_TEST_EMBEDDING_SIZE = 20\nMAX_TEST_SEQUENCE_LENGTH = 10\nMAX_TEST_BATCH_SIZE = 5\nMIN_TEST_ALPHA = 5000.0\nMAX_TEST_ALPHA = 20000.0\nMIN_TEST_AMPLITUDE = 0.1\nMAX_TEST_AMPLITUDE = 10.0\n\n\nclass TestSinusoidPositionEncodingOp(serial.SerializedTestCase):\n @given(\n positions_vec=hu.arrays(\n dims=[MAX_TEST_SEQUENCE_LENGTH],\n dtype=np.int32,\n elements=st.integers(1, MAX_TEST_SEQUENCE_LENGTH)\n ),\n embedding_size=st.integers(1, MAX_TEST_EMBEDDING_SIZE),\n batch_size=st.integers(1, MAX_TEST_BATCH_SIZE),\n alpha=st.floats(MIN_TEST_ALPHA, MAX_TEST_ALPHA),\n amplitude=st.floats(MIN_TEST_AMPLITUDE, MAX_TEST_AMPLITUDE),\n **hu.gcs_cpu_only\n )\n @settings(deadline=10000)\n def test_sinusoid_embedding(\n self, positions_vec, embedding_size, batch_size, alpha, amplitude, gc, dc\n ):\n positions = np.tile(positions_vec, [batch_size, 1]).transpose()\n\n op = core.CreateOperator(\n \"SinusoidPositionEncoding\",\n [\"positions\"],\n [\"output\"],\n embedding_size=embedding_size,\n alpha=alpha,\n amplitude=amplitude,\n )\n\n def sinusoid_encoding(dim, position):\n x = 1. * position / math.pow(alpha, 1. * dim / embedding_size)\n if dim % 2 == 0:\n return amplitude * math.sin(x)\n else:\n return amplitude * math.cos(x)\n\n def sinusoid_embedding_op(positions):\n output_shape = (len(positions), len(positions[0]), embedding_size)\n ar = np.zeros(output_shape)\n for i, position_vector in enumerate(positions):\n for j, position in enumerate(position_vector):\n for k in range(embedding_size):\n ar[i, j, k] = sinusoid_encoding(k, position)\n return [ar]\n\n self.assertReferenceChecks(\n device_option=gc,\n op=op,\n inputs=[positions],\n reference=sinusoid_embedding_op,\n )\n",
"\nimport operator_benchmark as op_bench\nimport torch\nimport torch.nn.quantized as nnq\nimport torch.quantization as tq\nimport torch.nn as nn\n\n\"\"\"Microbenchmarks for general quantization operations.\"\"\"\n\n# mode is used to show the direction of the benchmark:\n# if 'Q', benchmark quantization, else dequantization\n\nquantize_configs_short_dict = {\n 'attr_names': ['C', 'M', 'N', 'dtype', 'mode'],\n 'attrs': [\n [3, 512, 512, torch.quint8, 'Q'],\n [3, 512, 512, torch.quint8, 'D'],\n ],\n 'tags': ['short'],\n}\n\nquantize_configs_long_dict = {\n 'C': [3, 5, 8], # this is reused for per-channel: avoid single channel test\n 'M': [256, 1024],\n 'N': [256, 1024],\n 'dtype': [torch.quint8, torch.qint8, torch.qint32],\n 'mode': ['D', 'Q'],\n 'tags': ['long'],\n}\n\n\nquantize_per_tensor_configs_short = op_bench.config_list(\n **quantize_configs_short_dict\n)\n\nquantize_per_tensor_configs_long = op_bench.cross_product_configs(\n **quantize_configs_long_dict\n)\n\n\nclass QuantizePerTensorBenchmark(op_bench.TorchBenchmarkBase):\n r\"\"\"Benchmarks both quantization and dequantization.\"\"\"\n def init(self, C, M, N, dtype, mode):\n assert(mode in ('Q', 'D'))\n self.input = torch.rand(C, M, N)\n self.dtype = dtype\n self.op = nnq.Quantize(scale=1.0, zero_point=0, dtype=dtype)\n self.set_module_name('QuantizePerTensor')\n\n if mode == 'D':\n self.input = self.op(self.input)\n self.op = nnq.DeQuantize()\n self.set_module_name('DequantizePerTensor')\n\n self.inputs = {\n \"input\": self.input\n }\n\n def forward(self, input):\n return self.op(input)\n\n\nop_bench.generate_pt_test(\n quantize_per_tensor_configs_short + quantize_per_tensor_configs_long,\n QuantizePerTensorBenchmark)\n\n# === Per Channel quantization ===\n\nquantize_per_channel_configs_short = op_bench.config_list(\n cross_product_configs={\n 'axis': (0,)\n },\n **quantize_configs_short_dict\n)\n\nquantize_per_channel_configs_long = op_bench.cross_product_configs(\n axis=(0, 1, 2),\n **quantize_configs_long_dict\n)\n\nclass QuantizePerChannelBenchmark(op_bench.TorchBenchmarkBase):\n r\"\"\"Benchmarks both quantization and dequantization.\"\"\"\n def init(self, C, M, N, dtype, axis, mode):\n assert(mode in ('Q', 'D'))\n self.input = torch.rand(C, M, N)\n self.op = torch.quantize_per_channel\n\n channel_len = (C, M, N)[axis]\n\n self.kwargs = {\n 'scales': torch.tensor([1.0] * channel_len),\n 'zero_points': torch.tensor([0] * channel_len),\n 'dtype': dtype,\n 'axis': axis\n }\n\n self.set_module_name('QuantizePerChannel')\n\n if mode == 'D':\n self.input = self.op(self.input, **self.kwargs)\n\n def dequant(input, scales, zero_points, axis: int, dtype: int):\n return input.dequantize()\n self.op = dequant\n self.set_module_name('DequantizePerChannel')\n\n self.inputs = {\n \"input\": self.input,\n 'scales': torch.tensor([1.0] * channel_len),\n 'zero_points': torch.tensor([0] * channel_len),\n 'axis': axis,\n 'dtype': dtype\n }\n\n def forward(self, input, scales, zero_points, axis: int, dtype: int):\n return self.op(input, scales=scales, zero_points=zero_points, axis=axis, dtype=dtype)\n\n\nop_bench.generate_pt_test(\n quantize_per_channel_configs_short + quantize_per_channel_configs_long,\n QuantizePerChannelBenchmark)\n\n# === Fake Quantization ===\n\nfake_quantize_configs_short_dict = {\n 'attr_names': ['N', 'C', 'H', 'W'],\n 'attrs': [\n [1, 3, 512, 512],\n ],\n 'tags': ['short']\n}\n\nfake_quantize_configs_long_dict = {\n 'N': [1],\n 'C': [1, 3, 8, 32],\n 'H': [256, 1024],\n 'W': [256, 1024],\n 'tags': ['long']\n}\n\nfake_quantize_configs_short = op_bench.config_list(\n cross_product_configs={\n 'device': ('cpu', 'cuda'),\n },\n **fake_quantize_configs_short_dict\n)\n\nfake_quantize_configs_long = op_bench.cross_product_configs(\n device=('cpu', 'cuda'),\n **fake_quantize_configs_long_dict\n)\n\n\nclass FakeQuantizeBenchmark(op_bench.TorchBenchmarkBase):\n r\"\"\"Benchmarks fake quantization with default parameters.\"\"\"\n def init(self, N, C, H, W, device):\n self.inputs = {\n \"input\": torch.rand(N, C, H, W).to(device)\n }\n self.op = tq.FakeQuantize().to(device)\n self.set_module_name('FakeQuantize')\n\n def forward(self, input):\n return self.op(input)\n\n\nop_bench.generate_pt_test(\n fake_quantize_configs_short + fake_quantize_configs_long,\n FakeQuantizeBenchmark)\n\n\n# op_type is used to describe the type of operator used in benchmarking:\n# learnable_kernel represents the c++ kernel that can backpropagate on\n# scale and zero point.\n# original_kernel represents the original fake quantize c++ kernel.\n\ndef fakeQuantizePerTensorLearnableKernel(\n input, scale, zero_point,\n quant_min: int, quant_max: int\n):\n return torch._fake_quantize_learnable_per_tensor_affine(input, scale, zero_point, quant_min, quant_max)\n\ndef fakeQuantizePerTensorOriginalKernel(\n input, scale, zero_point,\n quant_min: int, quant_max: int\n):\n return torch.fake_quantize_per_tensor_affine(input, 1.0, 0, quant_min, quant_max)\n\nfake_quantize_per_tensor_ops = op_bench.op_list(\n attrs=(\n ('learnable_kernel', fakeQuantizePerTensorLearnableKernel),\n ('original_kernel', fakeQuantizePerTensorOriginalKernel)\n ),\n attr_names=('op_name', 'op_func'),\n)\n\nfake_quantize_operator_configs_short = op_bench.config_list(\n cross_product_configs={\n 'nbits': (4, 8),\n 'device': ('cpu', 'cuda'),\n },\n **fake_quantize_configs_short_dict\n)\n\nfake_quantize_operator_configs_long = op_bench.cross_product_configs(\n nbits=(4, 8),\n device=('cpu', 'cuda'),\n **fake_quantize_configs_long_dict\n)\n\nclass FakeQuantizePerTensorBaseOpBenchmark(op_bench.TorchBenchmarkBase):\n r\"\"\"Benchmarks 3 different fake quantize per tensor operators.\"\"\"\n def init(self, N, C, H, W, nbits, device, op_func):\n self.quant_min = 0\n self.quant_max = 2 ** nbits - 1\n self.quant_range = 2 ** nbits\n self.input = nn.Parameter(torch.rand(N, C, H, W, dtype=torch.float, device=device), requires_grad=self.auto_set())\n self.scale = nn.Parameter(torch.tensor([1.]).to(device), requires_grad=self.auto_set())\n self.zero_point = nn.Parameter(torch.tensor([0.]).to(device), requires_grad=self.auto_set())\n\n self.inputs = {\n \"input\": self.input,\n \"scale\": self.scale,\n \"zero_point\": self.zero_point,\n \"quant_min\": self.quant_min,\n \"quant_max\": self.quant_max,\n }\n self.op_func = op_func\n\n def forward(\n self, input, scale, zero_point,\n quant_min: int, quant_max: int\n ):\n return self.op_func(input, scale, zero_point, quant_min, quant_max)\n\nop_bench.generate_pt_tests_from_op_list(\n fake_quantize_per_tensor_ops,\n fake_quantize_operator_configs_short + fake_quantize_operator_configs_long,\n FakeQuantizePerTensorBaseOpBenchmark\n)\nop_bench.generate_pt_gradient_tests_from_op_list(\n fake_quantize_per_tensor_ops,\n fake_quantize_operator_configs_short + fake_quantize_operator_configs_long,\n FakeQuantizePerTensorBaseOpBenchmark\n)\n\ndef fakeQuantizePerChannelLearnableKernel(\n input, scale, zero_point, axis: int,\n quant_min: int, quant_max: int\n):\n return torch._fake_quantize_learnable_per_channel_affine(input, scale, zero_point, axis, quant_min, quant_max)\n\ndef fakeQuantizePerChannelOriginalKernel(\n input, scale, zero_point, axis: int,\n quant_min: int, quant_max: int\n):\n return torch.fake_quantize_per_channel_affine(input, scale, zero_point, axis, quant_min, quant_max)\n\nfake_quantize_per_channel_ops = op_bench.op_list(\n attrs=(\n ('learnable_kernel', fakeQuantizePerChannelLearnableKernel),\n ('original_kernel', fakeQuantizePerChannelOriginalKernel)\n ),\n attr_names=('op_name', 'op_func'),\n)\n\nclass FakeQuantizePerChannelOpBenchmark(op_bench.TorchBenchmarkBase):\n r\"\"\"Benchmarks 3 different fake quantize per channel operators.\"\"\"\n def init(self, N, C, H, W, nbits, device, op_func):\n self.quant_min = 0\n self.quant_max = 2 ** nbits - 1\n self.quant_range = 2 ** nbits\n # Axis is chosen with respect to the number of channels: C.\n self.axis = 1\n self.input = nn.Parameter(torch.rand(N, C, H, W, dtype=torch.float, device=device, requires_grad=self.auto_set()))\n\n if op_func.__name__ == 'fakeQuantizePerChannelOriginalKernel':\n self.scale = torch.ones(C, device=device, dtype=torch.float32, requires_grad=False)\n self.zero_point = torch.zeros(C, device=device, dtype=torch.int32, requires_grad=False)\n else:\n self.scale = nn.Parameter(torch.ones(C, device=device, dtype=torch.float32), requires_grad=self.auto_set())\n self.zero_point = nn.Parameter(torch.zeros(C, device=device, dtype=torch.float32), requires_grad=self.auto_set())\n\n self.inputs = {\n \"input\": self.input,\n \"scale\": self.scale,\n \"zero_point\": self.zero_point,\n \"axis\": self.axis,\n \"quant_min\": self.quant_min,\n \"quant_max\": self.quant_max,\n }\n\n self.op_func = op_func\n\n def forward(\n self, input, scale, zero_point,\n axis: int, quant_min: int, quant_max: int\n ):\n return self.op_func(input, scale, zero_point, axis, quant_min, quant_max)\n\nop_bench.generate_pt_tests_from_op_list(\n fake_quantize_per_channel_ops,\n fake_quantize_operator_configs_short + fake_quantize_operator_configs_long,\n FakeQuantizePerChannelOpBenchmark\n)\n\nop_bench.generate_pt_gradient_tests_from_op_list(\n fake_quantize_per_channel_ops,\n fake_quantize_operator_configs_short + fake_quantize_operator_configs_long,\n FakeQuantizePerChannelOpBenchmark\n)\n\nif __name__ == \"__main__\":\n op_bench.benchmark_runner.main()\n",
"import torch\nfrom typing import Any\n# The _get_device_index has been moved to torch.utils._get_device_index\nfrom torch._utils import _get_device_index as _torch_get_device_index\n\n\ndef _get_device_index(device: Any, optional: bool = False,\n allow_cpu: bool = False) -> int:\n r\"\"\"Gets the device index from :attr:`device`, which can be a torch.device\n object, a Python integer, or ``None``.\n\n If :attr:`device` is a torch.device object, returns the device index if it\n is a CUDA device. Note that for a CUDA device without a specified index,\n i.e., ``torch.device('cuda')``, this will return the current default CUDA\n device if :attr:`optional` is ``True``. If :attr:`allow_cpu` is ``True``,\n CPU devices will be accepted and ``-1`` will be returned in this case.\n\n If :attr:`device` is a Python integer, it is returned as is.\n\n If :attr:`device` is ``None``, this will return the current default CUDA\n device if :attr:`optional` is ``True``.\n \"\"\"\n if isinstance(device, str):\n device = torch.device(device)\n if isinstance(device, torch.device):\n if allow_cpu:\n if device.type not in ['cuda', 'cpu']:\n raise ValueError('Expected a cuda or cpu device, but got: {}'.format(device))\n elif device.type != 'cuda':\n raise ValueError('Expected a cuda device, but got: {}'.format(device))\n if not torch.jit.is_scripting():\n if isinstance(device, torch.cuda.device):\n return device.idx\n return _torch_get_device_index(device, optional, allow_cpu)\n\n\ndef _dummy_type(name: str) -> type:\n def init_err(self):\n class_name = self.__class__.__name__\n raise RuntimeError(\n \"Tried to instantiate dummy base class {}\".format(class_name))\n return type(name, (object,), {\"__init__\": init_err})\n",
"# This a large test that goes through the translation of the bvlc caffenet\n# model, runs an example through the whole model, and verifies numerically\n# that all the results look right. In default, it is disabled unless you\n# explicitly want to run it.\n\nfrom google.protobuf import text_format\nimport numpy as np\nimport os\nimport sys\n\nCAFFE_FOUND = False\ntry:\n from caffe.proto import caffe_pb2\n from caffe2.python import caffe_translator\n CAFFE_FOUND = True\nexcept Exception as e:\n # Safeguard so that we only catch the caffe module not found exception.\n if (\"'caffe'\" in str(e)):\n print(\n \"PyTorch/Caffe2 now requires a separate installation of caffe. \"\n \"Right now, this is not found, so we will skip the caffe \"\n \"translator test.\")\n\nfrom caffe2.python import utils, workspace, test_util\nimport unittest\n\ndef setUpModule():\n # Do nothing if caffe and test data is not found\n if not (CAFFE_FOUND and os.path.exists('data/testdata/caffe_translator')):\n return\n # We will do all the computation stuff in the global space.\n caffenet = caffe_pb2.NetParameter()\n caffenet_pretrained = caffe_pb2.NetParameter()\n with open('data/testdata/caffe_translator/deploy.prototxt') as f:\n text_format.Merge(f.read(), caffenet)\n with open('data/testdata/caffe_translator/'\n 'bvlc_reference_caffenet.caffemodel') as f:\n caffenet_pretrained.ParseFromString(f.read())\n for remove_legacy_pad in [True, False]:\n net, pretrained_params = caffe_translator.TranslateModel(\n caffenet, caffenet_pretrained, is_test=True,\n remove_legacy_pad=remove_legacy_pad\n )\n with open('data/testdata/caffe_translator/'\n 'bvlc_reference_caffenet.translatedmodel',\n 'w') as fid:\n fid.write(str(net))\n for param in pretrained_params.protos:\n workspace.FeedBlob(param.name, utils.Caffe2TensorToNumpyArray(param))\n # Let's also feed in the data from the Caffe test code.\n data = np.load('data/testdata/caffe_translator/data_dump.npy').astype(\n np.float32)\n workspace.FeedBlob('data', data)\n # Actually running the test.\n workspace.RunNetOnce(net.SerializeToString())\n\n\[email protected](not CAFFE_FOUND,\n 'No Caffe installation found.')\[email protected](not os.path.exists('data/testdata/caffe_translator'),\n 'No testdata existing for the caffe translator test. Exiting.')\nclass TestNumericalEquivalence(test_util.TestCase):\n def testBlobs(self):\n names = [\n \"conv1\", \"pool1\", \"norm1\", \"conv2\", \"pool2\", \"norm2\", \"conv3\",\n \"conv4\", \"conv5\", \"pool5\", \"fc6\", \"fc7\", \"fc8\", \"prob\"\n ]\n for name in names:\n print('Verifying {}'.format(name))\n caffe2_result = workspace.FetchBlob(name)\n reference = np.load(\n 'data/testdata/caffe_translator/' + name + '_dump.npy'\n )\n self.assertEqual(caffe2_result.shape, reference.shape)\n scale = np.max(caffe2_result)\n np.testing.assert_almost_equal(\n caffe2_result / scale,\n reference / scale,\n decimal=5\n )\n\n\nif __name__ == '__main__':\n if len(sys.argv) == 1:\n print(\n 'If you do not explicitly ask to run this test, I will not run it. '\n 'Pass in any argument to have the test run for you.'\n )\n sys.exit(0)\n unittest.main()\n",
"\n\n\n\n\nimport hypothesis.strategies as st\nimport numpy as np\nimport numpy.testing as npt\nfrom hypothesis import given, settings\n\nimport caffe2.python.hypothesis_test_util as hu\n\nfrom caffe2.python import (\n layer_model_instantiator,\n core,\n schema,\n workspace,\n)\nfrom caffe2.python.layers.layers import (\n AccessedFeatures,\n almost_equal_schemas,\n get_key,\n IdList,\n IdScoreList,\n InstantiationContext,\n is_request_only_scalar,\n set_request_only,\n)\nfrom caffe2.python.layers.tags import Tags\nfrom caffe2.python.layer_test_util import (\n LayersTestCase,\n OpSpec,\n)\nimport logging\nlogger = logging.getLogger(__name__)\n\n\nclass TestLayers(LayersTestCase):\n def testSparseDropoutWithReplacement(self):\n input_record = schema.NewRecord(self.model.net, IdList)\n self.model.output_schema = schema.Struct()\n\n lengths_blob = input_record.field_blobs()[0]\n values_blob = input_record.field_blobs()[1]\n lengths = np.array([1] * 10).astype(np.int32)\n values = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]).astype(np.int64)\n workspace.FeedBlob(lengths_blob, lengths)\n workspace.FeedBlob(values_blob, values)\n\n out = self.model.SparseDropoutWithReplacement(\n input_record, 0.0, 0.5, 1.0, -1, output_names_or_num=1)\n self.assertEqual(schema.List(schema.Scalar(np.int64,)), out)\n\n train_init_net, train_net = self.get_training_nets()\n eval_net = self.get_eval_net()\n predict_net = self.get_predict_net()\n\n workspace.RunNetOnce(train_init_net)\n workspace.RunNetOnce(train_net)\n out_values = workspace.FetchBlob(out.items())\n out_lengths = workspace.FetchBlob(out.lengths())\n self.assertBlobsEqual(out_values, values)\n self.assertBlobsEqual(out_lengths, lengths)\n\n workspace.RunNetOnce(eval_net)\n\n workspace.RunNetOnce(predict_net)\n predict_values = workspace.FetchBlob(\"values_auto_0\")\n predict_lengths = workspace.FetchBlob(\"lengths_auto_0\")\n self.assertBlobsEqual(predict_values, np.array([-1] * 10).astype(np.int64))\n self.assertBlobsEqual(predict_lengths, lengths)\n\n def testAddLoss(self):\n input_record_LR = self.new_record(\n schema.Struct(\n ('label', schema.Scalar((np.float64, (1, )))),\n ('logit', schema.Scalar((np.float32, (2, )))),\n ('weight', schema.Scalar((np.float64, (1, ))))\n )\n )\n loss_LR = self.model.BatchLRLoss(input_record_LR)\n\n self.model.add_loss(loss_LR)\n assert 'unnamed' in self.model.loss\n self.assertEqual(\n schema.Scalar((np.float32, tuple())), self.model.loss.unnamed\n )\n self.assertEqual(loss_LR, self.model.loss.unnamed)\n\n self.model.add_loss(loss_LR, 'addLoss')\n assert 'addLoss' in self.model.loss\n self.assertEqual(\n schema.Scalar((np.float32, tuple())), self.model.loss.addLoss\n )\n self.assertEqual(loss_LR, self.model.loss.addLoss)\n\n self.model.add_loss(\n schema.Scalar(\n dtype=np.float32, blob=core.BlobReference('loss_blob_1')\n ), 'addLoss'\n )\n assert 'addLoss_auto_0' in self.model.loss\n self.assertEqual(\n schema.Scalar((np.float32, tuple())), self.model.loss.addLoss_auto_0\n )\n assert core.BlobReference('loss_blob_1') in self.model.loss.field_blobs()\n\n self.model.add_loss(\n schema.Struct(\n (\n 'structName', schema.Scalar(\n dtype=np.float32,\n blob=core.BlobReference('loss_blob_2')\n )\n )\n ), 'addLoss'\n )\n assert 'addLoss_auto_1' in self.model.loss\n self.assertEqual(\n schema.Struct(('structName', schema.Scalar((np.float32, tuple())))),\n self.model.loss.addLoss_auto_1\n )\n assert core.BlobReference('loss_blob_2') in self.model.loss.field_blobs()\n\n loss_in_tuple_0 = schema.Scalar(\n dtype=np.float32, blob=core.BlobReference('loss_blob_in_tuple_0')\n )\n\n loss_in_tuple_1 = schema.Scalar(\n dtype=np.float32, blob=core.BlobReference('loss_blob_in_tuple_1')\n )\n\n loss_tuple = schema.NamedTuple(\n 'loss_in_tuple', * [loss_in_tuple_0, loss_in_tuple_1]\n )\n self.model.add_loss(loss_tuple, 'addLoss')\n assert 'addLoss_auto_2' in self.model.loss\n self.assertEqual(\n schema.Struct(\n ('loss_in_tuple_0', schema.Scalar((np.float32, tuple()))),\n ('loss_in_tuple_1', schema.Scalar((np.float32, tuple())))\n ), self.model.loss.addLoss_auto_2\n )\n assert core.BlobReference('loss_blob_in_tuple_0')\\\n in self.model.loss.field_blobs()\n assert core.BlobReference('loss_blob_in_tuple_1')\\\n in self.model.loss.field_blobs()\n\n def testFilterMetricSchema(self):\n self.model.add_metric_field(\"a:b\", schema.Scalar())\n self.model.add_metric_field(\"a:c\", schema.Scalar())\n self.model.add_metric_field(\"d\", schema.Scalar())\n\n self.assertEqual(\n self.model.metrics_schema,\n schema.Struct(\n (\"a\", schema.Struct(\n (\"b\", schema.Scalar()),\n (\"c\", schema.Scalar()),\n )),\n (\"d\", schema.Scalar()),\n ))\n\n self.model.filter_metrics_schema({\"a:b\", \"d\"})\n self.assertEqual(\n self.model.metrics_schema,\n schema.Struct(\n (\"a\", schema.Struct(\n (\"b\", schema.Scalar()),\n )),\n (\"d\", schema.Scalar()),\n ))\n\n def testAddOutputSchema(self):\n # add the first field\n self.model.add_output_schema('struct', schema.Struct())\n expected_output_schema = schema.Struct(('struct', schema.Struct()))\n self.assertEqual(\n self.model.output_schema,\n expected_output_schema,\n )\n\n # add the second field\n self.model.add_output_schema('scalar', schema.Scalar(np.float64))\n expected_output_schema = schema.Struct(\n ('struct', schema.Struct()),\n ('scalar', schema.Scalar(np.float64)),\n )\n self.assertEqual(\n self.model.output_schema,\n expected_output_schema,\n )\n\n # overwrite a field should raise\n with self.assertRaises(AssertionError):\n self.model.add_output_schema('scalar', schema.Struct())\n\n def _test_net(self, net, ops_list):\n '''\n Helper function to assert the net contains some set of operations and\n then to run the net.\n\n Inputs:\n net -- the network to test and run\n ops_list -- the list of operation specifications to check for\n in the net\n '''\n ops_output = self.assertNetContainOps(net, ops_list)\n workspace.RunNetOnce(net)\n return ops_output\n\n def testFCWithoutBias(self):\n output_dims = 2\n fc_without_bias = self.model.FCWithoutBias(\n self.model.input_feature_schema.float_features, output_dims)\n self.model.output_schema = fc_without_bias\n\n self.assertEqual(\n schema.Scalar((np.float32, (output_dims, ))),\n fc_without_bias\n )\n\n train_init_net, train_net = self.get_training_nets()\n\n init_ops = self.assertNetContainOps(\n train_init_net,\n [\n OpSpec(\"UniformFill\", None, None),\n ]\n )\n\n mat_mul_spec = OpSpec(\n \"MatMul\",\n [\n self.model.input_feature_schema.float_features(),\n init_ops[0].output[0],\n ],\n fc_without_bias.field_blobs()\n )\n\n self.assertNetContainOps(train_net, [mat_mul_spec])\n\n predict_net = self.get_predict_net()\n self.assertNetContainOps(predict_net, [mat_mul_spec])\n\n def testFCWithBootstrap(self):\n output_dims = 1\n fc_with_bootstrap = self.model.FCWithBootstrap(\n self.model.input_feature_schema.float_features,\n output_dims=output_dims,\n num_bootstrap=2,\n max_fc_size=-1\n )\n self.model.output_schema = fc_with_bootstrap\n\n\n self.assertEqual(len(fc_with_bootstrap), 4)\n\n # must be in this order\n assert (\n core.BlobReference(\"fc_with_bootstrap/bootstrap_iteration_0/indices\") == fc_with_bootstrap[0].field_blobs()[0]\n )\n assert (\n core.BlobReference(\"fc_with_bootstrap/bootstrap_iteration_0/preds\") == fc_with_bootstrap[1].field_blobs()[0]\n )\n assert (\n core.BlobReference(\"fc_with_bootstrap/bootstrap_iteration_1/indices\") == fc_with_bootstrap[2].field_blobs()[0]\n )\n assert (\n core.BlobReference(\"fc_with_bootstrap/bootstrap_iteration_1/preds\") == fc_with_bootstrap[3].field_blobs()[0]\n )\n\n train_init_net, train_net = self.get_training_nets()\n predict_net = layer_model_instantiator.generate_predict_net(self.model)\n\n train_proto = train_net.Proto()\n eval_proto = predict_net.Proto()\n\n train_ops = train_proto.op\n eval_ops = eval_proto.op\n\n master_train_ops = [\n \"Shape\",\n \"GivenTensorInt64Fill\",\n \"Gather\",\n \"GivenTensorIntFill\",\n \"GivenTensorIntFill\",\n \"Cast\",\n \"Sub\",\n \"UniformIntFill\",\n \"Gather\",\n \"FC\",\n \"UniformIntFill\",\n \"Gather\",\n \"FC\",\n ]\n\n master_eval_ops = [\n \"Shape\",\n \"GivenTensorInt64Fill\",\n \"Gather\",\n \"GivenTensorIntFill\",\n \"GivenTensorIntFill\",\n \"Cast\",\n \"Sub\",\n \"UniformIntFill\",\n \"FC\",\n \"UniformIntFill\",\n \"FC\",\n ]\n\n assert len(train_ops) == len(master_train_ops)\n assert len(eval_ops) == len(master_eval_ops)\n\n assert train_proto.external_input == eval_proto.external_input\n assert train_proto.external_output == list()\n\n # make sure all the ops are present and unchanged for train_net and eval_net\n for idx, op in enumerate(master_train_ops):\n assert train_ops[idx].type == op\n\n for idx, op in enumerate(master_eval_ops):\n assert eval_ops[idx].type == op\n\n\n def testFCwithAxis2(self):\n input_dim = 10\n output_dim = 30\n max_length = 20\n input_record = self.new_record(\n schema.Struct(\n ('history_sequence', schema.Scalar((np.float32, (max_length,\n input_dim)))),\n )\n )\n fc_out = self.model.FC(\n input_record.history_sequence, output_dim,\n axis=2)\n self.model.output_schema = fc_out\n self.assertEqual(\n schema.Scalar((np.float32, (max_length, output_dim))),\n fc_out\n )\n\n train_init_net, train_net = self.get_training_nets()\n\n def testFCTransposed(self):\n input_dim = 10\n output_dim = 30\n max_length = 20\n input_record = self.new_record(\n schema.Struct(\n ('history_sequence', schema.Scalar((np.float32, (max_length,\n input_dim)))),\n )\n )\n fc_transposed_out = self.model.FC(\n input_record.history_sequence, output_dim,\n axis=2, transposed=True)\n self.model.output_schema = fc_transposed_out\n self.assertEqual(\n schema.Scalar((np.float32, (max_length, output_dim))),\n fc_transposed_out\n )\n\n train_init_net, train_net = self.get_training_nets()\n\n def testFCTransposedWithMaxFCSize(self):\n input_dim = 10\n output_dim = 30\n max_length = 20\n input_record = self.new_record(\n schema.Struct(\n ('history_sequence', schema.Scalar((np.float32, (max_length,\n input_dim)))),\n )\n )\n fc_transposed_out = self.model.FC(\n input_record.history_sequence, output_dim,\n max_fc_size=input_dim * output_dim // 2,\n axis=2, transposed=True)\n self.model.output_schema = fc_transposed_out\n self.assertEqual(\n schema.Scalar((np.float32, (max_length, output_dim))),\n fc_transposed_out\n )\n\n train_init_net, train_net = self.get_training_nets()\n\n def testSparseLookupSumPoolingWithEviction(self):\n # Create test embedding table of 1 row\n record = schema.NewRecord(self.model.net, schema.Struct(\n ('sparse', schema.Struct(\n ('sparse_feature_0', schema.ListWithEvicted(\n schema.Scalar(np.int64,\n metadata=schema.Metadata(categorical_limit=1)),)),)),\n ))\n embedding_dim = 8\n lengths_blob = record.sparse.sparse_feature_0.lengths.get()\n values_blob = record.sparse.sparse_feature_0.items.get()\n evicted_values_blob = record.sparse.sparse_feature_0._evicted_values.get()\n lengths = np.array([1]).astype(np.int32)\n values = np.array([0]).astype(np.int64)\n # Need to reset row 0\n evicted_values = np.array([0]).astype(np.int64)\n workspace.FeedBlob(lengths_blob, lengths)\n workspace.FeedBlob(values_blob, values)\n workspace.FeedBlob(evicted_values_blob, evicted_values)\n\n embedding_after_pooling = self.model.SparseLookup(\n record.sparse.sparse_feature_0, [embedding_dim], 'Sum', weight_init=(\"ConstantFill\", {\"value\": 1.0}))\n\n self.model.output_schema = schema.Struct()\n self.assertEqual(\n schema.Scalar((np.float32, (embedding_dim, ))),\n embedding_after_pooling\n )\n train_init_net, train_net = self.get_training_nets()\n workspace.RunNetOnce(train_init_net)\n embedding_after_init = workspace.FetchBlob(\"sparse_lookup/w\")\n # Change row 0's value before reset\n new_values = np.array([[2, 2, 2, 2, 2, 2, 2, 2]]).astype(np.float32)\n workspace.FeedBlob(\"sparse_lookup/w\", new_values)\n workspace.RunNetOnce(train_net.Proto())\n embedding_after_training = workspace.FetchBlob(\"sparse_lookup/w\")\n # Verify row 0's value does not change after reset\n self.assertEquals(embedding_after_training.all(), embedding_after_init.all())\n\n\n def testSparseLookupSumPooling(self):\n record = schema.NewRecord(self.model.net, schema.Struct(\n ('sparse', schema.Struct(\n ('sparse_feature_0', schema.List(\n schema.Scalar(np.int64,\n metadata=schema.Metadata(categorical_limit=1000)))),\n )),\n ))\n embedding_dim = 64\n embedding_after_pooling = self.model.SparseLookup(\n record.sparse.sparse_feature_0, [embedding_dim], 'Sum')\n self.model.output_schema = schema.Struct()\n self.assertEqual(\n schema.Scalar((np.float32, (embedding_dim, ))),\n embedding_after_pooling\n )\n\n train_init_net, train_net = self.get_training_nets()\n\n init_ops = self.assertNetContainOps(\n train_init_net,\n [\n OpSpec(\"UniformFill\", None, None),\n OpSpec(\"ConstantFill\", None, None),\n ]\n )\n sparse_lookup_op_spec = OpSpec(\n 'SparseLengthsSum',\n [\n init_ops[0].output[0],\n record.sparse.sparse_feature_0.items(),\n record.sparse.sparse_feature_0.lengths(),\n ],\n [embedding_after_pooling()]\n )\n self.assertNetContainOps(train_net, [sparse_lookup_op_spec])\n\n predict_net = self.get_predict_net()\n self.assertNetContainOps(predict_net, [sparse_lookup_op_spec])\n\n @given(\n use_hashing=st.booleans(),\n modulo=st.integers(min_value=100, max_value=200),\n use_divide_mod=st.booleans(),\n divisor=st.integers(min_value=10, max_value=20),\n )\n def testSparseFeatureHashIdList(self, use_hashing, modulo, use_divide_mod, divisor):\n record = schema.NewRecord(\n self.model.net,\n schema.List(schema.Scalar(\n np.int64,\n metadata=schema.Metadata(categorical_limit=60000)\n ))\n )\n use_divide_mod = use_divide_mod if use_hashing is False else False\n output_schema = self.model.SparseFeatureHash(\n record,\n modulo=modulo,\n use_hashing=use_hashing,\n use_divide_mod=use_divide_mod,\n divisor=divisor,\n )\n\n self.model.output_schema = output_schema\n\n self.assertEqual(len(self.model.layers), 1)\n self.assertEqual(output_schema._items.metadata.categorical_limit,\n modulo)\n train_init_net, train_net = self.get_training_nets()\n if use_divide_mod:\n self.assertEqual(len(train_net.Proto().op), 3)\n else:\n self.assertEqual(len(train_net.Proto().op), 2)\n\n @given(\n use_hashing=st.booleans(),\n modulo=st.integers(min_value=100, max_value=200),\n )\n def testSparseFeatureHashIdScoreList(self, use_hashing, modulo):\n record = schema.NewRecord(self.model.net,\n schema.Map(schema.Scalar(np.int64,\n metadata=schema.Metadata(\n categorical_limit=60000)),\n np.float32))\n\n output_schema = self.model.SparseFeatureHash(\n record,\n modulo=modulo,\n use_hashing=use_hashing)\n\n self.model.output_schema = output_schema\n\n self.assertEqual(len(self.model.layers), 1)\n self.assertEqual(output_schema._items.keys.metadata.categorical_limit,\n modulo)\n train_init_net, train_net = self.get_training_nets()\n\n def testSparseLookupIncorrectPositionWeightedOnIdList(self):\n '''\n Currently the implementation of SparseLookup assumed input is id_score_list\n when use PositionWeighted.\n '''\n record = schema.NewRecord(self.model.net, schema.Struct(\n ('sparse', schema.Struct(\n ('sparse_feature_0', schema.List(\n schema.Scalar(np.int64,\n metadata=schema.Metadata(categorical_limit=1000)))),\n )),\n ))\n\n embedding_dim = 64\n with self.assertRaises(AssertionError):\n self.model.SparseLookup(\n record.sparse.sparse_feature_0, [embedding_dim], 'PositionWeighted')\n\n def testSparseLookupPositionWeightedOnIdList(self):\n record = schema.NewRecord(self.model.net, schema.Struct(\n ('sparse', schema.Struct(\n ('sparse_feature_0', schema.List(\n schema.Scalar(np.int64,\n metadata=schema.Metadata(categorical_limit=1000)))),\n )),\n ))\n\n # convert id_list to id_score_list with PositionWeighted layer\n sparse_segment = record.sparse.sparse_feature_0\n pos_w_layer = self.model.PositionWeighted(sparse_segment)\n\n sparse_segment = schema.Map(\n keys=get_key(sparse_segment),\n values=pos_w_layer.position_weights,\n lengths_blob=sparse_segment.lengths\n )\n\n embedding_dim = 64\n embedding_after_pooling = self.model.SparseLookup(\n sparse_segment, [embedding_dim], 'PositionWeighted')\n self.model.output_schema = schema.Struct()\n self.assertEqual(\n schema.Scalar((np.float32, (embedding_dim, ))),\n embedding_after_pooling\n )\n\n train_init_net, train_net = self.get_training_nets()\n\n self.assertNetContainOps(\n train_init_net,\n [\n OpSpec(\"ConstantFill\", None, None), # position_weights/pos_w\n OpSpec(\"UniformFill\", None, None),\n OpSpec(\"ConstantFill\", None, None),\n ]\n )\n self.assertNetContainOps(train_net, [\n OpSpec(\"LengthsRangeFill\", None, None),\n OpSpec(\"Gather\", None, None),\n OpSpec(\"SparseLengthsWeightedSum\", None, None),\n ])\n\n predict_net = self.get_predict_net()\n self.assertNetContainOps(predict_net, [\n OpSpec(\"LengthsRangeFill\", None, None),\n OpSpec(\"Gather\", None, None),\n OpSpec(\"SparseLengthsWeightedSum\", None, None),\n ])\n\n def testSparseLookupPositionWeightedOnIdScoreList(self):\n record = schema.NewRecord(self.model.net, schema.Struct(\n ('sparse', schema.Struct(\n ('id_score_list_0', schema.Map(\n schema.Scalar(\n np.int64,\n metadata=schema.Metadata(\n categorical_limit=1000\n ),\n ),\n np.float32\n )),\n )),\n ))\n\n embedding_dim = 64\n embedding_after_pooling = self.model.SparseLookup(\n record.sparse.id_score_list_0, [embedding_dim], 'PositionWeighted')\n self.model.output_schema = schema.Struct()\n self.assertEqual(\n schema.Scalar((np.float32, (embedding_dim, ))),\n embedding_after_pooling\n )\n\n train_init_net, train_net = self.get_training_nets()\n\n init_ops = self.assertNetContainOps(\n train_init_net,\n [\n OpSpec(\"UniformFill\", None, None),\n OpSpec(\"ConstantFill\", None, None),\n ]\n )\n sparse_lookup_op_spec = OpSpec(\n 'SparseLengthsWeightedSum',\n [\n init_ops[0].output[0],\n record.sparse.id_score_list_0.values(),\n record.sparse.id_score_list_0.keys(),\n record.sparse.id_score_list_0.lengths(),\n ],\n [embedding_after_pooling()]\n )\n self.assertNetContainOps(train_net, [sparse_lookup_op_spec])\n\n predict_net = self.get_predict_net()\n self.assertNetContainOps(predict_net, [sparse_lookup_op_spec])\n\n def testSparseLookupIncorrectRecencyWeightedOnIdList(self):\n '''\n Currently the implementation of SparseLookup assumed input is id_score_list\n when use RecencyWeighted.\n '''\n record = schema.NewRecord(self.model.net, schema.Struct(\n ('sparse', schema.Struct(\n ('sparse_feature_0', schema.List(\n schema.Scalar(np.int64,\n metadata=schema.Metadata(categorical_limit=1000)))),\n )),\n ))\n\n embedding_dim = 64\n with self.assertRaises(AssertionError):\n self.model.SparseLookup(\n record.sparse.sparse_feature_0, [embedding_dim], 'RecencyWeighted')\n\n def testSparseLookupRecencyWeightedOnIdScoreList(self):\n record = schema.NewRecord(self.model.net, schema.Struct(\n ('sparse', schema.Struct(\n ('id_score_list_0', schema.Map(\n schema.Scalar(\n np.int64,\n metadata=schema.Metadata(\n categorical_limit=1000\n ),\n ),\n np.float32\n )),\n )),\n ))\n\n embedding_dim = 64\n embedding_after_pooling = self.model.SparseLookup(\n record.sparse.id_score_list_0, [embedding_dim], 'RecencyWeighted')\n self.model.output_schema = schema.Struct()\n self.assertEqual(\n schema.Scalar((np.float32, (embedding_dim, ))),\n embedding_after_pooling\n )\n\n train_init_net, train_net = self.get_training_nets()\n\n init_ops = self.assertNetContainOps(\n train_init_net,\n [\n OpSpec(\"UniformFill\", None, None),\n OpSpec(\"ConstantFill\", None, None),\n ]\n )\n sparse_lookup_op_spec = OpSpec(\n 'SparseLengthsWeightedSum',\n [\n init_ops[0].output[0],\n record.sparse.id_score_list_0.values(),\n record.sparse.id_score_list_0.keys(),\n record.sparse.id_score_list_0.lengths(),\n ],\n [embedding_after_pooling()]\n )\n self.assertNetContainOps(train_net, [sparse_lookup_op_spec])\n\n predict_net = self.get_predict_net()\n self.assertNetContainOps(predict_net, [sparse_lookup_op_spec])\n\n def testPairwiseSimilarityWithAllEmbeddings(self):\n embedding_dim = 64\n N = 5\n record = schema.NewRecord(self.model.net, schema.Struct(\n ('all_embeddings', schema.Scalar(\n ((np.float32, (N, embedding_dim)))\n )),\n ))\n current = self.model.PairwiseSimilarity(\n record, N * N)\n\n self.assertEqual(\n schema.Scalar((np.float32, (N * N, ))),\n current\n )\n\n train_init_net, train_net = self.get_training_nets()\n self.assertNetContainOps(train_init_net, [])\n self.assertNetContainOps(train_net, [\n OpSpec(\"BatchMatMul\", None, None),\n OpSpec(\"Flatten\", None, None),\n ])\n\n def testPairwiseSimilarityWithXandYEmbeddings(self):\n embedding_dim = 64\n record = schema.NewRecord(self.model.net, schema.Struct(\n ('x_embeddings', schema.Scalar(\n ((np.float32, (5, embedding_dim)))\n )),\n ('y_embeddings', schema.Scalar(\n ((np.float32, (6, embedding_dim)))\n )),\n ))\n current = self.model.PairwiseSimilarity(\n record, 5 * 6)\n\n self.assertEqual(\n schema.Scalar((np.float32, (5 * 6, ))),\n current\n )\n\n train_init_net, train_net = self.get_training_nets()\n self.assertNetContainOps(train_init_net, [])\n self.assertNetContainOps(train_net, [\n OpSpec(\"BatchMatMul\", None, None),\n OpSpec(\"Flatten\", None, None),\n ])\n\n def testPairwiseSimilarityWithXandYEmbeddingsAndGather(self):\n embedding_dim = 64\n\n output_idx = [1, 3, 5]\n output_idx_blob = self.model.add_global_constant(\n str(self.model.net.NextScopedBlob('pairwise_dot_product_gather')),\n output_idx,\n dtype=np.int32,\n )\n indices_to_gather = schema.Scalar(\n (np.int32, len(output_idx)),\n output_idx_blob,\n )\n\n record = schema.NewRecord(self.model.net, schema.Struct(\n ('x_embeddings', schema.Scalar(\n ((np.float32, (5, embedding_dim)))\n )),\n ('y_embeddings', schema.Scalar(\n ((np.float32, (6, embedding_dim)))\n )),\n ('indices_to_gather', indices_to_gather),\n ))\n current = self.model.PairwiseSimilarity(\n record, len(output_idx))\n\n # This assert is not necessary,\n # output size is passed into PairwiseSimilarity\n self.assertEqual(\n schema.Scalar((np.float32, (len(output_idx), ))),\n current\n )\n\n train_init_net, train_net = self.get_training_nets()\n self.assertNetContainOps(train_init_net, [])\n self.assertNetContainOps(train_net, [\n OpSpec(\"BatchMatMul\", None, None),\n OpSpec(\"Flatten\", None, None),\n OpSpec(\"BatchGather\", None, None),\n ])\n\n def testPairwiseSimilarityIncorrectInput(self):\n embedding_dim = 64\n record = schema.NewRecord(self.model.net, schema.Struct(\n ('x_embeddings', schema.Scalar(\n ((np.float32, (5, embedding_dim)))\n )),\n ))\n with self.assertRaises(AssertionError):\n self.model.PairwiseSimilarity(\n record, 25)\n\n record = schema.NewRecord(self.model.net, schema.Struct(\n ('all_embeddings', schema.List(np.float32))\n ))\n with self.assertRaises(AssertionError):\n self.model.PairwiseSimilarity(\n record, 25)\n\n def testConcat(self):\n embedding_dim = 64\n input_record = self.new_record(schema.Struct(\n ('input1', schema.Scalar((np.float32, (embedding_dim, )))),\n ('input2', schema.Scalar((np.float32, (embedding_dim, )))),\n ('input3', schema.Scalar((np.float32, (embedding_dim, )))),\n ))\n\n output = self.model.Concat(input_record)\n self.assertEqual(\n schema.Scalar((np.float32, ((len(input_record.fields) * embedding_dim, )))),\n output\n )\n\n # Note that in Concat layer we assume first dimension is batch.\n # so input is B * embedding_dim\n # add_axis=1 make it B * 1 * embedding_dim\n # concat on axis=1 make it B * N * embedding_dim\n output = self.model.Concat(input_record, axis=1, add_axis=1)\n self.assertEqual(\n schema.Scalar((np.float32, ((len(input_record.fields), embedding_dim)))),\n output\n )\n\n def testSamplingTrain(self):\n output_dims = 1000\n\n indices = self.new_record(schema.Scalar((np.int32, (10,))))\n sampling_prob = self.new_record(schema.Scalar((np.float32, (10, ))))\n\n sampled_fc = self.model.SamplingTrain(\n schema.Struct(\n ('input', self.model.input_feature_schema.float_features),\n ('indices', indices),\n ('sampling_prob', sampling_prob),\n ),\n \"FC\",\n output_dims,\n )\n self.model.output_schema = sampled_fc\n\n # Check that we don't add prediction layer into the model\n self.assertEqual(1, len(self.model.layers))\n\n self.assertEqual(\n schema.Scalar((np.float32, (output_dims, ))),\n sampled_fc\n )\n\n train_init_net, train_net = self.get_training_nets()\n\n init_ops = self.assertNetContainOps(\n train_init_net,\n [\n OpSpec(\"UniformFill\", None, None),\n OpSpec(\"UniformFill\", None, None),\n ]\n )\n\n sampled_fc_layer = self.model.layers[0]\n\n gather_w_spec = OpSpec(\n \"Gather\",\n [\n init_ops[0].output[0],\n indices(),\n ],\n [\n sampled_fc_layer._prediction_layer.train_param_blobs[0]\n ]\n )\n gather_b_spec = OpSpec(\n \"Gather\",\n [\n init_ops[1].output[0],\n indices(),\n ],\n [\n sampled_fc_layer._prediction_layer.train_param_blobs[1]\n ]\n )\n train_fc_spec = OpSpec(\n \"FC\",\n [\n self.model.input_feature_schema.float_features(),\n ] + sampled_fc_layer._prediction_layer.train_param_blobs,\n sampled_fc.field_blobs()\n )\n log_spec = OpSpec(\"Log\", [sampling_prob()], [None])\n sub_spec = OpSpec(\n \"Sub\",\n [sampled_fc.field_blobs()[0], None],\n sampled_fc.field_blobs()\n )\n\n train_ops = self.assertNetContainOps(\n train_net,\n [gather_w_spec, gather_b_spec, train_fc_spec, log_spec, sub_spec])\n\n self.assertEqual(train_ops[3].output[0], train_ops[4].input[1])\n\n predict_net = self.get_predict_net()\n self.assertNetContainOps(\n predict_net,\n [\n OpSpec(\n \"FC\",\n [\n self.model.input_feature_schema.float_features(),\n init_ops[0].output[0],\n init_ops[1].output[0],\n ],\n sampled_fc.field_blobs()\n )\n ]\n )\n\n def testBatchLRLoss(self):\n input_record = self.new_record(schema.Struct(\n ('label', schema.Scalar((np.float64, (1,)))),\n ('logit', schema.Scalar((np.float32, (2,)))),\n ('weight', schema.Scalar((np.float64, (1,))))\n ))\n loss = self.model.BatchLRLoss(input_record)\n self.assertEqual(schema.Scalar((np.float32, tuple())), loss)\n\n def testBatchLRLossWithUncertainty(self):\n input_record = self.new_record(schema.Struct(\n ('label', schema.Scalar((np.float64, (1,)))),\n ('logit', schema.Scalar((np.float32, (2,)))),\n ('weight', schema.Scalar((np.float64, (1,)))),\n ('log_variance', schema.Scalar((np.float64, (1,)))),\n ))\n loss = self.model.BatchLRLoss(input_record)\n self.assertEqual(schema.Scalar((np.float32, tuple())), loss)\n\n def testMarginRankLoss(self):\n input_record = self.new_record(schema.Struct(\n ('pos_prediction', schema.Scalar((np.float32, (1,)))),\n ('neg_prediction', schema.List(np.float32)),\n ))\n pos_items = np.array([0.1, 0.2, 0.3], dtype=np.float32)\n neg_lengths = np.array([1, 2, 3], dtype=np.int32)\n neg_items = np.array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6], dtype=np.float32)\n schema.FeedRecord(\n input_record,\n [pos_items, neg_lengths, neg_items]\n )\n loss = self.model.MarginRankLoss(input_record)\n self.run_train_net_forward_only()\n self.assertEqual(schema.Scalar((np.float32, tuple())), loss)\n\n def testBPRLoss(self):\n input_record = self.new_record(schema.Struct(\n ('pos_prediction', schema.Scalar((np.float32, (1,)))),\n ('neg_prediction', schema.List(np.float32)),\n ))\n pos_items = np.array([0.8, 0.9], dtype=np.float32)\n neg_lengths = np.array([1, 2], dtype=np.int32)\n neg_items = np.array([0.1, 0.2, 0.3], dtype=np.float32)\n schema.FeedRecord(\n input_record,\n [pos_items, neg_lengths, neg_items]\n )\n loss = self.model.BPRLoss(input_record)\n self.run_train_net_forward_only()\n self.assertEqual(schema.Scalar((np.float32, tuple())), loss)\n result = workspace.FetchBlob('bpr_loss/output')\n np.testing.assert_array_almost_equal(np.array(1.24386, dtype=np.float32), result)\n\n def testBatchMSELoss(self):\n input_record = self.new_record(schema.Struct(\n ('label', schema.Scalar((np.float64, (1,)))),\n ('prediction', schema.Scalar((np.float32, (2,)))),\n ))\n loss = self.model.BatchMSELoss(input_record)\n self.assertEqual(schema.Scalar((np.float32, tuple())), loss)\n\n def testBatchHuberLoss(self):\n input_record = self.new_record(schema.Struct(\n ('label', schema.Scalar((np.float32, (1,)))),\n ('prediction', schema.Scalar((np.float32, (2,)))),\n ))\n loss = self.model.BatchHuberLoss(input_record)\n self.assertEqual(schema.Scalar((np.float32, tuple())), loss)\n\n def testBatchSigmoidCrossEntropyLoss(self):\n input_record = self.new_record(schema.Struct(\n ('label', schema.Scalar((np.float32, (32,)))),\n ('prediction', schema.Scalar((np.float32, (32,))))\n ))\n loss = self.model.BatchSigmoidCrossEntropyLoss(input_record)\n self.assertEqual(schema.Scalar((np.float32, tuple())), loss)\n\n def testBatchSoftmaxLoss(self):\n input_record = self.new_record(schema.Struct(\n ('label', schema.Scalar((np.float32, tuple()))),\n ('prediction', schema.Scalar((np.float32, (32,))))\n ))\n loss = self.model.BatchSoftmaxLoss(input_record)\n self.assertEqual(schema.Struct(\n ('softmax', schema.Scalar((np.float32, (32,)))),\n ('loss', schema.Scalar(np.float32)),\n ), loss)\n\n def testBatchSoftmaxLossWeight(self):\n input_record = self.new_record(schema.Struct(\n ('label', schema.Scalar((np.float32, tuple()))),\n ('prediction', schema.Scalar((np.float32, (32,)))),\n ('weight', schema.Scalar((np.float64, (1,))))\n ))\n loss = self.model.BatchSoftmaxLoss(input_record)\n self.assertEqual(schema.Struct(\n ('softmax', schema.Scalar((np.float32, (32,)))),\n ('loss', schema.Scalar(np.float32)),\n ), loss)\n\n @given(\n X=hu.arrays(dims=[2, 5]),\n )\n def testBatchNormalization(self, X):\n input_record = self.new_record(schema.Scalar((np.float32, (5,))))\n schema.FeedRecord(input_record, [X])\n bn_output = self.model.BatchNormalization(input_record)\n self.assertEqual(schema.Scalar((np.float32, (5,))), bn_output)\n self.model.output_schema = schema.Struct()\n\n train_init_net, train_net = self.get_training_nets()\n\n init_ops = self.assertNetContainOps(\n train_init_net,\n [\n OpSpec(\"ConstantFill\", None, None),\n OpSpec(\"ConstantFill\", None, None),\n OpSpec(\"ConstantFill\", None, None),\n OpSpec(\"ConstantFill\", None, None),\n ]\n )\n\n input_blob = input_record.field_blobs()[0]\n output_blob = bn_output.field_blobs()[0]\n\n expand_dims_spec = OpSpec(\n \"ExpandDims\",\n [input_blob],\n None,\n )\n\n train_bn_spec = OpSpec(\n \"SpatialBN\",\n [None, init_ops[0].output[0], init_ops[1].output[0],\n init_ops[2].output[0], init_ops[3].output[0]],\n [output_blob, init_ops[2].output[0], init_ops[3].output[0], None, None],\n {'is_test': 0, 'order': 'NCHW', 'momentum': 0.9},\n )\n\n test_bn_spec = OpSpec(\n \"SpatialBN\",\n [None, init_ops[0].output[0], init_ops[1].output[0],\n init_ops[2].output[0], init_ops[3].output[0]],\n [output_blob],\n {'is_test': 1, 'order': 'NCHW', 'momentum': 0.9},\n )\n\n squeeze_spec = OpSpec(\n \"Squeeze\",\n [output_blob],\n [output_blob],\n )\n\n self.assertNetContainOps(\n train_net,\n [expand_dims_spec, train_bn_spec, squeeze_spec]\n )\n\n eval_net = self.get_eval_net()\n\n self.assertNetContainOps(\n eval_net,\n [expand_dims_spec, test_bn_spec, squeeze_spec]\n )\n\n predict_net = self.get_predict_net()\n\n self.assertNetContainOps(\n predict_net,\n [expand_dims_spec, test_bn_spec, squeeze_spec]\n )\n\n workspace.RunNetOnce(train_init_net)\n workspace.RunNetOnce(train_net)\n\n schema.FeedRecord(input_record, [X])\n workspace.RunNetOnce(eval_net)\n\n schema.FeedRecord(input_record, [X])\n workspace.RunNetOnce(predict_net)\n\n @given(\n X=hu.arrays(dims=[2, 5, 6]),\n use_layer_norm_op=st.booleans(),\n )\n def testLayerNormalization(self, X, use_layer_norm_op):\n expect = (5, 6,)\n if not use_layer_norm_op:\n X = X.reshape(10, 6)\n expect = (6,)\n input_record = self.new_record(schema.Scalar((np.float32, expect)))\n schema.FeedRecord(input_record, [X])\n ln_output = self.model.LayerNormalization(\n input_record, use_layer_norm_op=use_layer_norm_op\n )\n self.assertEqual(schema.Scalar((np.float32, expect)), ln_output)\n self.model.output_schema = schema.Struct()\n\n train_init_net, train_net = self.get_training_nets(add_constants=True)\n workspace.RunNetOnce(train_init_net)\n workspace.RunNetOnce(train_net)\n\n @given(\n X=hu.arrays(dims=[5, 2]),\n num_to_collect=st.integers(min_value=1, max_value=10),\n )\n def testLastNWindowCollector(self, X, num_to_collect):\n input_record = self.new_record(schema.Scalar(np.float32))\n schema.FeedRecord(input_record, [X])\n last_n = self.model.LastNWindowCollector(input_record, num_to_collect)\n self.run_train_net_forward_only()\n output_record = schema.FetchRecord(last_n.last_n)\n start = max(0, 5 - num_to_collect)\n npt.assert_array_equal(X[start:], output_record())\n num_visited = schema.FetchRecord(last_n.num_visited)\n npt.assert_array_equal([5], num_visited())\n\n @given(\n X=hu.arrays(dims=[5, 2]),\n num_to_collect=st.integers(min_value=3, max_value=3),\n )\n @settings(deadline=1000)\n def testReservoirSamplingWithID(self, X, num_to_collect):\n ID = np.array([1, 2, 3, 1, 2], dtype=np.int64)\n input_record = self.new_record(\n schema.Struct(\n ('record', schema.Struct(\n ('dense', schema.Scalar()),\n )),\n ('object_id', schema.Scalar(np.int64)),\n )\n )\n schema.FeedRecord(input_record, [X, ID])\n packed_record = self.model.PackRecords(\n input_record.record, 1, fields=input_record.record.field_names())\n reservoir_input = schema.Struct(\n ('data', packed_record),\n ('object_id', input_record.object_id),\n )\n reservoir = self.model.ReservoirSampling(\n reservoir_input, num_to_collect)\n self.model.output_schema = schema.Struct()\n train_init_net, train_net = \\\n layer_model_instantiator.generate_training_nets_forward_only(\n self.model)\n workspace.RunNetOnce(train_init_net)\n workspace.CreateNet(train_net)\n workspace.RunNet(train_net.Proto().name, num_iter=2)\n num_visited = schema.FetchRecord(reservoir.num_visited)\n npt.assert_array_equal([3], num_visited())\n for param in self.model.params:\n serialized = workspace.SerializeBlob(str(param))\n workspace.DeserializeBlob(str(param), serialized)\n ID = np.array([3, 5, 3, 3, 5], dtype=np.int64)\n schema.FeedRecord(input_record.object_id, [ID])\n workspace.RunNet(train_net.Proto().name, num_iter=2)\n num_visited = schema.FetchRecord(reservoir.num_visited)\n npt.assert_array_equal([2], num_visited())\n\n def testUniformSampling(self):\n input_record = self.new_record(schema.Scalar(np.int32))\n input_array = np.array([3, 10, 11, 15, 20, 99], dtype=np.int32)\n schema.FeedRecord(input_record, [input_array])\n num_samples = 20\n num_elements = 100\n uniform_sampling_output = self.model.UniformSampling(\n input_record, num_samples, num_elements)\n self.model.loss = uniform_sampling_output\n self.run_train_net()\n samples = workspace.FetchBlob(uniform_sampling_output.samples())\n sampling_prob = workspace.FetchBlob(\n uniform_sampling_output.sampling_prob())\n self.assertEqual(num_samples, len(samples))\n np.testing.assert_array_equal(input_array, samples[:len(input_array)])\n np.testing.assert_almost_equal(\n np.array([float(num_samples) / num_elements] * num_samples,\n dtype=np.float32),\n sampling_prob\n )\n\n def testUniformSamplingWithIncorrectSampleSize(self):\n input_record = self.new_record(schema.Scalar(np.int32))\n num_samples = 200\n num_elements = 100\n with self.assertRaises(AssertionError):\n self.model.UniformSampling(input_record, num_samples, num_elements)\n\n def testGatherRecord(self):\n indices = np.array([1, 3, 4], dtype=np.int32)\n dense = np.array(list(range(20)), dtype=np.float32).reshape(10, 2)\n lengths = np.array(list(range(10)), dtype=np.int32)\n items = np.array(list(range(lengths.sum())), dtype=np.int64)\n items_lengths = np.array(list(range(lengths.sum())), dtype=np.int32)\n items_items = np.array(list(range(items_lengths.sum())), dtype=np.int64)\n record = self.new_record(schema.Struct(\n ('dense', schema.Scalar(np.float32)),\n ('sparse', schema.Struct(\n ('list', schema.List(np.int64)),\n ('list_of_list', schema.List(schema.List(np.int64))),\n )),\n ('empty_struct', schema.Struct())\n ))\n indices_record = self.new_record(schema.Scalar(np.int32))\n input_record = schema.Struct(\n ('indices', indices_record),\n ('record', record),\n )\n schema.FeedRecord(\n input_record,\n [indices, dense, lengths, items, lengths, items_lengths,\n items_items])\n gathered_record = self.model.GatherRecord(input_record)\n self.assertTrue(schema.equal_schemas(gathered_record, record))\n\n self.run_train_net_forward_only()\n gathered_dense = workspace.FetchBlob(gathered_record.dense())\n np.testing.assert_array_equal(\n np.concatenate([dense[i:i + 1] for i in indices]), gathered_dense)\n gathered_lengths = workspace.FetchBlob(\n gathered_record.sparse.list.lengths())\n np.testing.assert_array_equal(\n np.concatenate([lengths[i:i + 1] for i in indices]),\n gathered_lengths)\n gathered_items = workspace.FetchBlob(\n gathered_record.sparse.list.items())\n offsets = lengths.cumsum() - lengths\n np.testing.assert_array_equal(\n np.concatenate([\n items[offsets[i]: offsets[i] + lengths[i]]\n for i in indices\n ]), gathered_items)\n\n gathered_items_lengths = workspace.FetchBlob(\n gathered_record.sparse.list_of_list.items.lengths())\n np.testing.assert_array_equal(\n np.concatenate([\n items_lengths[offsets[i]: offsets[i] + lengths[i]]\n for i in indices\n ]),\n gathered_items_lengths\n )\n\n nested_offsets = []\n nested_lengths = []\n nested_offset = 0\n j = 0\n for l in lengths:\n nested_offsets.append(nested_offset)\n nested_length = 0\n for _i in range(l):\n nested_offset += items_lengths[j]\n nested_length += items_lengths[j]\n j += 1\n nested_lengths.append(nested_length)\n\n gathered_items_items = workspace.FetchBlob(\n gathered_record.sparse.list_of_list.items.items())\n np.testing.assert_array_equal(\n np.concatenate([\n items_items[nested_offsets[i]:\n nested_offsets[i] + nested_lengths[i]]\n for i in indices\n ]),\n gathered_items_items\n )\n\n def testMapToRange(self):\n input_record = self.new_record(schema.Scalar(np.int32))\n indices_blob = self.model.MapToRange(input_record,\n max_index=100).indices\n self.model.output_schema = schema.Struct()\n\n train_init_net, train_net = self.get_training_nets()\n\n schema.FeedRecord(\n input_record,\n [np.array([10, 3, 20, 99, 15, 11, 3, 11], dtype=np.int32)]\n )\n workspace.RunNetOnce(train_init_net)\n workspace.RunNetOnce(train_net)\n indices = workspace.FetchBlob(indices_blob())\n np.testing.assert_array_equal(\n np.array([1, 2, 3, 4, 5, 6, 2, 6], dtype=np.int32),\n indices\n )\n\n schema.FeedRecord(\n input_record,\n [np.array([10, 3, 23, 35, 60, 15, 10, 15], dtype=np.int32)]\n )\n workspace.RunNetOnce(train_net)\n indices = workspace.FetchBlob(indices_blob())\n np.testing.assert_array_equal(\n np.array([1, 2, 7, 8, 9, 5, 1, 5], dtype=np.int32),\n indices\n )\n\n eval_net = self.get_eval_net()\n\n schema.FeedRecord(\n input_record,\n [np.array([10, 3, 23, 35, 60, 15, 200], dtype=np.int32)]\n )\n workspace.RunNetOnce(eval_net)\n indices = workspace.FetchBlob(indices_blob())\n np.testing.assert_array_equal(\n np.array([1, 2, 7, 8, 9, 5, 0], dtype=np.int32),\n indices\n )\n\n schema.FeedRecord(\n input_record,\n [np.array([10, 3, 23, 15, 101, 115], dtype=np.int32)]\n )\n workspace.RunNetOnce(eval_net)\n indices = workspace.FetchBlob(indices_blob())\n np.testing.assert_array_equal(\n np.array([1, 2, 7, 5, 0, 0], dtype=np.int32),\n indices\n )\n\n predict_net = self.get_predict_net()\n\n schema.FeedRecord(\n input_record,\n [np.array([3, 3, 20, 23, 151, 35, 60, 15, 200], dtype=np.int32)]\n )\n workspace.RunNetOnce(predict_net)\n indices = workspace.FetchBlob(indices_blob())\n np.testing.assert_array_equal(\n np.array([2, 2, 3, 7, 0, 8, 9, 5, 0], dtype=np.int32),\n indices\n )\n\n def testSelectRecordByContext(self):\n float_features = self.model.input_feature_schema.float_features\n\n float_array = np.array([1.0, 2.0], dtype=np.float32)\n\n schema.FeedRecord(float_features, [float_array])\n\n with Tags(Tags.EXCLUDE_FROM_PREDICTION):\n log_float_features = self.model.Log(float_features, 1)\n joined = self.model.SelectRecordByContext(\n schema.Struct(\n (InstantiationContext.PREDICTION, float_features),\n (InstantiationContext.TRAINING, log_float_features),\n # TODO: TRAIN_ONLY layers are also generated in eval\n (InstantiationContext.EVAL, log_float_features),\n )\n )\n\n # model.output_schema has to a struct\n self.model.output_schema = schema.Struct((\n 'joined', joined\n ))\n predict_net = layer_model_instantiator.generate_predict_net(self.model)\n workspace.RunNetOnce(predict_net)\n predict_output = schema.FetchRecord(predict_net.output_record())\n npt.assert_array_equal(float_array,\n predict_output['joined']())\n eval_net = layer_model_instantiator.generate_eval_net(self.model)\n workspace.RunNetOnce(eval_net)\n eval_output = schema.FetchRecord(eval_net.output_record())\n npt.assert_array_equal(np.log(float_array),\n eval_output['joined']())\n _, train_net = (\n layer_model_instantiator.generate_training_nets_forward_only(\n self.model\n )\n )\n workspace.RunNetOnce(train_net)\n train_output = schema.FetchRecord(train_net.output_record())\n npt.assert_array_equal(np.log(float_array),\n train_output['joined']())\n\n def testFunctionalLayer(self):\n def normalize(net, in_record, out_record):\n mean = net.ReduceFrontMean(in_record(), 1)\n net.Sub(\n [in_record(), mean],\n out_record(),\n broadcast=1)\n normalized = self.model.Functional(\n self.model.input_feature_schema.float_features, 1,\n normalize, name=\"normalizer\")\n\n # Attach metadata to one of the outputs and use it in FC\n normalized.set_type((np.float32, 32))\n self.model.output_schema = self.model.FC(normalized, 2)\n\n predict_net = layer_model_instantiator.generate_predict_net(\n self.model)\n ops = predict_net.Proto().op\n assert len(ops) == 3\n assert ops[0].type == \"ReduceFrontMean\"\n assert ops[1].type == \"Sub\"\n assert ops[2].type == \"FC\"\n assert len(ops[0].input) == 1\n assert ops[0].input[0] ==\\\n self.model.input_feature_schema.float_features()\n assert len(ops[1].output) == 1\n assert ops[1].output[0] in ops[2].input\n\n def testFunctionalLayerHelper(self):\n mean = self.model.ReduceFrontMean(\n self.model.input_feature_schema.float_features, 1)\n normalized = self.model.Sub(\n schema.Tuple(\n self.model.input_feature_schema.float_features, mean),\n 1, broadcast=1)\n # Attach metadata to one of the outputs and use it in FC\n normalized.set_type((np.float32, (32,)))\n self.model.output_schema = self.model.FC(normalized, 2)\n\n predict_net = layer_model_instantiator.generate_predict_net(\n self.model)\n ops = predict_net.Proto().op\n assert len(ops) == 3\n assert ops[0].type == \"ReduceFrontMean\"\n assert ops[1].type == \"Sub\"\n assert ops[2].type == \"FC\"\n assert len(ops[0].input) == 1\n assert ops[0].input[0] ==\\\n self.model.input_feature_schema.float_features()\n assert len(ops[1].output) == 1\n assert ops[1].output[0] in ops[2].input\n\n def testFunctionalLayerHelperAutoInference(self):\n softsign = self.model.Softsign(\n schema.Tuple(self.model.input_feature_schema.float_features),\n 1)\n assert softsign.field_type().base == np.float32\n assert softsign.field_type().shape == (32,)\n self.model.output_schema = self.model.FC(softsign, 2)\n\n predict_net = layer_model_instantiator.generate_predict_net(\n self.model)\n ops = predict_net.Proto().op\n assert len(ops) == 2\n assert ops[0].type == \"Softsign\"\n assert ops[1].type == \"FC\"\n assert len(ops[0].input) == 1\n assert ops[0].input[0] ==\\\n self.model.input_feature_schema.float_features()\n assert len(ops[0].output) == 1\n assert ops[0].output[0] in ops[1].input\n\n def testHalfToFloatTypeInference(self):\n input = self.new_record(schema.Scalar((np.float32, (32,))))\n\n output = self.model.FloatToHalf(input, 1)\n assert output.field_type().base == np.float16\n assert output.field_type().shape == (32, )\n\n output = self.model.HalfToFloat(output, 1)\n assert output.field_type().base == np.float32\n assert output.field_type().shape == (32, )\n\n def testFunctionalLayerHelperAutoInferenceScalar(self):\n loss = self.model.AveragedLoss(self.model.input_feature_schema, 1)\n self.assertEqual(1, len(loss.field_types()))\n self.assertEqual(np.float32, loss.field_types()[0].base)\n self.assertEqual(tuple(), loss.field_types()[0].shape)\n\n def testFunctionalLayerInputCoercion(self):\n one = self.model.global_constants['ONE']\n two = self.model.Add([one, one], 1)\n self.model.loss = two\n self.run_train_net()\n data = workspace.FetchBlob(two.field_blobs()[0])\n np.testing.assert_array_equal([2.0], data)\n\n def testFunctionalLayerWithOutputNames(self):\n k = 3\n topk = self.model.TopK(\n self.model.input_feature_schema,\n output_names_or_num=['values', 'indices'],\n k=k,\n )\n self.assertEqual(2, len(topk.field_types()))\n self.assertEqual(np.float32, topk.field_types()[0].base)\n self.assertEqual((k,), topk.field_types()[0].shape)\n self.assertEqual(np.int32, topk.field_types()[1].base)\n self.assertEqual((k,), topk.field_types()[1].shape)\n self.assertEqual(['TopK/values', 'TopK/indices'], topk.field_blobs())\n\n def testFunctionalLayerSameOperatorOutputNames(self):\n Con1 = self.model.ConstantFill([], 1, value=1)\n Con2 = self.model.ConstantFill([], 1, value=2)\n self.assertNotEqual(str(Con1), str(Con2))\n\n def testFunctionalLayerWithOutputDtypes(self):\n loss = self.model.AveragedLoss(\n self.model.input_feature_schema,\n 1,\n output_dtypes=(np.float32, (1,)),\n )\n self.assertEqual(1, len(loss.field_types()))\n self.assertEqual(np.float32, loss.field_types()[0].base)\n self.assertEqual((1,), loss.field_types()[0].shape)\n\n def testPropagateRequestOnly(self):\n # test case when output is request only\n input_record = self.new_record(schema.Struct(\n ('input1', schema.Scalar((np.float32, (32, )))),\n ('input2', schema.Scalar((np.float32, (64, )))),\n ('input3', schema.Scalar((np.float32, (16, )))),\n ))\n\n set_request_only(input_record)\n concat_output = self.model.Concat(input_record)\n self.assertEqual(is_request_only_scalar(concat_output), True)\n\n # test case when output is not request only\n input_record2 = self.new_record(schema.Struct(\n ('input4', schema.Scalar((np.float32, (100, ))))\n )) + input_record\n\n concat_output2 = self.model.Concat(input_record2)\n self.assertEqual(is_request_only_scalar(concat_output2), False)\n\n def testSetRequestOnly(self):\n input_record = schema.Scalar(np.int64)\n schema.attach_metadata_to_scalars(\n input_record,\n schema.Metadata(\n categorical_limit=100000000,\n expected_value=99,\n feature_specs=schema.FeatureSpec(\n feature_ids=[1, 100, 1001]\n )\n )\n )\n\n set_request_only(input_record)\n self.assertEqual(input_record.metadata.categorical_limit, 100000000)\n self.assertEqual(input_record.metadata.expected_value, 99)\n self.assertEqual(\n input_record.metadata.feature_specs.feature_ids,\n [1, 100, 1001]\n )\n\n @given(\n X=hu.arrays(dims=[5, 5]), # Shape of X is irrelevant\n dropout_for_eval=st.booleans(),\n )\n def testDropout(self, X, dropout_for_eval):\n input_record = self.new_record(schema.Scalar((np.float32, (1,))))\n schema.FeedRecord(input_record, [X])\n d_output = self.model.Dropout(\n input_record,\n dropout_for_eval=dropout_for_eval\n )\n self.assertEqual(schema.Scalar((np.float32, (1,))), d_output)\n self.model.output_schema = schema.Struct()\n\n train_init_net, train_net = self.get_training_nets()\n\n input_blob = input_record.field_blobs()[0]\n output_blob = d_output.field_blobs()[0]\n\n with_d_spec = OpSpec(\n \"Dropout\",\n [input_blob],\n [output_blob, None],\n {'is_test': 0, 'ratio': 0.5}\n )\n\n without_d_spec = OpSpec(\n \"Dropout\",\n [input_blob],\n [output_blob, None],\n {'is_test': 1, 'ratio': 0.5}\n )\n\n self.assertNetContainOps(\n train_net,\n [with_d_spec]\n )\n\n eval_net = self.get_eval_net()\n predict_net = self.get_predict_net()\n\n if dropout_for_eval:\n self.assertNetContainOps(\n eval_net,\n [with_d_spec]\n )\n self.assertNetContainOps(\n predict_net,\n [with_d_spec]\n )\n else:\n self.assertNetContainOps(\n eval_net,\n [without_d_spec]\n )\n self.assertNetContainOps(\n predict_net,\n [without_d_spec]\n )\n\n workspace.RunNetOnce(train_init_net)\n workspace.RunNetOnce(train_net)\n\n schema.FeedRecord(input_record, [X])\n workspace.RunNetOnce(eval_net)\n\n schema.FeedRecord(input_record, [X])\n workspace.RunNetOnce(predict_net)\n\n @given(\n num_inputs=st.integers(1, 3),\n batch_size=st.integers(5, 10)\n )\n def testMergeIdListsLayer(self, num_inputs, batch_size):\n inputs = []\n for _ in range(num_inputs):\n lengths = np.random.randint(5, size=batch_size).astype(np.int32)\n size = lengths.sum()\n values = np.random.randint(1, 10, size=size).astype(np.int64)\n inputs.append(lengths)\n inputs.append(values)\n input_schema = schema.Tuple(\n *[schema.List(\n schema.Scalar(dtype=np.int64, metadata=schema.Metadata(\n categorical_limit=20\n ))) for _ in range(num_inputs)]\n )\n\n input_record = schema.NewRecord(self.model.net, input_schema)\n schema.FeedRecord(input_record, inputs)\n output_schema = self.model.MergeIdLists(input_record)\n assert schema.equal_schemas(\n output_schema, IdList,\n check_field_names=False)\n\n @given(\n batch_size=st.integers(min_value=2, max_value=10),\n input_dims=st.integers(min_value=5, max_value=10),\n output_dims=st.integers(min_value=5, max_value=10),\n bandwidth=st.floats(min_value=0.1, max_value=5),\n )\n def testRandomFourierFeatures(self, batch_size, input_dims, output_dims, bandwidth):\n\n def _rff_hypothesis_test(rff_output, X, W, b, scale):\n '''\n Runs hypothesis test for Semi Random Features layer.\n\n Inputs:\n rff_output -- output of net after running random fourier features layer\n X -- input data\n W -- weight parameter from train_init_net\n b -- bias parameter from train_init_net\n scale -- value by which to scale the output vector\n '''\n output = workspace.FetchBlob(rff_output)\n output_ref = scale * np.cos(np.dot(X, np.transpose(W)) + b)\n npt.assert_allclose(output, output_ref, rtol=1e-3, atol=1e-3)\n\n X = np.random.random((batch_size, input_dims)).astype(np.float32)\n scale = np.sqrt(2.0 / output_dims)\n input_record = self.new_record(schema.Scalar((np.float32, (input_dims,))))\n schema.FeedRecord(input_record, [X])\n input_blob = input_record.field_blobs()[0]\n rff_output = self.model.RandomFourierFeatures(input_record,\n output_dims,\n bandwidth)\n self.model.output_schema = schema.Struct()\n\n self.assertEqual(\n schema.Scalar((np.float32, (output_dims, ))),\n rff_output\n )\n\n train_init_net, train_net = self.get_training_nets()\n\n # Init net assertions\n init_ops_list = [\n OpSpec(\"GaussianFill\", None, None),\n OpSpec(\"UniformFill\", None, None),\n ]\n init_ops = self._test_net(train_init_net, init_ops_list)\n W = workspace.FetchBlob(self.model.layers[0].w)\n b = workspace.FetchBlob(self.model.layers[0].b)\n\n # Operation specifications\n fc_spec = OpSpec(\"FC\", [input_blob, init_ops[0].output[0],\n init_ops[1].output[0]], None)\n cosine_spec = OpSpec(\"Cos\", None, None)\n scale_spec = OpSpec(\"Scale\", None, rff_output.field_blobs(),\n {'scale': scale})\n ops_list = [\n fc_spec,\n cosine_spec,\n scale_spec\n ]\n\n # Train net assertions\n self._test_net(train_net, ops_list)\n _rff_hypothesis_test(rff_output(), X, W, b, scale)\n\n # Eval net assertions\n eval_net = self.get_eval_net()\n self._test_net(eval_net, ops_list)\n _rff_hypothesis_test(rff_output(), X, W, b, scale)\n\n # Predict net assertions\n predict_net = self.get_predict_net()\n self._test_net(predict_net, ops_list)\n _rff_hypothesis_test(rff_output(), X, W, b, scale)\n\n @given(\n batch_size=st.integers(min_value=2, max_value=10),\n input_dims=st.integers(min_value=5, max_value=10),\n output_dims=st.integers(min_value=5, max_value=10),\n s=st.integers(min_value=0, max_value=3),\n scale=st.floats(min_value=0.1, max_value=5),\n set_weight_as_global_constant=st.booleans()\n )\n def testArcCosineFeatureMap(self, batch_size, input_dims, output_dims, s, scale,\n set_weight_as_global_constant):\n\n def _arc_cosine_hypothesis_test(ac_output, X, W, b, s):\n '''\n Runs hypothesis test for Arc Cosine layer.\n\n Inputs:\n ac_output -- output of net after running arc cosine layer\n X -- input data\n W -- weight parameter from train_init_net\n b -- bias parameter from train_init_net\n s -- degree parameter\n '''\n # Get output from net\n net_output = workspace.FetchBlob(ac_output)\n\n # Computing output directly\n x_rand = np.matmul(X, np.transpose(W)) + b\n x_pow = np.power(x_rand, s)\n if s > 0:\n h_rand_features = np.piecewise(x_rand,\n [x_rand <= 0, x_rand > 0],\n [0, 1])\n else:\n h_rand_features = np.piecewise(x_rand,\n [x_rand <= 0, x_rand > 0],\n [0, lambda x: x / (1 + x)])\n output_ref = np.multiply(x_pow, h_rand_features)\n\n # Comparing net output and computed output\n npt.assert_allclose(net_output, output_ref, rtol=1e-3, atol=1e-3)\n\n X = np.random.normal(size=(batch_size, input_dims)).astype(np.float32)\n input_record = self.new_record(schema.Scalar((np.float32, (input_dims,))))\n schema.FeedRecord(input_record, [X])\n input_blob = input_record.field_blobs()[0]\n\n ac_output = self.model.ArcCosineFeatureMap(\n input_record,\n output_dims,\n s=s,\n scale=scale,\n set_weight_as_global_constant=set_weight_as_global_constant\n )\n self.model.output_schema = schema.Struct()\n self.assertEqual(\n schema.Scalar((np.float32, (output_dims, ))),\n ac_output\n )\n\n train_init_net, train_net = self.get_training_nets()\n\n # Run create_init_net to initialize the global constants, and W and b\n workspace.RunNetOnce(train_init_net)\n workspace.RunNetOnce(self.model.create_init_net(name='init_net'))\n\n if set_weight_as_global_constant:\n W = workspace.FetchBlob(\n self.model.global_constants['arc_cosine_feature_map_fixed_rand_W']\n )\n b = workspace.FetchBlob(\n self.model.global_constants['arc_cosine_feature_map_fixed_rand_b']\n )\n else:\n W = workspace.FetchBlob(self.model.layers[0].random_w)\n b = workspace.FetchBlob(self.model.layers[0].random_b)\n\n # Operation specifications\n fc_spec = OpSpec(\"FC\", [input_blob, None, None], None)\n softsign_spec = OpSpec(\"Softsign\", None, None)\n relu_spec = OpSpec(\"Relu\", None, None)\n relu_spec_output = OpSpec(\"Relu\", None, ac_output.field_blobs())\n pow_spec = OpSpec(\"Pow\", None, None, {'exponent': float(s - 1)})\n mul_spec = OpSpec(\"Mul\", None, ac_output.field_blobs())\n\n if s == 0:\n ops_list = [\n fc_spec,\n softsign_spec,\n relu_spec_output,\n ]\n elif s == 1:\n ops_list = [\n fc_spec,\n relu_spec_output,\n ]\n else:\n ops_list = [\n fc_spec,\n relu_spec,\n pow_spec,\n mul_spec,\n ]\n\n # Train net assertions\n self._test_net(train_net, ops_list)\n _arc_cosine_hypothesis_test(ac_output(), X, W, b, s)\n\n # Eval net assertions\n eval_net = self.get_eval_net()\n self._test_net(eval_net, ops_list)\n _arc_cosine_hypothesis_test(ac_output(), X, W, b, s)\n\n # Predict net assertions\n predict_net = self.get_predict_net()\n self._test_net(predict_net, ops_list)\n _arc_cosine_hypothesis_test(ac_output(), X, W, b, s)\n\n @given(\n batch_size=st.integers(min_value=2, max_value=10),\n input_dims=st.integers(min_value=5, max_value=10),\n output_dims=st.integers(min_value=5, max_value=10),\n s=st.integers(min_value=0, max_value=3),\n scale=st.floats(min_value=0.1, max_value=5),\n set_weight_as_global_constant=st.booleans(),\n use_struct_input=st.booleans(),\n )\n def testSemiRandomFeatures(self, batch_size, input_dims, output_dims, s, scale,\n set_weight_as_global_constant, use_struct_input):\n\n def _semi_random_hypothesis_test(srf_output, X_full, X_random, rand_w,\n rand_b, s):\n '''\n Runs hypothesis test for Semi Random Features layer.\n\n Inputs:\n srf_output -- output of net after running semi random features layer\n X_full -- full input data\n X_random -- random-output input data\n rand_w -- random-initialized weight parameter from train_init_net\n rand_b -- random-initialized bias parameter from train_init_net\n s -- degree parameter\n\n '''\n # Get output from net\n net_output = workspace.FetchBlob(srf_output)\n\n # Fetch learned parameter blobs\n learned_w = workspace.FetchBlob(self.model.layers[0].learned_w)\n learned_b = workspace.FetchBlob(self.model.layers[0].learned_b)\n\n # Computing output directly\n x_rand = np.matmul(X_random, np.transpose(rand_w)) + rand_b\n x_learn = np.matmul(X_full, np.transpose(learned_w)) + learned_b\n x_pow = np.power(x_rand, s)\n if s > 0:\n h_rand_features = np.piecewise(x_rand,\n [x_rand <= 0, x_rand > 0],\n [0, 1])\n else:\n h_rand_features = np.piecewise(x_rand,\n [x_rand <= 0, x_rand > 0],\n [0, lambda x: x / (1 + x)])\n output_ref = np.multiply(np.multiply(x_pow, h_rand_features), x_learn)\n\n # Comparing net output and computed output\n npt.assert_allclose(net_output, output_ref, rtol=1e-3, atol=1e-3)\n\n X_full = np.random.normal(size=(batch_size, input_dims)).astype(np.float32)\n if use_struct_input:\n X_random = np.random.normal(size=(batch_size, input_dims)).\\\n astype(np.float32)\n input_data = [X_full, X_random]\n input_record = self.new_record(schema.Struct(\n ('full', schema.Scalar(\n (np.float32, (input_dims,))\n )),\n ('random', schema.Scalar(\n (np.float32, (input_dims,))\n ))\n ))\n else:\n X_random = X_full\n input_data = [X_full]\n input_record = self.new_record(schema.Scalar(\n (np.float32, (input_dims,))\n ))\n\n schema.FeedRecord(input_record, input_data)\n srf_output = self.model.SemiRandomFeatures(\n input_record,\n output_dims,\n s=s,\n scale_random=scale,\n scale_learned=scale,\n set_weight_as_global_constant=set_weight_as_global_constant\n )\n\n self.model.output_schema = schema.Struct()\n\n self.assertEqual(\n schema.Struct(\n ('full', schema.Scalar(\n (np.float32, (output_dims,))\n )),\n ('random', schema.Scalar(\n (np.float32, (output_dims,))\n ))\n ),\n srf_output\n )\n\n init_ops_list = [\n OpSpec(\"GaussianFill\", None, None),\n OpSpec(\"UniformFill\", None, None),\n OpSpec(\"GaussianFill\", None, None),\n OpSpec(\"UniformFill\", None, None),\n ]\n train_init_net, train_net = self.get_training_nets()\n\n # Need to run to initialize the global constants for layer\n workspace.RunNetOnce(self.model.create_init_net(name='init_net'))\n\n if set_weight_as_global_constant:\n # If weight params are global constants, they won't be in train_init_net\n init_ops = self._test_net(train_init_net, init_ops_list[:2])\n rand_w = workspace.FetchBlob(\n self.model.global_constants['semi_random_features_fixed_rand_W']\n )\n rand_b = workspace.FetchBlob(\n self.model.global_constants['semi_random_features_fixed_rand_b']\n )\n\n # Operation specifications\n fc_random_spec = OpSpec(\"FC\", [None, None, None], None)\n fc_learned_spec = OpSpec(\"FC\", [None, init_ops[0].output[0],\n init_ops[1].output[0]], None)\n else:\n init_ops = self._test_net(train_init_net, init_ops_list)\n rand_w = workspace.FetchBlob(self.model.layers[0].random_w)\n rand_b = workspace.FetchBlob(self.model.layers[0].random_b)\n\n # Operation specifications\n fc_random_spec = OpSpec(\"FC\", [None, init_ops[0].output[0],\n init_ops[1].output[0]], None)\n fc_learned_spec = OpSpec(\"FC\", [None, init_ops[2].output[0],\n init_ops[3].output[0]], None)\n\n softsign_spec = OpSpec(\"Softsign\", None, None)\n relu_spec = OpSpec(\"Relu\", None, None)\n relu_output_spec = OpSpec(\"Relu\", None, srf_output.random.field_blobs())\n pow_spec = OpSpec(\"Pow\", None, None, {'exponent': float(s - 1)})\n mul_interim_spec = OpSpec(\"Mul\", None, srf_output.random.field_blobs())\n mul_spec = OpSpec(\"Mul\", None, srf_output.full.field_blobs())\n\n if s == 0:\n ops_list = [\n fc_learned_spec,\n fc_random_spec,\n softsign_spec,\n relu_output_spec,\n mul_spec,\n ]\n elif s == 1:\n ops_list = [\n fc_learned_spec,\n fc_random_spec,\n relu_output_spec,\n mul_spec,\n ]\n else:\n ops_list = [\n fc_learned_spec,\n fc_random_spec,\n relu_spec,\n pow_spec,\n mul_interim_spec,\n mul_spec,\n ]\n\n # Train net assertions\n self._test_net(train_net, ops_list)\n _semi_random_hypothesis_test(srf_output.full(), X_full, X_random,\n rand_w, rand_b, s)\n\n # Eval net assertions\n eval_net = self.get_eval_net()\n self._test_net(eval_net, ops_list)\n _semi_random_hypothesis_test(srf_output.full(), X_full, X_random,\n rand_w, rand_b, s)\n\n # Predict net assertions\n predict_net = self.get_predict_net()\n self._test_net(predict_net, ops_list)\n _semi_random_hypothesis_test(srf_output.full(), X_full, X_random,\n rand_w, rand_b, s)\n\n def testConv(self):\n batch_size = 50\n H = 1\n W = 10\n C = 50\n output_dims = 32\n kernel_h = 1\n kernel_w = 3\n stride_h = 1\n stride_w = 1\n pad_t = 0\n pad_b = 0\n pad_r = None\n pad_l = None\n\n input_record = self.new_record(schema.Scalar((np.float32, (H, W, C))))\n X = np.random.random((batch_size, H, W, C)).astype(np.float32)\n schema.FeedRecord(input_record, [X])\n conv = self.model.Conv(\n input_record,\n output_dims,\n kernel_h=kernel_h,\n kernel_w=kernel_w,\n stride_h=stride_h,\n stride_w=stride_w,\n pad_t=pad_t,\n pad_b=pad_b,\n pad_r=pad_r,\n pad_l=pad_l,\n order='NHWC'\n )\n\n self.assertEqual(\n schema.Scalar((np.float32, (output_dims,))),\n conv\n )\n\n self.run_train_net_forward_only()\n output_record = schema.FetchRecord(conv)\n # check the number of output channels is the same as input in this example\n assert output_record.field_types()[0].shape == (H, W, output_dims)\n assert output_record().shape == (batch_size, H, W, output_dims)\n\n train_init_net, train_net = self.get_training_nets()\n # Init net assertions\n init_ops = self.assertNetContainOps(\n train_init_net,\n [\n OpSpec(\"XavierFill\", None, None),\n OpSpec(\"ConstantFill\", None, None),\n ]\n )\n conv_spec = OpSpec(\n \"Conv\",\n [\n input_record.field_blobs()[0],\n init_ops[0].output[0],\n init_ops[1].output[0],\n ],\n conv.field_blobs()\n )\n\n # Train net assertions\n self.assertNetContainOps(train_net, [conv_spec])\n\n # Predict net assertions\n predict_net = self.get_predict_net()\n self.assertNetContainOps(predict_net, [conv_spec])\n\n # Eval net assertions\n eval_net = self.get_eval_net()\n self.assertNetContainOps(eval_net, [conv_spec])\n\n @given(\n num=st.integers(min_value=10, max_value=100),\n feed_weight=st.booleans(),\n use_inv_var_parameterization=st.booleans(),\n use_log_barrier=st.booleans(),\n enable_diagnose=st.booleans(),\n **hu.gcs\n )\n @settings(deadline=1000)\n def testAdaptiveWeight(\n self, num, feed_weight, use_inv_var_parameterization, use_log_barrier,\n enable_diagnose, gc, dc\n ):\n input_record = self.new_record(schema.RawTuple(num))\n data = np.random.random(num)\n schema.FeedRecord(\n input_record, [np.array(x).astype(np.float32) for x in data]\n )\n weights = np.random.random(num) if feed_weight else None\n result = self.model.AdaptiveWeight(\n input_record,\n weights=weights,\n estimation_method=(\n 'inv_var' if use_inv_var_parameterization else 'log_std'\n ),\n pos_optim_method=(\n 'log_barrier' if use_log_barrier else 'pos_grad_proj'\n ),\n enable_diagnose=enable_diagnose\n )\n train_init_net, train_net = self.get_training_nets(True)\n workspace.RunNetOnce(train_init_net)\n workspace.RunNetOnce(train_net)\n result = workspace.FetchBlob(result())\n if not feed_weight:\n weights = np.array([1. / num for _ in range(num)])\n expected = np.sum(weights * data + 0.5 * np.log(1. / 2. / weights))\n npt.assert_allclose(expected, result, atol=1e-4, rtol=1e-4)\n if enable_diagnose:\n assert len(self.model.ad_hoc_plot_blobs) == num\n reconst_weights_from_ad_hoc = np.array(\n [workspace.FetchBlob(b) for b in self.model.ad_hoc_plot_blobs]\n ).flatten()\n npt.assert_allclose(\n reconst_weights_from_ad_hoc, weights, atol=1e-4, rtol=1e-4\n )\n else:\n assert len(self.model.ad_hoc_plot_blobs) == 0\n\n @given(num=st.integers(min_value=10, max_value=100), **hu.gcs)\n def testConstantWeight(self, num, gc, dc):\n input_record = self.new_record(schema.RawTuple(num))\n data = np.random.random(num)\n schema.FeedRecord(\n input_record, [np.array(x).astype(np.float32) for x in data]\n )\n weights = np.random.random(num)\n result = self.model.ConstantWeight(input_record, weights=weights)\n train_init_net, train_net = self.get_training_nets(True)\n workspace.RunNetOnce(train_init_net)\n workspace.RunNetOnce(train_net)\n result = workspace.FetchBlob(result())\n expected = np.sum(weights * data)\n npt.assert_allclose(expected, result, atol=1e-4, rtol=1e-4)\n\n @given(**hu.gcs)\n @settings(deadline=10000)\n def testHomotopyWeight(self, gc, dc):\n input_record = self.new_record(schema.RawTuple(2))\n data = np.random.random(2)\n schema.FeedRecord(\n input_record, [np.array(x).astype(np.float32) for x in data]\n )\n # ensure: quad_life > 2 * half_life\n half_life = int(np.random.random() * 1e2 + 1)\n quad_life = int(np.random.random() * 1e3 + 2 * half_life + 1)\n min_weight = np.random.random()\n max_weight = np.random.random() + min_weight + 1e-5\n result = self.model.HomotopyWeight(\n input_record,\n min_weight=min_weight,\n max_weight=max_weight,\n half_life=half_life,\n quad_life=quad_life,\n )\n train_init_net, train_net = self.get_training_nets(True)\n workspace.RunNetOnce(train_init_net)\n workspace.CreateNet(train_net)\n workspace.RunNet(train_net.Name(), num_iter=half_life)\n half_life_result = workspace.FetchBlob(result())\n workspace.RunNet(train_net.Name(), num_iter=quad_life - half_life)\n quad_life_result = workspace.FetchBlob(result())\n\n alpha = (min_weight + max_weight) / 2.\n beta = (min_weight + max_weight) / 2.\n expected_half_life_result = alpha * data[0] + beta * data[1]\n alpha = (3 * min_weight + max_weight) / 4.\n beta = (min_weight + 3 * max_weight) / 4.\n expected_quad_life_result = alpha * data[0] + beta * data[1]\n npt.assert_allclose(\n expected_half_life_result, half_life_result, atol=1e-2, rtol=1e-2\n )\n npt.assert_allclose(\n expected_quad_life_result, quad_life_result, atol=1e-2, rtol=1e-2\n )\n\n def _testLabelSmooth(self, categories, binary_prob_label, bsz):\n label = self.new_record(schema.Scalar((np.float32, (1, ))))\n label_np = np.random.randint(categories, size=bsz).astype(np.float32)\n schema.FeedRecord(label, [label_np])\n smooth_matrix_shape = (\n 2 if binary_prob_label else (categories, categories)\n )\n smooth_matrix = np.random.random(smooth_matrix_shape)\n smoothed_label = self.model.LabelSmooth(label, smooth_matrix)\n train_init_net, train_net = self.get_training_nets(True)\n workspace.RunNetOnce(train_init_net)\n workspace.RunNetOnce(train_net)\n smoothed_label_np = workspace.FetchBlob(smoothed_label())\n if binary_prob_label:\n expected = np.array(\n [\n smooth_matrix[0] if x == 0.0 else smooth_matrix[1]\n for x in label_np\n ]\n )\n else:\n expected = np.array([smooth_matrix[int(x)] for x in label_np])\n npt.assert_allclose(expected, smoothed_label_np, atol=1e-4, rtol=1e-4)\n\n @given(\n categories=st.integers(min_value=2, max_value=10),\n bsz=st.integers(min_value=10, max_value=100),\n **hu.gcs\n )\n def testLabelSmoothForCategoricalLabel(self, categories, bsz, gc, dc):\n self._testLabelSmooth(categories, False, bsz)\n\n @given(\n bsz=st.integers(min_value=10, max_value=100),\n **hu.gcs\n )\n def testLabelSmoothForBinaryProbLabel(self, bsz, gc, dc):\n self._testLabelSmooth(2, True, bsz)\n\n @given(\n num_inputs=st.integers(min_value=2, max_value=10),\n batch_size=st.integers(min_value=2, max_value=10),\n input_dim=st.integers(min_value=5, max_value=10),\n seed=st.integers(1, 10),\n )\n def testBlobWeightedSum(self, num_inputs, batch_size, input_dim, seed):\n\n def get_blob_weighted_sum():\n weights = []\n for i in range(num_inputs):\n w_blob_name = 'blob_weighted_sum/w_{0}'.format(i)\n assert workspace.HasBlob(w_blob_name), (\n \"cannot fine blob {}\".format(w_blob_name)\n )\n w = workspace.FetchBlob(w_blob_name)\n weights.append(w)\n\n result = np.sum([\n input_data[idx] * weights[idx] for idx in range(num_inputs)\n ], axis=0)\n return result\n\n np.random.seed(seed)\n expected_output_schema = schema.Scalar((np.float32, (input_dim,)))\n input_schema = schema.Tuple(\n *[expected_output_schema for _ in range(num_inputs)]\n )\n input_data = [\n np.random.random((batch_size, input_dim)).astype(np.float32)\n for _ in range(num_inputs)\n ]\n input_record = self.new_record(input_schema)\n schema.FeedRecord(input_record, input_data)\n\n # test output schema\n ws_output = self.model.BlobWeightedSum(input_record)\n self.assertEqual(len(self.model.layers), 1)\n assert schema.equal_schemas(ws_output, expected_output_schema)\n\n # test train net\n train_init_net, train_net = self.get_training_nets()\n workspace.RunNetOnce(train_init_net)\n workspace.RunNetOnce(train_net)\n output = workspace.FetchBlob(ws_output())\n npt.assert_almost_equal(get_blob_weighted_sum(), output, decimal=5)\n\n self.run_train_net_forward_only()\n output = workspace.FetchBlob(ws_output())\n npt.assert_almost_equal(get_blob_weighted_sum(), output, decimal=5)\n\n # test eval net\n eval_net = self.get_eval_net()\n workspace.RunNetOnce(eval_net)\n output = workspace.FetchBlob(ws_output())\n npt.assert_almost_equal(get_blob_weighted_sum(), output, decimal=5)\n\n # test pred net\n pred_net = self.get_predict_net()\n workspace.RunNetOnce(pred_net)\n output = workspace.FetchBlob(ws_output())\n npt.assert_almost_equal(get_blob_weighted_sum(), output, decimal=5)\n\n def testFeatureSparseToDenseGetAccessedFeatures(self):\n float_features_column = \"float_features\"\n float_features_type = \"FLOAT\"\n float_features_ids = [1, 2, 3]\n\n id_list_features_column = \"id_list_features\"\n id_list_features_type = \"ID_LIST\"\n id_list_features_ids = [4, 5, 6]\n\n id_score_list_features_column = \"id_score_list_features\"\n id_score_list_features_type = \"ID_SCORE_LIST\"\n id_score_list_features_ids = [7, 8 , 9]\n\n feature_names = [\"a\", \"b\", \"c\"]\n\n input_record = self.new_record(schema.Struct(\n (float_features_column, schema.Map(np.int32, np.float32)),\n (id_list_features_column,\n schema.Map(np.int32, schema.List(np.int64))),\n (id_score_list_features_column,\n schema.Map(np.int32, schema.Map(np.int64, np.float32))),\n ))\n\n input_specs = [\n (\n float_features_column,\n schema.FeatureSpec(\n feature_type=float_features_type,\n feature_ids=float_features_ids,\n feature_names=feature_names,\n ),\n ),\n (\n id_list_features_column,\n schema.FeatureSpec(\n feature_type=id_list_features_type,\n feature_ids=id_list_features_ids,\n feature_names=feature_names,\n ),\n ),\n (\n id_score_list_features_column,\n schema.FeatureSpec(\n feature_type=id_score_list_features_type,\n feature_ids=id_score_list_features_ids,\n feature_names=feature_names,\n ),\n ),\n ]\n\n self.model.FeatureSparseToDense(input_record, input_specs)\n\n expected_accessed_features = {\n float_features_column: [\n AccessedFeatures(float_features_type, set(float_features_ids))],\n id_list_features_column: [\n AccessedFeatures(id_list_features_type, set(id_list_features_ids))],\n id_score_list_features_column: [\n AccessedFeatures(id_score_list_features_type, set(id_score_list_features_ids))],\n }\n\n self.assertEqual(len(self.model.layers), 1)\n self.assertEqual(\n self.model.layers[0].get_accessed_features(),\n expected_accessed_features\n )\n\n def test_get_key(self):\n def _is_id_list(input_record):\n return almost_equal_schemas(input_record, IdList)\n\n\n def _is_id_score_list(input_record):\n return almost_equal_schemas(input_record,\n IdScoreList,\n check_field_types=False)\n\n def old_get_sparse_key_logic(input_record):\n if _is_id_list(input_record):\n sparse_key = input_record.items()\n elif _is_id_score_list(input_record):\n sparse_key = input_record.keys()\n else:\n raise NotImplementedError()\n return sparse_key\n\n id_score_list_record = schema.NewRecord(\n self.model.net,\n schema.Map(\n schema.Scalar(\n np.int64,\n metadata=schema.Metadata(\n categorical_limit=1000\n ),\n ),\n np.float32\n )\n )\n\n self.assertEqual(\n get_key(id_score_list_record)(),\n old_get_sparse_key_logic(id_score_list_record)\n )\n\n id_list_record = schema.NewRecord(\n self.model.net,\n schema.List(\n schema.Scalar(\n np.int64,\n metadata=schema.Metadata(categorical_limit=1000)\n )\n )\n )\n\n self.assertEqual(\n get_key(id_list_record)(),\n old_get_sparse_key_logic(id_list_record)\n )\n\n def testSparseLookupWithAttentionWeightOnIdScoreList(self):\n record = schema.NewRecord(\n self.model.net,\n schema.Map(\n schema.Scalar(\n np.int64,\n metadata=schema.Metadata(categorical_limit=1000),\n ),\n np.float32,\n ),\n )\n embedding_dim = 64\n embedding_after_pooling = self.model.SparseLookup(\n record, [embedding_dim], \"Sum\", use_external_weights=True\n )\n self.model.output_schema = schema.Struct()\n self.assertEqual(\n schema.Scalar((np.float32, (embedding_dim,))), embedding_after_pooling\n )\n\n train_init_net, train_net = self.get_training_nets()\n\n init_ops = self.assertNetContainOps(\n train_init_net,\n [OpSpec(\"UniformFill\", None, None), OpSpec(\"ConstantFill\", None, None)],\n )\n sparse_lookup_op_spec = OpSpec(\n \"SparseLengthsWeightedSum\",\n [\n init_ops[0].output[0],\n record.values(),\n record.keys(),\n record.lengths(),\n ],\n [embedding_after_pooling()],\n )\n self.assertNetContainOps(train_net, [sparse_lookup_op_spec])\n\n predict_net = self.get_predict_net()\n self.assertNetContainOps(predict_net, [sparse_lookup_op_spec])\n\n def testSparseItemwiseDropoutWithReplacement(self):\n input_record = schema.NewRecord(self.model.net, IdList)\n self.model.output_schema = schema.Struct()\n\n lengths_blob = input_record.field_blobs()[0]\n values_blob = input_record.field_blobs()[1]\n lengths = np.array([1] * 10).astype(np.int32)\n values = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]).astype(np.int64)\n workspace.FeedBlob(lengths_blob, lengths)\n workspace.FeedBlob(values_blob, values)\n\n out = self.model.SparseItemwiseDropoutWithReplacement(\n input_record, 0.0, 0.5, 1.0, -1, output_names_or_num=1)\n self.assertEqual(schema.List(schema.Scalar(np.int64,)), out)\n\n train_init_net, train_net = self.get_training_nets()\n eval_net = self.get_eval_net()\n predict_net = self.get_predict_net()\n\n workspace.RunNetOnce(train_init_net)\n workspace.RunNetOnce(train_net)\n out_values = workspace.FetchBlob(out.items())\n out_lengths = workspace.FetchBlob(out.lengths())\n self.assertBlobsEqual(out_values, values)\n self.assertBlobsEqual(out_lengths, lengths)\n\n workspace.RunNetOnce(eval_net)\n\n workspace.RunNetOnce(predict_net)\n predict_values = workspace.FetchBlob(\"values_auto_0\")\n predict_lengths = workspace.FetchBlob(\"lengths_auto_0\")\n self.assertBlobsEqual(predict_values, np.array([-1] * 10).astype(np.int64))\n self.assertBlobsEqual(predict_lengths, lengths)\n",
"from setuptools import setup\nfrom torch.utils.cpp_extension import CppExtension, BuildExtension\n\nsetup(name='benchmark_cpp_extension',\n ext_modules=[CppExtension('benchmark_cpp_extension', ['extension.cpp'])],\n cmdclass={'build_ext': BuildExtension})\n",
"r'''\n**This file is EXPERIMENTAL and is mostly used for testing purposes! Do not\nrely on it for anything!**\n'''\nfrom torch.fx import Graph, GraphModule\nfrom torch.fx.graph import map_arg\nfrom torch.fx.proxy import Proxy\nimport sys\nimport torch\nfrom torch.nn.utils import fuse_conv_bn_weights\nimport operator\n\n# can be a\n# module type, a builtin function, or a string to match target\n\ndef _minmax_scale_zeropoint(min_val, max_val, qmin=-127, qmax=128, eps=torch.finfo(torch.float32).eps):\n min_val = min(0.0, min_val)\n max_val = max(0.0, max_val)\n if max_val == min_val:\n return 1.0, 0\n else:\n scale = (max_val - min_val) / float(qmax - qmin)\n scale = max(scale, eps)\n zero_point = qmin - round(min_val / scale)\n zero_point = max(qmin, zero_point)\n zero_point = min(qmax, zero_point)\n zero_point = int(zero_point)\n return scale, zero_point\n\nclass MinMaxObserver:\n def __init__(self, quantizer, node):\n self.min, self.max = float('inf'), float('-inf')\n self.all_tensors = True\n\n def observe(self, node, env):\n v = env[node.name]\n if not isinstance(v, torch.Tensor):\n self.all_tensors = False\n return\n self.max = max(self.max, float(v.max()))\n self.min = min(self.min, float(v.min()))\n\n def scale_zeropoint(self):\n return _minmax_scale_zeropoint(self.min, self.max, qmin=0, qmax=255)\n\nclass NoObserver:\n def __init__(self, quantizer, node):\n pass\n\n def observe(self, node, env):\n pass\n\nDEFAULT_QUANTIZATION_PATTERNS = {}\ndef register_pattern(pattern):\n def insert(fn):\n DEFAULT_QUANTIZATION_PATTERNS[pattern] = fn\n return fn\n return insert\n\n\n@register_pattern(operator.add)\nclass Add(MinMaxObserver):\n def quantize(self, quantizer, node, load_arg):\n if not self.all_tensors:\n return NotImplemented\n scale, zeropoint = self.scale_zeropoint()\n return quantizer.quantized_graph.create_node(\n 'call_function', torch.ops.quantized.add, load_arg(node.args), {'scale': scale, 'zero_point': zeropoint})\n\n\nclass Relu(NoObserver):\n def quantize(self, quantizer, node, load_arg):\n return torch.relu(load_arg(node.args[0])) # torch.relu works directly on quantized tensors?\n\n# these ops have quantized equivalents that do not need any extra information\n@register_pattern(torch.nn.ReLU)\n@register_pattern(torch.nn.AvgPool2d)\n@register_pattern(torch.nn.MaxPool2d)\n@register_pattern(torch.nn.AdaptiveAvgPool2d)\nclass CopyNode(NoObserver):\n def quantize(self, quantizer, node, load_arg):\n return quantizer.quantized_graph.node_copy(node, load_arg)\n\nclass IdentityModule(torch.nn.Module):\n def forward(self, x):\n return x\n\n# handle conv, maybe followed by bn, maybe followed by relu\n@register_pattern(torch.nn.modules.conv.Conv2d)\n@register_pattern((torch.nn.ReLU, torch.nn.modules.conv.Conv2d))\n@register_pattern((torch.nn.modules.batchnorm.BatchNorm2d, torch.nn.modules.conv.Conv2d))\n@register_pattern((torch.nn.ReLU, (torch.nn.modules.batchnorm.BatchNorm2d, torch.nn.modules.conv.Conv2d)))\nclass ConvNormRelu(MinMaxObserver):\n def __init__(self, quantizer, node):\n super().__init__(quantizer, node)\n self.relu_node, self.bn_node = None, None\n if isinstance(quantizer.modules[node.target], torch.nn.ReLU):\n self.relu_node = node\n node = node.args[0]\n if isinstance(quantizer.modules[node.target], torch.nn.BatchNorm2d):\n self.bn_node = node\n self.bn = quantizer.modules[self.bn_node.target]\n node = node.args[0]\n assert isinstance(quantizer.modules[node.target], torch.nn.modules.Conv2d)\n self.conv_node = node\n self.conv = quantizer.modules[self.conv_node.target]\n\n def quantize(self, quantizer, node, load_arg):\n mod = self.conv\n weight, bias = mod.weight, mod.bias\n\n if self.bn_node is not None:\n weight, bias = fuse_conv_bn_weights(\n weight, bias, self.bn.running_mean, self.bn.running_var,\n self.bn.eps, self.bn.weight, self.bn.bias)\n\n min_val, max_val = float(weight.min()), float(weight.max())\n\n act_scale, act_zp = self.scale_zeropoint()\n\n weight_scale, weight_zp = _minmax_scale_zeropoint(min_val, max_val)\n qweight = torch.quantize_per_tensor(weight, weight_scale, weight_zp, torch.qint8)\n\n ctor = torch.nn.intrinsic.quantized.ConvReLU2d if self.relu_node is not None else torch.nn.quantized.Conv2d\n\n qconv = ctor(mod.in_channels, mod.out_channels, mod.kernel_size,\n mod.stride, mod.padding, mod.dilation, mod.groups,\n mod.bias is not None, mod.padding_mode)\n\n qconv.set_weight_bias(qweight, bias)\n qconv.scale = float(act_scale)\n qconv.zero_point = int(act_zp)\n parent_name, name = _parent_name(self.conv_node.target)\n setattr(quantizer.modules[parent_name], name, qconv)\n if self.bn_node is not None:\n parent_bn, bn_name = _parent_name(self.bn_node.target)\n # we can't just delete this because submodules's forwards (which are not longer use)\n # try to call it, so replace with something that does nothing.\n setattr(quantizer.modules[parent_name], bn_name, IdentityModule())\n\n return quantizer.quantized_graph.create_node('call_module', self.conv_node.target, (load_arg(self.conv_node.args[0]),), {})\n\n\n# turn foo.bar -> ['foo', 'bar']\ndef _parent_name(target):\n r = target.rsplit('.', 1)\n if len(r) == 1:\n return '', r[0]\n else:\n return r[0], r[1]\n\n\n\nclass DefaultQuant(MinMaxObserver):\n def quantize(self, input):\n assert self.all_tensors\n scale, zeropoint = self.scale_zeropoint()\n return torch.quantize_per_tensor(Proxy(input), scale, zeropoint, torch.quint8).node\n\ndef matches(modules, node, pattern, max_uses=sys.maxsize):\n if isinstance(pattern, tuple):\n self_match, *arg_matches = pattern\n else:\n self_match = pattern\n arg_matches = None\n\n if len(node.users) > max_uses:\n return False\n\n if isinstance(self_match, type) and issubclass(self_match, torch.nn.Module):\n if node.op != 'call_module':\n return False\n if not isinstance(modules[node.target], self_match):\n return False\n elif callable(self_match):\n if node.op != 'call_function' or node.target is not self_match:\n return False\n elif node.target != self_match:\n return False\n\n if not arg_matches:\n return True\n\n if len(arg_matches) != len(node.args):\n return False\n\n return all(matches(modules, node, arg_match, max_uses=1) for node, arg_match in zip(node.args, arg_matches))\n\n\nclass Quantizer:\n def __init__(self, mod, patterns=DEFAULT_QUANTIZATION_PATTERNS, quant_ctor=DefaultQuant):\n self.root = mod\n self.graph = mod.graph\n self.quant_ctor = quant_ctor\n\n # cached information for observe\n self.state_dict = self.root.state_dict()\n self.modules = dict(self.root.named_modules())\n\n # match the patterns that will get quantized\n self.matches = self._find_matches(patterns)\n # find _inputs_ to matched nodes that are not quantized, these\n # have to be quantized, which requires measuring stats,\n # initialize an quant_ctor object for each\n self.quants = self._find_quants(quant_ctor)\n\n\n\n def observe(self, args):\n # most of this function is just an interpreter for the graph\n # it would be possible to put this in some abstraction, but\n # it is pretty nice to just be able to see exactly what is happening here\n # and hack on it.\n # maybe we should just provide an example interpreter that people copy/paste\n # then edit.\n args_iter = iter(args)\n env = {}\n\n def load_arg(a):\n return map_arg(a, lambda node: env[node.name])\n\n output_node : Optional[Node] = None\n for node in self.graph.nodes:\n if node.op == 'placeholder':\n result = next(args_iter)\n elif node.op == 'get_attr':\n result = self.state_dict[node.target]\n elif node.op == 'call_function':\n result = node.target(*load_arg(node.args), **load_arg(node.kwargs))\n elif node.op == 'call_method':\n self_obj, *args = load_arg(node.args)\n kwargs = load_arg(node.kwargs)\n result = getattr(self_obj, node.target)(*args, **kwargs)\n elif node.op == 'call_module':\n result = self.modules[node.target](*load_arg(node.args), **load_arg(node.kwargs))\n elif node.op == 'output':\n return load_arg(node.args[0])\n\n env[node.name] = result\n root_node, obj = self.matches.get(node.name, (None, None))\n if root_node is node:\n obj.observe(node, env)\n if node.name in self.quants:\n self.quants[node.name].observe(node, env)\n\n raise RuntimeError('Graph had no output node!')\n\n def quantize(self):\n self.quantized_graph = Graph()\n\n env = {}\n quant_env = {}\n\n def load_arg(n, quantized):\n if not quantized:\n if n.name not in env and n.name in quant_env:\n env[n.name] = Proxy(quant_env[n.name]).dequantize().node\n return env[n.name]\n else:\n if n.name not in quant_env and n.name in env:\n quant_env[n.name] = self.quants[n.name].quantize(env[n.name])\n return quant_env[n.name]\n\n def copy_recursive(node):\n def load_or_emit(n):\n if n.name in env or e.name in quant_env:\n return load_arg(n, quantized=False)\n else:\n return copy_recusive(n)\n r = env[node.name] = self.quantized_graph.node_copy(node, lambda n: load_arg(n, quantized=False))\n return r\n\n for node in self.graph.nodes:\n root_node, obj = self.matches.get(node.name, (None, None))\n if root_node is None:\n # not quantized just copy it\n env[node.name] = self.quantized_graph.node_copy(node, lambda n: load_arg(n, quantized=False))\n\n elif root_node is node:\n r = obj.quantize(self, node, lambda a: map_arg(a, lambda n: load_arg(n, quantized=True)))\n if r is NotImplemented:\n # quantizer choose to to quantize the node take the entire match, and just copy it over\n env[node.name] = copy_recursive(node)\n else:\n quant_env[node.name] = r\n\n return GraphModule(self.root, self.quantized_graph)\n\n def _find_matches(self, patterns):\n modules = dict(self.root.named_modules())\n match_map = {} # node name -> (root_node, match_value?)\n\n def apply_match(pattern, node, match):\n if isinstance(pattern, tuple):\n s, *args = pattern\n apply_match(s, node, match)\n for subpattern, arg in zip(args, node.args):\n apply_match(subpattern, arg, match)\n else:\n match_map[node.name] = match\n\n for node in reversed(self.graph.nodes):\n if node.name not in match_map:\n for pattern, value in patterns.items():\n if matches(modules, node, pattern):\n apply_match(pattern, node, (node, value(self, node)))\n\n return match_map\n\n def _find_quants(self, quant_ctor):\n quants = {}\n\n def visit_arg(n):\n # note: we have to measure quantization information\n # even for nodes where we might not use it because it is already\n # quantized. This is because each match has the option to\n # say NotImplemented (if for instance, it is an __add__ and the data type is not appropriate)\n if n.name not in quants:\n quants[n.name] = quant_ctor(self, n)\n for node in self.graph.nodes:\n if node.name in self.matches:\n map_arg(node.args, visit_arg)\n map_arg(node.kwargs, visit_arg)\n return quants\n",
"import gc\nimport torch\n\nfrom ._utils import _dummy_type\n\n\nif not hasattr(torch._C, '_CudaStreamBase'):\n # Define dummy base classes\n torch._C.__dict__['_CUDAGraph'] = _dummy_type('_CUDAGraph')\n torch._C.__dict__['_graph_pool_handle'] = _dummy_type('_graph_pool_handle')\n\nfrom torch._C import _CUDAGraph # noqa: F401\nfrom torch._C import _graph_pool_handle\n\n\n# Python shim helps Sphinx process docstrings more reliably.\ndef graph_pool_handle():\n r\"\"\"\n Returns an opaque token representing the id of a graph memory pool.\n See :ref:`Graph memory management<graph-memory-management>`.\n\n .. warning::\n This API is a prototype and may change in future releases.\n \"\"\"\n return _graph_pool_handle()\n\n\n# Python shim helps Sphinx process docstrings more reliably.\nclass CUDAGraph(torch._C._CUDAGraph):\n r\"\"\"\n Wrapper around a CUDA graph.\n\n .. warning::\n This API is a prototype and may change in future releases.\n \"\"\"\n def __new__(cls):\n return super(CUDAGraph, cls).__new__(cls)\n\n def __init__(self):\n super(CUDAGraph, self).__init__()\n\n def capture_begin(self, pool=None):\n r\"\"\"\n Begins capturing CUDA work on the current stream.\n\n Typically, you shouldn't call ``capture_begin`` yourself.\n Use :class:`~torch.cuda.graph` or :func:`~torch.cuda.make_graphed_callables`,\n which call ``capture_begin`` internally.\n\n Arguments:\n pool (optional): Token (returned by :func:`~torch.cuda.graph_pool_handle` or\n :meth:`other_Graph_instance.pool()<torch.cuda.CUDAGraph.pool>`) that hints this graph may share memory\n with the indicated pool. See :ref:`Graph memory management<graph-memory-management>`.\n \"\"\"\n # I'm not sure if pybind11 converts a None arg to the default defined on the C++ side,\n # so I'm not taking any chances.\n if pool is None:\n super(CUDAGraph, self).capture_begin()\n else:\n super(CUDAGraph, self).capture_begin(pool)\n\n def capture_end(self):\n r\"\"\"\n Ends CUDA graph capture on the current stream.\n After ``capture_end``, ``replay`` may be called on this instance.\n\n Typically, you shouldn't call ``capture_end`` yourself.\n Use :class:`~torch.cuda.graph` or :func:`~torch.cuda.make_graphed_callables`,\n which call ``capture_end`` internally.\n \"\"\"\n super(CUDAGraph, self).capture_end()\n\n def replay(self):\n r\"\"\"\n Replays the CUDA work captured by this graph.\n \"\"\"\n super(CUDAGraph, self).replay()\n\n def reset(self):\n r\"\"\"\n Deletes the graph currently held by this instance.\n \"\"\"\n super(CUDAGraph, self).reset()\n\n def pool(self):\n r\"\"\"\n Returns an opaque token representing the id of this graph's memory pool.\n This id can optionally be passed to another graph's ``capture_begin``,\n which hints the other graph may share the same memory pool.\n \"\"\"\n return super(CUDAGraph, self).pool()\n\n\nclass graph(object):\n r\"\"\"\n Context-manager that captures CUDA work into a :class:`torch.cuda.CUDAGraph`\n object for later replay.\n\n See :ref:`CUDA Graphs <cuda-graph-semantics>` for a general introduction,\n detailed use, and constraints.\n\n Arguments:\n cuda_graph (torch.cuda.CUDAGraph): Graph object used for capture.\n pool (optional): Opaque token (returned by a call to :func:`~torch.cuda.graph_pool_handle()` or\n :meth:`other_Graph_instance.pool()<torch.cuda.CUDAGraph.pool>`) hinting this graph's capture\n may share memory from the specified pool. See :ref:`Graph memory management<graph-memory-management>`.\n stream (torch.cuda.Stream, optional): If supplied, will be set as the current stream in the context.\n If not supplied, ``graph`` sets its own internal side stream as the current stream in the context.\n\n .. note::\n For effective memory sharing, if you pass a ``pool`` used by a previous capture and the previous capture\n used an explicit ``stream`` argument, you should pass the same ``stream`` argument to this capture.\n\n .. warning::\n This API is a prototype and may change in future releases.\n \"\"\"\n default_capture_stream = None\n\n def __init__(self,\n cuda_graph,\n pool=None,\n stream=None):\n # Lazy-init of default_capture_stream helps avoid circular-import errors.\n # Not thread safe, but graphs already have the general (explicitly documented)\n # restriction that only one capture may be underway at a time in the process.\n if self.__class__.default_capture_stream is None:\n self.__class__.default_capture_stream = torch.cuda.Stream()\n\n self.pool = () if pool is None else (pool,)\n self.capture_stream = stream if stream is not None else self.__class__.default_capture_stream\n assert self.capture_stream is not None\n self.stream_ctx = torch.cuda.stream(self.capture_stream)\n self.cuda_graph = cuda_graph\n\n def __enter__(self):\n # Free as much memory as we can for the graph\n torch.cuda.synchronize()\n gc.collect()\n torch.cuda.empty_cache()\n\n # Stackoverflow seems comfortable with this pattern\n # https://stackoverflow.com/questions/26635684/calling-enter-and-exit-manually#39172487\n self.stream_ctx.__enter__()\n\n self.cuda_graph.capture_begin(*self.pool)\n\n\n def __exit__(self, exc_type, exc_value, traceback):\n self.cuda_graph.capture_end()\n self.stream_ctx.__exit__(exc_type, exc_value, traceback)\n # returning None should propagate exceptions from either capture_end or stream_ctx.__exit__()\n\n\ndef make_graphed_callables(callables, sample_args):\n r\"\"\"\n Accepts callables (functions or :class:`nn.Module<torch.nn.Module>`\\ s)\n and returns graphed versions.\n\n Each graphed callable's forward pass runs its source callable's\n forward CUDA work as a CUDA graph inside a single autograd node.\n\n The graphed callable's forward pass also appends\n a backward node to the autograd graph. During backward, this node runs the\n callable's backward work as a CUDA graph.\n\n Therefore, each graphed callable should be a drop-in replacement for its source callable\n in an autograd-enabled training loop.\n\n See :ref:`Partial-network capture<partial-network-capture>` for detailed use and constraints.\n\n If you pass a tuple of several callables, their captures will use the same memory pool.\n See :ref:`Graph memory management<graph-memory-management>` for when this is appropriate.\n\n Arguments:\n callables (torch.nn.Module or Python function, or tuple of these): Callable or callables to graph.\n See :ref:`Graph memory management<graph-memory-management>` for when passing a tuple of callables\n is appropriate. If you pass a tuple of callables, their order in the tuple must be the same order\n they'll run in the live workload.\n sample_args (tuple of Tensors, or tuple of tuples of Tensors): Samples args for each callable.\n If a single callable was passed, ``sample_args`` must be a single tuple of argument Tensors.\n If a tuple of callables was passed, ``sample_args`` must be tuple of tuples of argument Tensors.\n\n .. note::\n The ``requires_grad`` state of each Tensor in ``sample_args`` must match the state\n that's expected for the corresponding real input in the training loop.\n\n .. warning::\n This API is a prototype and may change in future releases.\n\n .. warning::\n ``sample_args`` for each callable must be a tuple of Tensors. Other types and keyword args\n are not allowed.\n\n .. warning::\n Returned callables do not support higher order differentiation (e.g., double backward).\n\n .. warning::\n In any :class:`~torch.nn.Module` passed to :func:`~make_graphed_callables`, only parameters\n may be trainable. Buffers must have ``requires_grad=False``.\n\n .. warning::\n After you pass a :class:`torch.nn.Module` through :func:`~make_graphed_callables`,\n you may not add or remove any of that Module's parameters or buffers.\n\n .. warning::\n :class:`torch.nn.Module`\\s passed to :func:`~torch.cuda.make_graphed_callables` must not have module hooks\n registered on them at the time they are passed. However, registering hooks on modules *after* passing them\n through :func:`~torch.cuda.make_graphed_callables` is allowed.\n\n .. warning::\n When running a graphed callable, you must pass its arguments in the same order and format\n they appeared in that callable's ``sample_args``.\n\n .. warning::\n All Tensor outputs of graphed callables must require grad.\n \"\"\"\n just_one_callable = False\n\n if not isinstance(callables, tuple):\n just_one_callable = True\n callables = (callables,)\n sample_args = (sample_args,)\n\n for c, args in zip(callables, sample_args):\n if isinstance(c, torch.nn.Module):\n assert len(c._backward_hooks) == 0 and len(c._forward_hooks) == 0 and len(c._forward_pre_hooks) == 0, \\\n \"Modules must not have hooks registered at the time they are passed. However, registering hooks \" + \\\n \"on modules after passing them through make_graphed_callables is allowed.\"\n assert all(b.requires_grad is False for b in c.buffers()), \"In any :class:`~torch.nn.Module` passed to \" + \\\n \":func:`~make_graphed_callables`, only parameters may be trainable. All buffers must have \" + \\\n \"``requires_grad=False``.\"\n assert all(isinstance(arg, torch.Tensor) for arg in args), \"In the prototype API, sample_args \" + \\\n \"for each callable must be a tuple of Tensors. Other types and keyword args are not allowed.\"\n\n\n # If a callable is an nn.Module, its graph's full input surface is the args the user explicitly\n # passes to forward (ie, its sample_args) AND the module's parameter attributes.\n per_callable_len_user_args = [len(args) for args in sample_args]\n per_callable_module_params = [tuple(c.parameters()) if isinstance(c, torch.nn.Module) else ()\n for c in callables]\n per_callable_static_input_surfaces = [sample_args[i] + per_callable_module_params[i]\n for i in range(len(callables))]\n\n fwd_graphs = [torch.cuda.CUDAGraph() for _ in range(len(callables))]\n bwd_graphs = [torch.cuda.CUDAGraph() for _ in range(len(callables))]\n\n mempool = graph_pool_handle()\n\n # Warmup\n # Hopefully prevents cudnn benchmarking and other lazy-initialization cuda work\n # from ending up in any captures.\n torch.cuda.synchronize()\n with torch.cuda.stream(torch.cuda.Stream()):\n for func, args, static_input_surface in zip(callables,\n sample_args,\n per_callable_static_input_surfaces):\n for _ in range(3):\n outputs = func(*args)\n outputs = (outputs,) if isinstance(outputs, torch.Tensor) else outputs\n grad_inputs = torch.autograd.grad(outputs=outputs,\n inputs=tuple(i for i in static_input_surface if i.requires_grad),\n grad_outputs=tuple(torch.empty_like(o) for o in outputs),\n only_inputs=True,\n allow_unused=False)\n del outputs, grad_inputs\n torch.cuda.synchronize()\n\n # All captures here share a mempool. To avoid replays corrupting each other's memory,\n # the safest approach is to capture all passes in the same order they'll run:\n # fwd 1, fwd 2, ... fwd N, then bwd N, bwd N-1, ... bwd 1.\n\n # Capture forward graphs\n per_callable_static_outputs = []\n per_callable_output_was_tensor = []\n for func, args, fwd_graph in zip(callables,\n sample_args,\n fwd_graphs):\n with torch.cuda.graph(fwd_graph, pool=mempool):\n outputs = func(*args)\n\n # Assumes model output is a tensor or tuple of tensors\n if isinstance(outputs, torch.Tensor):\n per_callable_output_was_tensor.append(True)\n outputs = (outputs,)\n else:\n per_callable_output_was_tensor.append(False)\n\n per_callable_static_outputs.append(outputs)\n\n # Capture backward graphs in reverse order\n per_callable_static_grad_outputs = []\n per_callable_static_grad_inputs = []\n for static_input_surface, static_outputs, bwd_graph, module_params in \\\n zip(reversed(per_callable_static_input_surfaces),\n reversed(per_callable_static_outputs),\n reversed(bwd_graphs),\n reversed(per_callable_module_params)):\n\n # For now, assumes all static_outputs require grad\n assert all(o.requires_grad for o in static_outputs), \"Outputs of graphed callables must require grad.\"\n static_grad_outputs = tuple(torch.empty_like(o) for o in static_outputs)\n\n with torch.cuda.graph(bwd_graph, pool=mempool):\n grad_inputs = torch.autograd.grad(outputs=static_outputs,\n inputs=tuple(i for i in static_input_surface if i.requires_grad),\n grad_outputs=static_grad_outputs,\n only_inputs=True,\n allow_unused=False)\n\n # Constructs a tuple suitable for returning from Graphed.backward:\n # Pads out the actually-needed grads with Nones in gradient slots for inputs that don't require grad.\n # I couldn't think of a slick one-liner for this pattern.\n static_grad_inputs = []\n grad_idx = 0\n for arg in static_input_surface:\n if arg.requires_grad:\n static_grad_inputs.append(grad_inputs[grad_idx])\n grad_idx += 1\n else:\n static_grad_inputs.append(None) # type: ignore[arg-type]\n static_grad_inputs = tuple(static_grad_inputs) # type: ignore[assignment]\n\n per_callable_static_grad_outputs.append(static_grad_outputs)\n per_callable_static_grad_inputs.append(static_grad_inputs)\n\n # Reverses the most recent two lists\n per_callable_static_grad_outputs = list(reversed(per_callable_static_grad_outputs))\n per_callable_static_grad_inputs = list(reversed(per_callable_static_grad_inputs))\n # Now for every per_callable list, per_callable_*[i] holds the stuff for the ith callable.\n\n def make_graphed_autograd_function(fwd_graph,\n bwd_graph,\n module_params,\n len_user_args,\n output_was_tensor,\n static_input_surface,\n static_outputs,\n static_grad_outputs,\n static_grad_inputs):\n class Graphed(torch.autograd.Function):\n @staticmethod\n def forward(ctx, *inputs):\n # At this stage, only the user args may (potentially) be new tensors.\n for i in range(len_user_args):\n if static_input_surface[i].data_ptr() != inputs[i].data_ptr():\n static_input_surface[i].copy_(inputs[i])\n fwd_graph.replay()\n assert isinstance(static_outputs, tuple)\n return tuple(o.detach() for o in static_outputs)\n\n @staticmethod\n @torch.autograd.function.once_differentiable\n def backward(ctx, *grads):\n for g, grad in zip(static_grad_outputs, grads):\n if g is None:\n assert grad is None\n else:\n # don't copy if autograd gods have been kind and the\n # incoming grad is already in the right place\n if g.data_ptr() != grad.data_ptr():\n g.copy_(grad)\n bwd_graph.replay()\n\n # Input args that didn't require grad expect a None gradient.\n assert isinstance(static_grad_inputs, tuple)\n return tuple(b.detach() if b is not None else b for b in static_grad_inputs)\n\n def functionalized(*user_args):\n # Runs the autograd function with inputs == all inputs to the graph that might require grad\n # (explicit user args + module parameters)\n # Assumes module params didn't change since capture.\n out = Graphed.apply(*(user_args + module_params))\n return out[0] if output_was_tensor else out\n\n return functionalized\n\n # Put together the final graphed callables\n ret = []\n for i, func in enumerate(callables):\n graphed = make_graphed_autograd_function(fwd_graphs[i],\n bwd_graphs[i],\n per_callable_module_params[i],\n per_callable_len_user_args[i],\n per_callable_output_was_tensor[i],\n per_callable_static_input_surfaces[i],\n per_callable_static_outputs[i],\n per_callable_static_grad_outputs[i],\n per_callable_static_grad_inputs[i])\n\n if isinstance(func, torch.nn.Module):\n def make_graphed_forward(func, graph_training_state, graphed, orig_fwd):\n def new_fwd(*user_args):\n # If the module's training-or-eval state matches what we graphed,\n # run the graph, otherwise run the original forward method\n if func.training == graph_training_state:\n return graphed(*user_args)\n else:\n return orig_fwd(*user_args)\n return new_fwd\n func.forward = make_graphed_forward(func, func.training, graphed, func.forward) # type: ignore[assignment]\n ret.append(func)\n else:\n ret.append(graphed)\n\n if just_one_callable:\n return ret[0]\n\n return tuple(ret)\n",
"# If you need to modify this file to make this test pass, please also apply same edits accordingly to\n# https://github.com/pytorch/examples/blob/master/distributed/rpc/rl/main.py\n# and https://pytorch.org/tutorials/intermediate/rpc_tutorial.html\n\nimport numpy as np\nfrom itertools import count\n\nimport torch\nimport torch.distributed.rpc as rpc\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport torch.optim as optim\nfrom torch.distributed.rpc import RRef, rpc_sync, rpc_async, remote\nfrom torch.distributions import Categorical\n\nfrom torch.testing._internal.dist_utils import dist_init, worker_name\nfrom torch.testing._internal.distributed.rpc.rpc_agent_test_fixture import RpcAgentTestFixture\n\nTOTAL_EPISODE_STEP = 5000\nGAMMA = 0.1\nSEED = 543\n\ndef _call_method(method, rref, *args, **kwargs):\n r\"\"\"\n a helper function to call a method on the given RRef\n \"\"\"\n return method(rref.local_value(), *args, **kwargs)\n\n\ndef _remote_method(method, rref, *args, **kwargs):\n r\"\"\"\n a helper function to run method on the owner of rref and fetch back the\n result using RPC\n \"\"\"\n args = [method, rref] + list(args)\n return rpc_sync(rref.owner(), _call_method, args=args, kwargs=kwargs)\n\n\nclass Policy(nn.Module):\n r\"\"\"\n Borrowing the ``Policy`` class from the Reinforcement Learning example.\n Copying the code to make these two examples independent.\n See https://github.com/pytorch/examples/tree/master/reinforcement_learning\n \"\"\"\n def __init__(self):\n super(Policy, self).__init__()\n self.affine1 = nn.Linear(4, 128)\n self.dropout = nn.Dropout(p=0.6)\n self.affine2 = nn.Linear(128, 2)\n\n self.saved_log_probs = []\n self.rewards = []\n\n def forward(self, x):\n x = self.affine1(x)\n x = self.dropout(x)\n x = F.relu(x)\n action_scores = self.affine2(x)\n return F.softmax(action_scores, dim=1)\n\n\nclass DummyEnv:\n r\"\"\"\n A dummy environment that implements the required subset of the OpenAI gym\n interface. It exists only to avoid a dependency on gym for running the\n tests in this file. It is designed to run for a set max number of iterations,\n returning random states and rewards at each step.\n \"\"\"\n def __init__(self, state_dim=4, num_iters=10, reward_threshold=475.0):\n self.state_dim = state_dim\n self.num_iters = num_iters\n self.iter = 0\n self.reward_threshold = reward_threshold\n\n def seed(self, manual_seed):\n torch.manual_seed(manual_seed)\n\n def reset(self):\n self.iter = 0\n return torch.randn(self.state_dim)\n\n def step(self, action):\n self.iter += 1\n state = torch.randn(self.state_dim)\n reward = torch.rand(1).item() * self.reward_threshold\n done = self.iter >= self.num_iters\n info = {}\n return state, reward, done, info\n\n\nclass Observer:\n r\"\"\"\n An observer has exclusive access to its own environment. Each observer\n captures the state from its environment, and send the state to the agent to\n select an action. Then, the observer applies the action to its environment\n and reports the reward to the agent.\n \"\"\"\n def __init__(self):\n self.id = rpc.get_worker_info().id\n self.env = DummyEnv()\n self.env.seed(SEED)\n\n def run_episode(self, agent_rref, n_steps):\n r\"\"\"\n Run one episode of n_steps.\n Arguments:\n agent_rref (RRef): an RRef referencing the agent object.\n n_steps (int): number of steps in this episode\n \"\"\"\n state, ep_reward = self.env.reset(), 0\n for step in range(n_steps):\n # send the state to the agent to get an action\n action = _remote_method(Agent.select_action, agent_rref, self.id, state)\n\n # apply the action to the environment, and get the reward\n state, reward, done, _ = self.env.step(action)\n\n # report the reward to the agent for training purpose\n _remote_method(Agent.report_reward, agent_rref, self.id, reward)\n\n if done:\n break\n\n\nclass Agent:\n def __init__(self, world_size):\n self.ob_rrefs = []\n self.agent_rref = RRef(self)\n self.rewards = {}\n self.saved_log_probs = {}\n self.policy = Policy()\n self.optimizer = optim.Adam(self.policy.parameters(), lr=1e-2)\n self.eps = np.finfo(np.float32).eps.item()\n self.running_reward = 0\n self.reward_threshold = DummyEnv().reward_threshold\n for ob_rank in range(1, world_size):\n ob_info = rpc.get_worker_info(worker_name(ob_rank))\n self.ob_rrefs.append(remote(ob_info, Observer))\n self.rewards[ob_info.id] = []\n self.saved_log_probs[ob_info.id] = []\n\n def select_action(self, ob_id, state):\n r\"\"\"\n This function is mostly borrowed from the Reinforcement Learning example.\n See https://github.com/pytorch/examples/tree/master/reinforcement_learning\n The main difference is that instead of keeping all probs in one list,\n the agent keeps probs in a dictionary, one key per observer.\n\n NB: no need to enforce thread-safety here as GIL will serialize\n executions.\n \"\"\"\n probs = self.policy(state.unsqueeze(0))\n m = Categorical(probs)\n action = m.sample()\n self.saved_log_probs[ob_id].append(m.log_prob(action))\n return action.item()\n\n def report_reward(self, ob_id, reward):\n r\"\"\"\n Observers call this function to report rewards.\n \"\"\"\n self.rewards[ob_id].append(reward)\n\n def run_episode(self, n_steps=0):\n r\"\"\"\n Run one episode. The agent will tell each observer to run n_steps.\n \"\"\"\n futs = []\n for ob_rref in self.ob_rrefs:\n # make async RPC to kick off an episode on all observers\n futs.append(\n rpc_async(\n ob_rref.owner(),\n _call_method,\n args=(Observer.run_episode, ob_rref, self.agent_rref, n_steps)\n )\n )\n\n # wait until all obervers have finished this episode\n for fut in futs:\n fut.wait()\n\n def finish_episode(self):\n r\"\"\"\n This function is mostly borrowed from the Reinforcement Learning example.\n See https://github.com/pytorch/examples/tree/master/reinforcement_learning\n The main difference is that it joins all probs and rewards from\n different observers into one list, and uses the minimum observer rewards\n as the reward of the current episode.\n \"\"\"\n\n # joins probs and rewards from different observers into lists\n R, probs, rewards = 0, [], []\n for ob_id in self.rewards:\n probs.extend(self.saved_log_probs[ob_id])\n rewards.extend(self.rewards[ob_id])\n\n # use the minimum observer reward to calculate the running reward\n min_reward = min([sum(self.rewards[ob_id]) for ob_id in self.rewards])\n self.running_reward = 0.05 * min_reward + (1 - 0.05) * self.running_reward\n\n # clear saved probs and rewards\n for ob_id in self.rewards:\n self.rewards[ob_id] = []\n self.saved_log_probs[ob_id] = []\n\n policy_loss, returns = [], []\n for r in rewards[::-1]:\n R = r + GAMMA * R\n returns.insert(0, R)\n returns = torch.tensor(returns)\n returns = (returns - returns.mean()) / (returns.std() + self.eps)\n for log_prob, R in zip(probs, returns):\n policy_loss.append(-log_prob * R)\n self.optimizer.zero_grad()\n policy_loss = torch.cat(policy_loss).sum()\n policy_loss.backward()\n self.optimizer.step()\n return min_reward\n\n\ndef run_agent(agent, n_steps):\n for i_episode in count(1):\n agent.run_episode(n_steps=n_steps)\n last_reward = agent.finish_episode()\n\n if agent.running_reward > agent.reward_threshold:\n print(\"Solved! Running reward is now {}!\".format(agent.running_reward))\n break\n\n\nclass ReinforcementLearningRpcTest(RpcAgentTestFixture):\n @dist_init(setup_rpc=False)\n def test_rl_rpc(self):\n if self.rank == 0:\n # Rank 0 is the agent.\n rpc.init_rpc(\n name=worker_name(self.rank),\n backend=self.rpc_backend,\n rank=self.rank,\n world_size=self.world_size,\n rpc_backend_options=self.rpc_backend_options,\n )\n agent = Agent(self.world_size)\n run_agent(agent, n_steps=int(TOTAL_EPISODE_STEP / (self.world_size - 1)))\n\n # Ensure training was run. We don't really care about whether the task was learned,\n # since the purpose of the test is to check the API calls.\n self.assertGreater(agent.running_reward, 0.0)\n else:\n # Other ranks are observers that passively wait for instructions from the agent.\n rpc.init_rpc(\n name=worker_name(self.rank),\n backend=self.rpc_backend,\n rank=self.rank,\n world_size=self.world_size,\n rpc_backend_options=self.rpc_backend_options,\n )\n rpc.shutdown()\n",
"import torch\n\n'''\n`SampleModule` is used by `test_cpp_api_parity.py` to test that Python / C++ API\nparity test harness works for `torch.nn.Module` subclasses.\n\nWhen `SampleModule.has_parity` is true, behavior of `forward` / `backward`\nis the same as the C++ equivalent.\n\nWhen `SampleModule.has_parity` is false, behavior of `forward` / `backward`\nis different from the C++ equivalent.\n'''\n\nclass SampleModule(torch.nn.Module):\n def __init__(self, has_parity, has_submodule):\n super(SampleModule, self).__init__()\n self.has_parity = has_parity\n if has_submodule:\n self.submodule = SampleModule(self.has_parity, False)\n\n self.has_submodule = has_submodule\n self.register_parameter('param', torch.nn.Parameter(torch.empty(3, 4)))\n\n self.reset_parameters()\n\n def reset_parameters(self):\n with torch.no_grad():\n self.param.fill_(1)\n\n def forward(self, x):\n submodule_forward_result = self.submodule(x) if hasattr(self, 'submodule') else 0\n if self.has_parity:\n return x + self.param * 2 + submodule_forward_result\n else:\n return x + self.param * 4 + submodule_forward_result + 3\n\ntorch.nn.SampleModule = SampleModule\n\nSAMPLE_MODULE_CPP_SOURCE = \"\"\"\\n\nnamespace torch {\nnamespace nn {\nstruct C10_EXPORT SampleModuleOptions {\n SampleModuleOptions(bool has_parity, bool has_submodule) : has_parity_(has_parity), has_submodule_(has_submodule) {}\n\n TORCH_ARG(bool, has_parity);\n TORCH_ARG(bool, has_submodule);\n};\n\nstruct C10_EXPORT SampleModuleImpl : public torch::nn::Cloneable<SampleModuleImpl> {\n explicit SampleModuleImpl(SampleModuleOptions options) : options(std::move(options)) {\n if (options.has_submodule()) {\n submodule = register_module(\n \"submodule\",\n std::make_shared<SampleModuleImpl>(SampleModuleOptions(options.has_parity(), false)));\n }\n reset();\n }\n void reset() {\n param = register_parameter(\"param\", torch::ones({3, 4}));\n }\n torch::Tensor forward(torch::Tensor x) {\n return x + param * 2 + (submodule ? submodule->forward(x) : torch::zeros_like(x));\n }\n SampleModuleOptions options;\n torch::Tensor param;\n std::shared_ptr<SampleModuleImpl> submodule{nullptr};\n};\n\nTORCH_MODULE(SampleModule);\n} // namespace nn\n} // namespace torch\n\"\"\"\n\nmodule_tests = [\n dict(\n module_name='SampleModule',\n desc='has_parity',\n constructor_args=(True, True),\n cpp_constructor_args='torch::nn::SampleModuleOptions(true, true)',\n input_size=(3, 4),\n cpp_input_args=['torch::randn({3, 4})'],\n has_parity=True,\n ),\n dict(\n fullname='SampleModule_no_parity',\n constructor=lambda: SampleModule(has_parity=False, has_submodule=True),\n cpp_constructor_args='torch::nn::SampleModuleOptions(false, true)',\n input_size=(3, 4),\n cpp_input_args=['torch::randn({3, 4})'],\n has_parity=False,\n ),\n # This is to test that setting the `test_cpp_api_parity=False` flag skips\n # the C++ API parity test accordingly (otherwise this test would run and\n # throw a parity error).\n dict(\n fullname='SampleModule_THIS_TEST_SHOULD_BE_SKIPPED',\n constructor=lambda: SampleModule(False, True),\n cpp_constructor_args='torch::nn::SampleModuleOptions(false, true)',\n input_size=(3, 4),\n cpp_input_args=['torch::randn({3, 4})'],\n test_cpp_api_parity=False,\n ),\n]\n",
"\n\n\n\n\nfrom caffe2.python import core\nfrom hypothesis import given, settings\nimport caffe2.python.hypothesis_test_util as hu\nimport hypothesis.strategies as st\nimport numpy as np\n\n\nclass RMACRegionsOpTest(hu.HypothesisTestCase):\n @given(\n n=st.integers(500, 500),\n h=st.integers(1, 10),\n w=st.integers(1, 10),\n scales=st.integers(1, 3),\n **hu.gcs\n )\n @settings(deadline=10000)\n def test(self, n, h, w, scales, gc, dc):\n X = np.random.rand(n, 64, h, w).astype(np.float32)\n overlap = 0.4\n\n def ref_op(X):\n N, H, W = X.shape[0], X.shape[2], X.shape[3]\n\n # Possible regions for the long dimension\n steps = np.array((2, 3, 4, 5, 6, 7), dtype=np.float32)\n minW = np.minimum(H, W)\n\n # steps(idx) regions for long dimension\n b = (np.maximum(H, W) - minW) / (steps - 1)\n idx = np.argmin(\n np.abs(((minW**2 - minW * b) / minW**2) - overlap)) + 1\n\n # Region overplus per dimension\n Wd = 0\n Hd = 0\n if H < W:\n Wd = idx\n elif H > W:\n Hd = idx\n\n regions_xywh = []\n for l in range(1, scales + 1):\n wl = np.floor(2 * minW / (l + 1))\n\n # Center coordinates\n if l + Wd - 1 > 0:\n b = (W - wl) / (l + Wd - 1)\n else:\n b = 0\n cenW = np.floor(b * np.arange(l - 1 + Wd + 1))\n\n # Center coordinates\n if l + Hd - 1 > 0:\n b = (H - wl) / (l + Hd - 1)\n else:\n b = 0\n cenH = np.floor(b * np.arange(l - 1 + Hd + 1))\n\n for i_ in cenW:\n for j_ in cenH:\n regions_xywh.append([i_, j_, wl, wl])\n\n # Round the regions. Careful with the borders!\n for i in range(len(regions_xywh)):\n for j in range(4):\n regions_xywh[i][j] = int(round(regions_xywh[i][j]))\n if regions_xywh[i][0] + regions_xywh[i][2] > W:\n regions_xywh[i][0] -= (\n (regions_xywh[i][0] + regions_xywh[i][2]) - W\n )\n if regions_xywh[i][1] + regions_xywh[i][3] > H:\n regions_xywh[i][1] -= (\n (regions_xywh[i][1] + regions_xywh[i][3]) - H\n )\n # Filter out 0-sized regions\n regions_xywh = [r for r in regions_xywh if r[2] * r[3] > 0]\n\n # Convert to ROIPoolOp format: (batch_index x1 y1 x2 y2)\n regions = [\n [i, x, y, x + w - 1, y + h - 1]\n for i in np.arange(N) for x, y, w, h in regions_xywh\n ]\n return (np.array(regions).astype(np.float32), )\n\n op = core.CreateOperator(\n 'RMACRegions',\n ['X'],\n ['RMAC_REGIONS'],\n scales=scales,\n overlap=overlap,\n )\n\n # Check against numpy reference\n self.assertReferenceChecks(gc, op, [X], ref_op)\n",
"from functools import partial\n\nimport caffe2.python.hypothesis_test_util as hu\nimport numpy as np\nfrom caffe2.python import core\n\n\ndef ref_adagrad(\n param_in,\n mom_in,\n grad,\n lr,\n epsilon,\n using_fp16=False,\n output_effective_lr=False,\n output_effective_lr_and_update=False,\n decay=1.0,\n row_wise=False,\n weight_decay=0.0,\n counter_halflife=-1,\n count=None, # only used when counter_halflife != -1\n):\n mom_in_f32 = mom_in\n param_in_f32 = param_in\n if using_fp16:\n mom_in_f32 = mom_in.astype(np.float32)\n param_in_f32 = param_in.astype(np.float32)\n\n if count and count > 0 and counter_halflife > 0:\n weight_decay *= counter_halflife / count\n grad_temp = grad + weight_decay * param_in_f32\n if row_wise:\n mom_out = decay * mom_in_f32 + np.mean(np.square(grad_temp))\n else:\n mom_out = decay * mom_in_f32 + np.square(grad_temp)\n effective_lr = lr / (np.sqrt(mom_out) + epsilon)\n grad_adj = effective_lr * grad_temp\n param_out = param_in_f32 + grad_adj\n\n if output_effective_lr_and_update:\n if using_fp16:\n return (\n param_out.astype(np.float16),\n mom_out.astype(np.float16),\n effective_lr.astype(np.float16),\n grad_adj.astype(np.float16),\n )\n else:\n return (\n param_out.astype(np.float32),\n mom_out.astype(np.float32),\n effective_lr.astype(np.float32),\n grad_adj.astype(np.float32),\n )\n elif output_effective_lr:\n if using_fp16:\n return (\n param_out.astype(np.float16),\n mom_out.astype(np.float16),\n effective_lr.astype(np.float16),\n )\n else:\n return (\n param_out.astype(np.float32),\n mom_out.astype(np.float32),\n effective_lr.astype(np.float32),\n )\n\n if using_fp16:\n return (param_out.astype(np.float16), mom_out.astype(np.float16))\n else:\n return (param_out.astype(np.float32), mom_out.astype(np.float32))\n\n\ndef adagrad_sparse_test_helper(\n parent_test,\n inputs,\n lr,\n epsilon,\n engine,\n ref_adagrad,\n gc,\n dc,\n row_wise=False,\n weight_decay=0.0,\n counter_halflife=-1,\n):\n param, momentum, grad = inputs\n if row_wise:\n # For row-wise adagrad, only take the first element of each row\n momentum = momentum.reshape(momentum.shape[0], -1)[:, 0]\n momentum = np.abs(momentum)\n lr = np.array([lr], dtype=np.float32)\n count = None\n if counter_halflife != -1:\n count = np.random.rand(param.shape[0])\n\n # Create an indexing array containing values that are lists of indices,\n # which index into grad\n if grad.size == 0:\n indices = np.empty(shape=(0,), dtype=np.int)\n else:\n indices = np.random.choice(\n np.arange(grad.shape[0]),\n size=np.random.randint(grad.shape[0]),\n replace=False,\n )\n\n # Sparsify grad\n grad = grad[indices]\n\n op = core.CreateOperator(\n \"RowWiseSparseAdagrad\" if row_wise else \"SparseAdagrad\",\n [\"param\", \"momentum\", \"indices\", \"grad\", \"lr\"] if count is None else [\"param\", \"momentum\", \"indices\", \"grad\", \"lr\", \"count\"],\n [\"param\", \"momentum\"],\n epsilon=epsilon,\n weight_decay=weight_decay,\n counter_halflife=counter_halflife,\n engine=engine,\n device_option=gc,\n )\n\n def ref_sparse(param, momentum, indices, grad, lr, count=None, ref_using_fp16=False):\n param_out = np.copy(param)\n momentum_out = np.copy(momentum)\n # Need to do this because it's possible ref_adagrad's using_fp16 could\n # have been already specialized.\n ref_adagrad_temp = (\n partial(ref_adagrad, using_fp16=ref_using_fp16)\n if ref_using_fp16\n else ref_adagrad\n )\n for i, index in enumerate(indices):\n param_out[index], momentum_out[index] = ref_adagrad_temp(\n param[index],\n momentum[index],\n grad[i],\n lr,\n epsilon,\n weight_decay=weight_decay,\n counter_halflife=counter_halflife,\n count=None if count is None else count[index],\n )\n return (param_out, momentum_out)\n\n ref_using_fp16_values = [False]\n if gc == hu.gpu_do and not row_wise:\n ref_using_fp16_values.append(True)\n\n for ref_using_fp16 in ref_using_fp16_values:\n if ref_using_fp16:\n print(\"test_sparse_adagrad with half precision embedding\")\n momentum_i = momentum.astype(np.float16)\n param_i = param.astype(np.float16)\n else:\n print(\"test_sparse_adagrad with full precision embedding\")\n momentum_i = momentum.astype(np.float32)\n param_i = param.astype(np.float32)\n\n parent_test.assertReferenceChecks(\n gc,\n op,\n [param_i, momentum_i, indices, grad, lr, count, ref_using_fp16],\n ref_sparse\n )\n",
"import torch\nimport torch.nn.quantized as nnq\nimport torch.nn.intrinsic as nni\n\nclass LinearReLU(nnq.Linear):\n r\"\"\"\n A LinearReLU module fused from Linear and ReLU modules\n\n We adopt the same interface as :class:`torch.nn.quantized.Linear`.\n\n Attributes:\n Same as torch.nn.quantized.Linear\n\n Examples::\n\n >>> m = nn.intrinsic.LinearReLU(20, 30)\n >>> input = torch.randn(128, 20)\n >>> output = m(input)\n >>> print(output.size())\n torch.Size([128, 30])\n \"\"\"\n _FLOAT_MODULE = nni.LinearReLU\n\n def __init__(self, in_features, out_features, bias=True, dtype=torch.qint8):\n super().__init__(in_features, out_features, bias, dtype)\n\n def forward(self, x: torch.Tensor) -> torch.Tensor:\n return torch.ops.quantized.linear_relu(\n x, self._packed_params._packed_params, self.scale, self.zero_point)\n\n def _get_name(self):\n return 'QuantizedLinearReLU'\n\n @classmethod\n def from_float(cls, mod):\n return super(LinearReLU, cls).from_float(mod)\n",
"\n\nimport time\n\nimport caffe2.python.hypothesis_test_util as hu\nimport hypothesis.strategies as st\nimport numpy as np\nfrom caffe2.python import core, workspace\nfrom hypothesis import given, settings\n\n\nnp.set_printoptions(precision=6)\n\n\nclass TestSpeedFloatToFusedRandRowwiseQuantized(hu.HypothesisTestCase):\n @given(\n bitwidth_=st.sampled_from([1, 2, 4, 8]),\n random_=st.sampled_from([True, False]),\n data_shape_=st.sampled_from(\n [\n np.array([32, 512]),\n np.array([1, 1024]),\n np.array([1024, 1024]),\n np.array([1024, 1224]),\n np.array([512, 969]),\n ]\n ),\n **hu.gcs\n )\n @settings(deadline=10000)\n def test_speed_of_rand_quantization(self, bitwidth_, random_, data_shape_, gc, dc):\n X1 = np.random.rand(data_shape_[0], data_shape_[1]).astype(np.float32)\n X2 = np.random.rand(data_shape_[0], data_shape_[1]).astype(np.float32)\n\n sub_scale_sum_net = core.Net(\"sub_scale_sum\")\n sub_op = core.CreateOperator(\"Sub\", [\"X1\", \"X2\"], [\"dX\"])\n scale_op = core.CreateOperator(\"Scale\", [\"dX\"], [\"dX\"], scale=0.023)\n sum_op = core.CreateOperator(\"Sum\", [\"X2\", \"dX\"], [\"X2\"])\n sub_scale_sum_net.Proto().op.extend([sub_op, scale_op, sum_op])\n\n enc_net = core.Net(\"enc\")\n enc_op = core.CreateOperator(\n \"FloatToFusedRandRowwiseQuantized\",\n [\"dX\"],\n [\"Y\"],\n bitwidth=bitwidth_,\n random=random_,\n )\n enc_net.Proto().op.extend([enc_op])\n\n dec_net = core.Net(\"dec\")\n dec_op = core.CreateOperator(\n \"FusedRandRowwiseQuantizedToFloat\", [\"Y\"], [\"decX\"]\n )\n dec_net.Proto().op.extend([dec_op])\n\n workspace.FeedBlob(\"X1\", X1)\n workspace.FeedBlob(\"X2\", X2)\n\n workspace.CreateNet(sub_scale_sum_net)\n workspace.CreateNet(enc_net)\n workspace.CreateNet(dec_net)\n workspace.RunNet(sub_scale_sum_net)\n workspace.RunNet(enc_net)\n workspace.RunNet(dec_net)\n\n sub_scale_sum_time = 0\n enc_time = 0\n dec_time = 0\n times = 10\n for _ in range(times):\n start = time.time()\n workspace.RunNet(sub_scale_sum_net)\n end = time.time()\n sub_scale_sum_time += end - start\n\n start = time.time()\n workspace.RunNet(enc_net)\n end = time.time()\n enc_time += end - start\n\n start = time.time()\n workspace.RunNet(dec_net)\n end = time.time()\n dec_time += end - start\n\n print(\"Sub+Scale+Sum time: {} ms\".format(sub_scale_sum_time / times * 1000))\n print(\n \"Quantizing time: {} ms ({}X)\".format(\n enc_time / times * 1000, enc_time / sub_scale_sum_time\n )\n )\n print(\n \"De-quantizing time: {} ms ({}X)\".format(\n dec_time / times * 1000, dec_time / sub_scale_sum_time\n )\n )\n\n\nif __name__ == \"__main__\":\n import unittest\n\n unittest.main()\n",
"\n\n\n\n\nfrom caffe2.python import core\nfrom hypothesis import given\nimport caffe2.python.hypothesis_test_util as hu\nimport hypothesis.strategies as st\nimport numpy as np\n\n\ndef calculate_ap(predictions, labels):\n N, D = predictions.shape\n ap = np.zeros(D)\n num_range = np.arange((N), dtype=np.float32) + 1\n for k in range(D):\n scores = predictions[:N, k]\n label = labels[:N, k]\n sortind = np.argsort(-scores, kind='mergesort')\n truth = label[sortind]\n precision = np.cumsum(truth) / num_range\n ap[k] = precision[truth.astype(np.bool)].sum() / max(1, truth.sum())\n return ap\n\n\nclass TestAPMeterOps(hu.HypothesisTestCase):\n @given(predictions=hu.arrays(dims=[10, 3],\n elements=hu.floats(allow_nan=False,\n allow_infinity=False,\n min_value=0.1,\n max_value=1)),\n labels=hu.arrays(dims=[10, 3],\n dtype=np.int32,\n elements=st.integers(min_value=0,\n max_value=1)),\n **hu.gcs_cpu_only)\n def test_average_precision(self, predictions, labels, gc, dc):\n op = core.CreateOperator(\n \"APMeter\",\n [\"predictions\", \"labels\"],\n [\"AP\"],\n buffer_size=10,\n )\n\n def op_ref(predictions, labels):\n ap = calculate_ap(predictions, labels)\n return (ap, )\n\n self.assertReferenceChecks(\n device_option=gc,\n op=op,\n inputs=[predictions, labels],\n reference=op_ref)\n\n @given(predictions=hu.arrays(dims=[10, 3],\n elements=hu.floats(allow_nan=False,\n allow_infinity=False,\n min_value=0.1,\n max_value=1)),\n labels=hu.arrays(dims=[10, 3],\n dtype=np.int32,\n elements=st.integers(min_value=0,\n max_value=1)),\n **hu.gcs_cpu_only)\n def test_average_precision_small_buffer(self, predictions, labels, gc, dc):\n op_small_buffer = core.CreateOperator(\n \"APMeter\",\n [\"predictions\", \"labels\"],\n [\"AP\"],\n buffer_size=5,\n )\n\n def op_ref(predictions, labels):\n # We can only hold the last 5 in the buffer\n ap = calculate_ap(predictions[5:], labels[5:])\n return (ap, )\n\n self.assertReferenceChecks(\n device_option=gc,\n op=op_small_buffer,\n inputs=[predictions, labels],\n reference=op_ref\n )\n",
"import sys\nimport torch\nimport functools\nimport inspect\nfrom typing import Any, Callable, TypeVar, cast\n\n\n__all__ = ['no_grad', 'enable_grad', 'set_grad_enabled',\n 'inference_mode']\n\n\n# Used for annotating the decorator usage of 'no_grad' and 'enable_grad'.\n# See https://mypy.readthedocs.io/en/latest/generics.html#declaring-decorators\nFuncType = Callable[..., Any]\nF = TypeVar('F', bound=FuncType)\n\n\nclass _DecoratorContextManager:\n \"\"\"Allow a context manager to be used as a decorator\"\"\"\n\n def __call__(self, func: F) -> F:\n if inspect.isgeneratorfunction(func):\n return self._wrap_generator(func)\n\n @functools.wraps(func)\n def decorate_context(*args, **kwargs):\n with self.__class__():\n return func(*args, **kwargs)\n return cast(F, decorate_context)\n\n def _wrap_generator(self, func):\n \"\"\"Wrap each generator invocation with the context manager\"\"\"\n @functools.wraps(func)\n def generator_context(*args, **kwargs):\n gen = func(*args, **kwargs)\n\n # Generators are suspended and unsuspended at `yield`, hence we\n # make sure the grad mode is properly set every time the execution\n # flow returns into the wrapped generator and restored when it\n # returns through our `yield` to our caller (see PR #49017).\n cls = type(self)\n try:\n # Issuing `None` to a generator fires it up\n with cls():\n response = gen.send(None)\n\n while True:\n try:\n # Forward the response to our caller and get its next request\n request = yield response\n\n except GeneratorExit:\n # Inform the still active generator about its imminent closure\n with cls():\n gen.close()\n raise\n\n except BaseException:\n # Propagate the exception thrown at us by the caller\n with cls():\n response = gen.throw(*sys.exc_info())\n\n else:\n # Pass the last request to the generator and get its response\n with cls():\n response = gen.send(request)\n\n # We let the exceptions raised above by the generator's `.throw` or\n # `.send` methods bubble up to our caller, except for StopIteration\n except StopIteration as e:\n # The generator informed us that it is done: take whatever its\n # returned value (if any) was and indicate that we're done too\n # by returning it (see docs for python's return-statement).\n return e.value\n\n return generator_context\n\n def __enter__(self) -> None:\n raise NotImplementedError\n\n def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:\n raise NotImplementedError\n\n\nclass no_grad(_DecoratorContextManager):\n r\"\"\"Context-manager that disabled gradient calculation.\n\n Disabling gradient calculation is useful for inference, when you are sure\n that you will not call :meth:`Tensor.backward()`. It will reduce memory\n consumption for computations that would otherwise have `requires_grad=True`.\n\n In this mode, the result of every computation will have\n `requires_grad=False`, even when the inputs have `requires_grad=True`.\n\n This context manager is thread local; it will not affect computation\n in other threads.\n\n Also functions as a decorator. (Make sure to instantiate with parenthesis.)\n\n .. note::\n No-grad is one of several mechanisms that can enable or\n disable gradients locally see :ref:`locally-disable-grad-doc` for\n more information on how they compare.\n\n Example::\n\n >>> x = torch.tensor([1], requires_grad=True)\n >>> with torch.no_grad():\n ... y = x * 2\n >>> y.requires_grad\n False\n >>> @torch.no_grad()\n ... def doubler(x):\n ... return x * 2\n >>> z = doubler(x)\n >>> z.requires_grad\n False\n \"\"\"\n def __init__(self):\n if not torch._jit_internal.is_scripting():\n super().__init__()\n self.prev = False\n\n def __enter__(self):\n self.prev = torch.is_grad_enabled()\n torch.set_grad_enabled(False)\n\n def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:\n torch.set_grad_enabled(self.prev)\n\n\nclass enable_grad(_DecoratorContextManager):\n r\"\"\"Context-manager that enables gradient calculation.\n\n Enables gradient calculation, if it has been disabled via :class:`~no_grad`\n or :class:`~set_grad_enabled`.\n\n This context manager is thread local; it will not affect computation\n in other threads.\n\n Also functions as a decorator. (Make sure to instantiate with parenthesis.)\n\n .. note::\n enable_grad is one of several mechanisms that can enable or\n disable gradients locally see :ref:`locally-disable-grad-doc` for\n more information on how they compare.\n\n Example::\n\n >>> x = torch.tensor([1.], requires_grad=True)\n >>> with torch.no_grad():\n ... with torch.enable_grad():\n ... y = x * 2\n >>> y.requires_grad\n True\n >>> y.backward()\n >>> x.grad\n >>> @torch.enable_grad()\n ... def doubler(x):\n ... return x * 2\n >>> with torch.no_grad():\n ... z = doubler(x)\n >>> z.requires_grad\n True\n\n \"\"\"\n def __enter__(self) -> None:\n self.prev = torch.is_grad_enabled()\n torch._C._set_grad_enabled(True)\n\n def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:\n torch._C._set_grad_enabled(self.prev)\n\n\nclass set_grad_enabled(object):\n r\"\"\"Context-manager that sets gradient calculation to on or off.\n\n ``set_grad_enabled`` will enable or disable grads based on its argument :attr:`mode`.\n It can be used as a context-manager or as a function.\n\n This context manager is thread local; it will not affect computation\n in other threads.\n\n Args:\n mode (bool): Flag whether to enable grad (``True``), or disable\n (``False``). This can be used to conditionally enable\n gradients.\n\n .. note::\n set_grad_enabled is one of several mechanisms that can enable or\n disable gradients locally see :ref:`locally-disable-grad-doc` for\n more information on how they compare.\n\n Example::\n\n >>> x = torch.tensor([1], requires_grad=True)\n >>> is_train = False\n >>> with torch.set_grad_enabled(is_train):\n ... y = x * 2\n >>> y.requires_grad\n False\n >>> torch.set_grad_enabled(True)\n >>> y = x * 2\n >>> y.requires_grad\n True\n >>> torch.set_grad_enabled(False)\n >>> y = x * 2\n >>> y.requires_grad\n False\n\n \"\"\"\n\n def __init__(self, mode: bool) -> None:\n self.prev = torch.is_grad_enabled()\n torch._C._set_grad_enabled(mode)\n\n def __enter__(self) -> None:\n pass\n\n def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:\n torch._C._set_grad_enabled(self.prev)\n\n\nclass inference_mode(_DecoratorContextManager):\n r\"\"\"Context-manager that enables or disables inference mode\n\n InferenceMode is a new context manager analogous to :class:`~no_grad`\n to be used when you are certain your operations will have no interactions\n with autograd (e.g., model training). Code run under this mode gets better\n performance by disabling view tracking and version counter bumps.\n\n This context manager is thread local; it will not affect computation\n in other threads.\n\n Also functions as a decorator. (Make sure to instantiate with parenthesis.)\n\n .. note::\n Inference mode is one of several mechanisms that can enable or\n disable gradients locally see :ref:`locally-disable-grad-doc` for\n more information on how they compare.\n\n Args:\n mode (bool): Flag whether to enable or disable inference mode\n\n Example::\n >>> import torch\n >>> x = torch.ones(1, 2, 3, requires_grad=True)\n >>> with torch.inference_mode():\n ... y = x * x\n >>> y.requires_grad\n False\n >>> y._version\n Traceback (most recent call last):\n File \"<stdin>\", line 1, in <module>\n RuntimeError: Inference tensors do not track version counter.\n >>> @torch.inference_mode()\n ... def func(x):\n ... return x * x\n >>> out = func(x)\n >>> out.requires_grad\n False\n\n \"\"\"\n def __init__(self, mode=True):\n if not torch._jit_internal.is_scripting():\n super().__init__()\n # Holds a python binding to a RAII guard that can enable or disable\n # inference mode\n self._inference_mode_raii_guard = None\n self.mode = mode\n\n def __enter__(self):\n self._inference_mode_raii_guard = torch._C._InferenceMode(self.mode)\n\n def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:\n del self._inference_mode_raii_guard\n"
] | [
[
"torch.cuda.synchronize",
"torch.distributed.init_process_group",
"torch.cuda.manual_seed",
"torch.multiprocessing.spawn",
"torch.manual_seed",
"torch.cuda.Event",
"numpy.percentile",
"torch.distributed.distributed_c10d._get_default_group",
"numpy.mean",
"torch.rand",
"torch.device",
"numpy.array",
"torch.nn.MSELoss",
"torch.nn.parallel.DistributedDataParallel"
],
[
"numpy.random.rand",
"numpy.testing.assert_allclose"
],
[
"numpy.random.randint"
],
[
"torch.testing._internal.common_utils.run_tests"
],
[
"torch.jit._trace._script_if_tracing",
"torch._jit_internal._isinstance",
"torch.utils.set_module"
],
[
"torch.Generator",
"torch.randint",
"torch.empty",
"torch.randperm",
"torch.multinomial",
"torch.as_tensor"
],
[
"torch._C.PyTorchFileReader",
"torch._C.DeserializationStorageContext",
"torch.serialization._maybe_decode_ascii",
"torch.serialization._get_restore_location",
"torch._utils._validate_loaded_sparse_tensors"
],
[
"numpy.square",
"numpy.expand_dims",
"numpy.random.randn"
],
[
"torch.distributed.elastic.events.Event.deserialize",
"torch.distributed.elastic.events.RdzvEvent.deserialize",
"torch.distributed.elastic.events.construct_and_record_rdzv_event",
"torch.distributed.elastic.events._get_or_create_logger",
"torch.distributed.elastic.events.RdzvEvent",
"torch.distributed.elastic.events.Event",
"torch.testing._internal.common_utils.run_tests"
],
[
"torch.empty",
"torch.rand"
],
[
"torch.ceil",
"torch.cat",
"torch.cuda.current_device",
"torch._C._get_default_device",
"torch.autograd.forward_ad.unpack_dual",
"torch.isfinite",
"torch.no_grad",
"torch.get_default_dtype"
],
[
"torch.diag",
"torch.rand",
"torch.tensor"
],
[
"numpy.random.rand"
],
[
"torch.futures.wait_all",
"torch.distributed.init_process_group",
"torch.multiprocessing.spawn",
"torch.manual_seed",
"torch.utils.data.DataLoader",
"torch.distributed.is_initialized",
"torch.distributed.rpc.init_rpc",
"torch.distributed.FileStore",
"torch.distributed.rpc.TensorPipeRpcBackendOptions",
"torch.distributed.rpc.remote",
"torch.distributed.ProcessGroupGloo",
"torch.cuda.manual_seed_all",
"torch.distributed.rpc.shutdown",
"torch.distributed.rpc.rpc_async",
"torch.distributed.ProcessGroupNCCL"
],
[
"torch.distributed.elastic.rendezvous.RendezvousHandlerRegistry",
"torch.distributed.elastic.rendezvous.RendezvousParameters"
],
[
"torch._C._log_api_usage_once",
"torch.autograd.profiler.record_function",
"torch.typename"
],
[
"torch.nn.Sequential",
"torch.nn.PReLU",
"torch.nn.Conv2d",
"torch.nn.PixelShuffle",
"torch.nn.BatchNorm2d",
"torch.nn.init.orthogonal"
],
[
"numpy.random.seed",
"numpy.arange",
"numpy.ndarray",
"numpy.random.shuffle",
"numpy.random.rand",
"numpy.random.randint"
],
[
"torch.jit.export_opnames",
"torch.jit.trace",
"torch.rand"
],
[
"numpy.zeros",
"numpy.tile"
],
[
"torch.quantization.FakeQuantize",
"torch._fake_quantize_learnable_per_tensor_affine",
"torch.nn.quantized.DeQuantize",
"torch.ones",
"torch.zeros",
"torch.fake_quantize_per_tensor_affine",
"torch.tensor",
"torch.rand",
"torch.nn.quantized.Quantize",
"torch._fake_quantize_learnable_per_channel_affine",
"torch.fake_quantize_per_channel_affine"
],
[
"torch.device",
"torch._utils._get_device_index",
"torch.jit.is_scripting"
],
[
"numpy.load",
"numpy.max",
"numpy.testing.assert_almost_equal"
],
[
"numpy.log",
"numpy.random.random",
"numpy.sqrt",
"numpy.random.seed",
"numpy.power",
"numpy.multiply",
"numpy.transpose",
"numpy.testing.assert_array_equal",
"numpy.concatenate",
"numpy.piecewise",
"numpy.random.normal",
"numpy.testing.assert_allclose",
"numpy.array",
"numpy.sum",
"numpy.random.randint"
],
[
"torch.utils.cpp_extension.CppExtension"
],
[
"torch.fx.GraphModule",
"torch.fx.proxy.Proxy",
"torch.fx.graph.map_arg",
"torch.nn.utils.fuse_conv_bn_weights",
"torch.fx.Graph",
"torch.quantize_per_tensor",
"torch.finfo"
],
[
"torch.cuda.synchronize",
"torch.empty_like",
"torch._C._graph_pool_handle",
"torch.cuda.empty_cache",
"torch.cuda.stream",
"torch.cuda.graph",
"torch.cuda.CUDAGraph",
"torch.cuda.Stream"
],
[
"torch.nn.Dropout",
"torch.nn.functional.softmax",
"torch.testing._internal.dist_utils.worker_name",
"torch.cat",
"torch.manual_seed",
"torch.randn",
"torch.tensor",
"torch.distributed.rpc.get_worker_info",
"torch.nn.Linear",
"torch.distributed.rpc.remote",
"torch.nn.functional.relu",
"torch.distributions.Categorical",
"torch.testing._internal.dist_utils.dist_init",
"torch.rand",
"torch.distributed.rpc.shutdown",
"numpy.finfo",
"torch.distributed.rpc.RRef"
],
[
"torch.no_grad",
"torch.empty"
],
[
"numpy.maximum",
"numpy.minimum",
"numpy.abs",
"numpy.arange",
"numpy.random.rand",
"numpy.floor",
"numpy.array"
],
[
"numpy.square",
"numpy.abs",
"numpy.sqrt",
"numpy.arange",
"numpy.copy",
"numpy.random.rand",
"numpy.array",
"numpy.empty",
"numpy.random.randint"
],
[
"torch.ops.quantized.linear_relu"
],
[
"numpy.set_printoptions",
"numpy.array",
"numpy.random.rand"
],
[
"numpy.argsort",
"numpy.arange",
"numpy.zeros",
"numpy.cumsum"
],
[
"torch._C._set_grad_enabled",
"torch._C._InferenceMode",
"torch.set_grad_enabled",
"torch._jit_internal.is_scripting",
"torch.is_grad_enabled"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
mingxiaoh/chainer-v3 | [
"815ff00f5eaf7944d6e8a75662ff64a2fe046a4d",
"815ff00f5eaf7944d6e8a75662ff64a2fe046a4d",
"815ff00f5eaf7944d6e8a75662ff64a2fe046a4d",
"815ff00f5eaf7944d6e8a75662ff64a2fe046a4d",
"815ff00f5eaf7944d6e8a75662ff64a2fe046a4d"
] | [
"tests/chainer_tests/functions_tests/connection_tests/test_n_step_lstm.py",
"chainer/testing/unary_math_function_test.py",
"tests/mkldnnpy_tests/test_relu_bench.py",
"tests/mkldnnpy_tests/test_linear_bench.py",
"chainer/functions/connection/n_step_lstm.py"
] | [
"import unittest\n\nimport mock\nimport numpy\n\nimport chainer\nfrom chainer import cuda\nfrom chainer import functions\nfrom chainer import gradient_check\nfrom chainer import testing\nfrom chainer.testing import attr\n\n\ndef sigmoid(x):\n return numpy.tanh(x * 0.5) * 0.5 + 0.5\n\n\ndef _split(inputs, pos):\n return inputs[:pos], inputs[pos:]\n\n\[email protected](*testing.product({\n 'use_cudnn': [True, False],\n}))\nclass TestNStepLSTM(unittest.TestCase):\n\n batches = [3, 2, 1]\n length = len(batches)\n in_size = 3\n out_size = 2\n n_layers = 2\n dropout = 0.0\n\n def setUp(self):\n self.xs = [numpy.random.uniform(-1, 1, (b, self.in_size)).astype('f')\n for b in self.batches]\n h_shape = (self.n_layers, self.batches[0], self.out_size)\n self.cx = numpy.random.uniform(-1, 1, h_shape).astype(numpy.float32)\n self.hx = numpy.random.uniform(-1, 1, h_shape).astype(numpy.float32)\n\n self.ws = []\n self.bs = []\n for i in range(self.n_layers):\n weights = []\n biases = []\n for j in range(8):\n if i == 0 and j < 4:\n w_in = self.in_size\n else:\n w_in = self.out_size\n\n weights.append(numpy.random.uniform(\n -1, 1, (self.out_size, w_in)).astype('f'))\n biases.append(numpy.random.uniform(\n -1, 1, (self.out_size,)).astype('f'))\n self.ws.append(weights)\n self.bs.append(biases)\n\n self.dys = [numpy.random.uniform(-1, 1, (b, self.out_size)).astype('f')\n for b in self.batches]\n self.dcy = numpy.random.uniform(-1, 1, h_shape).astype(numpy.float32)\n self.dhy = numpy.random.uniform(-1, 1, h_shape).astype(numpy.float32)\n\n def check_forward(\n self, h_data, c_data, xs_data, ws_data, bs_data, volatile):\n h = chainer.Variable(h_data, volatile=volatile)\n c = chainer.Variable(c_data, volatile=volatile)\n xs = [chainer.Variable(x, volatile=volatile) for x in xs_data]\n ws = [[chainer.Variable(w, volatile=volatile) for w in ws]\n for ws in ws_data]\n bs = [[chainer.Variable(b, volatile=volatile) for b in bs]\n for bs in bs_data]\n hy, cy, ys = functions.n_step_lstm(\n self.n_layers, self.dropout, h, c, ws, bs, xs,\n use_cudnn=self.use_cudnn)\n\n e_hy = self.hx.copy()\n e_cy = self.cx.copy()\n for ind in range(self.length):\n x = self.xs[ind]\n batch = x.shape[0]\n for layer in range(self.n_layers):\n w = self.ws[layer]\n b = self.bs[layer]\n h_prev = e_hy[layer, :batch]\n c_prev = e_cy[layer, :batch]\n i = sigmoid(x.dot(w[0].T) + h_prev.dot(w[4].T) + b[0] + b[4])\n f = sigmoid(x.dot(w[1].T) + h_prev.dot(w[5].T) + b[1] + b[5])\n c_bar = numpy.tanh(\n x.dot(w[2].T) + h_prev.dot(w[6].T) + b[2] + b[6])\n o = sigmoid(x.dot(w[3].T) + h_prev.dot(w[7].T) + b[3] + b[7])\n e_c = (f * c_prev + i * c_bar)\n e_h = o * numpy.tanh(e_c)\n e_hy[layer, :batch] = e_h\n e_cy[layer, :batch] = e_c\n\n x = e_h\n\n testing.assert_allclose(\n ys[ind].data, x, rtol=1e-4, atol=1e-4)\n\n testing.assert_allclose(hy.data, e_hy, rtol=1e-4, atol=1e-4)\n testing.assert_allclose(cy.data, e_cy, rtol=1e-4, atol=1e-4)\n\n def test_forward_cpu(self):\n self.check_forward(self.hx, self.cx, self.xs, self.ws, self.bs, False)\n\n def test_forward_cpu_volatile(self):\n self.check_forward(self.hx, self.cx, self.xs, self.ws, self.bs, True)\n\n @attr.gpu\n def test_forward_gpu(self):\n self.check_forward(cuda.to_gpu(self.hx),\n cuda.to_gpu(self.cx),\n [cuda.to_gpu(x) for x in self.xs],\n [[cuda.to_gpu(w) for w in ws] for ws in self.ws],\n [[cuda.to_gpu(b) for b in bs] for bs in self.bs],\n False)\n\n @attr.gpu\n def test_forward_gpu_volatile(self):\n self.check_forward(cuda.to_gpu(self.hx),\n cuda.to_gpu(self.cx),\n [cuda.to_gpu(x) for x in self.xs],\n [[cuda.to_gpu(w) for w in ws] for ws in self.ws],\n [[cuda.to_gpu(b) for b in bs] for bs in self.bs],\n True)\n\n def check_backward(self, h_data, c_data, xs_data, ws_data, bs_data,\n dhy_data, dcy_data, dys_data):\n args = tuple([h_data, c_data] + sum(ws_data, []) + sum(bs_data, []) +\n xs_data)\n grads = tuple([dhy_data, dcy_data] + dys_data)\n\n def f(*inputs):\n (hx, cx), inputs = _split(inputs, 2)\n ws = []\n for i in range(self.n_layers):\n weights, inputs = _split(inputs, 8)\n ws.append(weights)\n bs = []\n for i in range(self.n_layers):\n biases, inputs = _split(inputs, 8)\n bs.append(biases)\n xs = inputs\n hy, cy, ys = functions.n_step_lstm(\n self.n_layers, self.dropout, hx, cx, ws, bs, xs)\n return (hy, cy) + ys\n\n gradient_check.check_backward(\n f, args, grads, eps=1e-2, rtol=1e-3, atol=1e-3)\n\n def test_backward_cpu(self):\n self.check_backward(self.hx, self.cx, self.xs, self.ws, self.bs,\n self.dhy, self.dcy, self.dys)\n\n @attr.gpu\n def test_backward_gpu(self):\n self.check_backward(cuda.to_gpu(self.hx),\n cuda.to_gpu(self.cx),\n [cuda.to_gpu(x) for x in self.xs],\n [[cuda.to_gpu(w) for w in ws] for ws in self.ws],\n [[cuda.to_gpu(b) for b in bs] for bs in self.bs],\n cuda.to_gpu(self.dhy),\n cuda.to_gpu(self.dcy),\n [cuda.to_gpu(dy) for dy in self.dys])\n\n\[email protected](*testing.product({\n 'use_cudnn': [True, False],\n}))\[email protected]\nclass TestNStepLSTMCudnnCall(unittest.TestCase):\n\n batches = [4, 3, 2, 1]\n length = len(batches)\n in_size = 3\n out_size = 4\n n_layers = 2\n dropout = 0.0\n\n def setUp(self):\n self.xs = [cuda.cupy.random.uniform(\n -1, 1, (b, self.in_size)).astype('f')\n for b in self.batches]\n h_shape = (self.n_layers, self.batches[0], self.out_size)\n self.cx = cuda.cupy.random.uniform(-1, 1, h_shape).astype('f')\n self.hx = cuda.cupy.random.uniform(-1, 1, h_shape).astype('f')\n\n self.ws = []\n self.bs = []\n for i in range(self.n_layers):\n weights = []\n biases = []\n for j in range(8):\n if i == 0 and j < 4:\n w_in = self.in_size\n else:\n w_in = self.out_size\n\n weights.append(cuda.cupy.random.uniform(\n -1, 1, (self.out_size, w_in)).astype('f'))\n biases.append(cuda.cupy.random.uniform(\n -1, 1, (self.out_size,)).astype('f'))\n\n self.ws.append(weights)\n self.bs.append(biases)\n\n self.dys = [cuda.cupy.random.uniform(\n -1, 1, (b, self.out_size)).astype('f')\n for b in self.batches]\n self.dcy = cuda.cupy.random.uniform(-1, 1, h_shape).astype('f')\n self.dhy = cuda.cupy.random.uniform(-1, 1, h_shape).astype('f')\n self.expect = self.use_cudnn and (\n cuda.cudnn.cudnn.getVersion() >= 5000)\n\n def forward(self, train):\n volatile = not train\n h = chainer.Variable(self.hx, volatile=volatile)\n c = chainer.Variable(self.cx, volatile=volatile)\n xs = [chainer.Variable(x, volatile=volatile) for x in self.xs]\n ws = [[chainer.Variable(w, volatile=volatile) for w in ws]\n for ws in self.ws]\n bs = [[chainer.Variable(b, volatile=volatile) for b in bs]\n for bs in self.bs]\n with chainer.using_config('train', train):\n return functions.n_step_lstm(\n self.n_layers, self.dropout, h, c, ws, bs, xs,\n use_cudnn=self.use_cudnn)\n\n def test_call_cudnn_forward_training(self):\n with mock.patch('cupy.cuda.cudnn.RNNForwardTraining') as func:\n self.forward(True)\n self.assertEqual(func.called, self.expect)\n\n def test_call_cudnn_forward_inference(self):\n with mock.patch('cupy.cuda.cudnn.RNNForwardInference') as func:\n self.forward(False)\n self.assertEqual(func.called, self.expect)\n\n def test_call_cudnn_backward(self):\n hy, cy, ys = self.forward(True)\n hy.grad = self.dhy\n with mock.patch('cupy.cuda.cudnn.RNNBackwardWeights') as func:\n hy.backward()\n self.assertEqual(func.called, self.expect)\n\n\ntesting.run_module(__name__, __file__)\n",
"import numpy\nimport unittest\n\nimport chainer\nfrom chainer import cuda\nfrom chainer.testing import attr\nfrom chainer.testing import condition\n\n\ndef _make_data_default(shape, dtype):\n x = numpy.random.uniform(-1, 1, shape).astype(dtype)\n gy = numpy.random.uniform(-1, 1, shape).astype(dtype)\n return x, gy\n\n\ndef unary_math_function_unittest(func, func_expected=None, label_expected=None,\n make_data=None):\n \"\"\"Decorator for testing unary mathematical Chainer functions.\n\n This decorator makes test classes test unary mathematical Chainer\n functions. Tested are forward and backward computations on CPU and GPU\n across parameterized ``shape`` and ``dtype``.\n\n Args:\n func(~chainer.Function): Chainer function to be tested by the decorated\n test class.\n func_expected: Function used to provide expected values for\n testing forward computation. If not given, a corresponsing numpy\n function for ``func`` is implicitly picked up by its class name.\n label_expected(string): String used to test labels of Chainer\n functions. If not given, the class name of ``func`` lowered is\n implicitly used.\n make_data: Function to customize input and gradient data used\n in the tests. It takes ``shape`` and ``dtype`` as its arguments,\n and returns a tuple of input and gradient data. By default, uniform\n destribution ranged ``[-1, 1]`` is used for both.\n\n The decorated test class tests forward and backward computations on CPU and\n GPU across the following :func:`~chainer.testing.parameterize` ed\n parameters:\n\n - shape: rank of zero, and rank of more than zero\n - dtype: ``numpy.float16``, ``numpy.float32`` and ``numpy.float64``\n\n Additionally, it tests the label of the Chainer function.\n\n Chainer functions tested by the test class decorated with the decorator\n should have the following properties:\n\n - Unary, taking one parameter and returning one value\n - ``dtype`` of input and output are the same\n - Elementwise operation for the supplied ndarray\n\n .. admonition:: Example\n\n The following code defines a test class that tests\n :func:`~chainer.functions.sin` Chainer function, which takes a parameter\n with ``dtype`` of float and returns a value with the same ``dtype``.\n\n .. doctest::\n\n >>> import unittest\n >>> from chainer import testing\n >>> from chainer import functions as F\n >>>\n >>> @testing.unary_math_function_unittest(F.Sin())\n ... class TestSin(unittest.TestCase):\n ... pass\n\n Because the test methods are implicitly injected to ``TestSin`` class by\n the decorator, it is enough to place ``pass`` in the class definition.\n\n Now the test is run with ``nose`` module.\n\n .. doctest::\n\n >>> import nose\n >>> nose.run(\n ... defaultTest=__name__, argv=['', '-a', '!gpu'], exit=False)\n True\n\n To customize test data, ``make_data`` optional parameter can be used.\n The following is an example of testing ``sqrt`` Chainer function, which\n is tested in positive value domain here instead of the default input.\n\n .. doctest::\n\n >>> import numpy\n >>>\n >>> def make_data(shape, dtype):\n ... x = numpy.random.uniform(0.1, 1, shape).astype(dtype)\n ... gy = numpy.random.uniform(-1, 1, shape).astype(dtype)\n ... return x, gy\n ...\n >>> @testing.unary_math_function_unittest(F.Sqrt(),\n ... make_data=make_data)\n ... class TestSqrt(unittest.TestCase):\n ... pass\n ...\n >>> nose.run(\n ... defaultTest=__name__, argv=['', '-a', '!gpu'], exit=False)\n True\n\n ``make_data`` function which returns input and gradient data generated\n in proper value domains with given ``shape`` and ``dtype`` parameters is\n defined, then passed to the decorator's ``make_data`` parameter.\n\n \"\"\"\n\n # TODO(takagi) In the future, the Chainer functions that could be tested\n # with the decorator would be extended as:\n #\n # - Multiple input parameters\n # - Multiple output values\n # - Other types than float: integer\n # - Other operators other than analytic math: basic math\n\n # Import here to avoid mutual import.\n from chainer import gradient_check\n from chainer import testing\n\n if func_expected is None:\n name = func.__class__.__name__.lower()\n try:\n func_expected = getattr(numpy, name)\n except AttributeError:\n raise ValueError(\"NumPy has no functions corresponding \"\n \"to Chainer function '{}'.\".format(name))\n\n if label_expected is None:\n label_expected = func.__class__.__name__.lower()\n\n if make_data is None:\n make_data = _make_data_default\n\n def f(klass):\n assert issubclass(klass, unittest.TestCase)\n\n def setUp(self):\n self.x, self.gy = make_data(self.shape, self.dtype)\n if self.dtype == numpy.float16:\n self.backward_options = {\n 'eps': 2 ** -4, 'atol': 2 ** -4, 'rtol': 2 ** -4,\n 'dtype': numpy.float64}\n else:\n self.backward_options = {'atol': 1e-4, 'rtol': 1e-4}\n setattr(klass, \"setUp\", setUp)\n\n def check_forward(self, x_data):\n x = chainer.Variable(x_data)\n y = func(x)\n self.assertEqual(y.data.dtype, x_data.dtype)\n y_expected = func_expected(cuda.to_cpu(x_data), dtype=x_data.dtype)\n testing.assert_allclose(y_expected, y.data, atol=1e-4, rtol=1e-4)\n setattr(klass, \"check_forward\", check_forward)\n\n @condition.retry(3)\n def test_forward_cpu(self):\n self.check_forward(self.x)\n setattr(klass, \"test_forward_cpu\", test_forward_cpu)\n\n @attr.gpu\n @condition.retry(3)\n def test_forward_gpu(self):\n self.check_forward(cuda.to_gpu(self.x))\n setattr(klass, \"test_forward_gpu\", test_forward_gpu)\n\n def check_backward(self, x_data, y_grad):\n gradient_check.check_backward(\n func, x_data, y_grad, **self.backward_options)\n setattr(klass, \"check_backward\", check_backward)\n\n @condition.retry(3)\n def test_backward_cpu(self):\n self.check_backward(self.x, self.gy)\n setattr(klass, \"test_backward_cpu\", test_backward_cpu)\n\n @attr.gpu\n @condition.retry(3)\n def test_backward_gpu(self):\n self.check_backward(cuda.to_gpu(self.x), cuda.to_gpu(self.gy))\n setattr(klass, \"test_backward_gpu\", test_backward_gpu)\n\n def test_label(self):\n self.assertEqual(func.label, label_expected)\n setattr(klass, \"test_label\", test_label)\n\n # Return parameterized class.\n return testing.parameterize(*testing.product({\n 'shape': [(3, 2), ()],\n 'dtype': [numpy.float16, numpy.float32, numpy.float64]\n }))(klass)\n return f\n",
"import chainer.functions as F\nimport numpy as np\nimport time\n\ndata = np.ndarray((10, 3, 2240, 2240), dtype=np.float32)\ndata.fill(333.33)\ndatay = np.ndarray((10, 3, 2240, 2240), dtype=np.float32)\ndatay.fill(333.33)\n\ntotal_forward = 0\ncount = 0\nniter = 15\nn_dry = 3\n\nfor i in range(niter):\n x = np.asarray(data),\n gy = np.asarray(datay),\n\n start = time.time()\n # model.forward(x)\n f_relu = F.ReLU(False)\n f_relu.forward_cpu(x)\n f_relu.backward_cpu(x, gy)\n end = time.time()\n if i > n_dry - 1:\n count += 1\n total_forward += (end-start)*1000\n\n\nprint(\"Average Forward: \", total_forward/count, \"ms\")\n\ndata = np.ndarray((2240, 2240), dtype=np.float32)\ndata.fill(333.33)\ndatay = np.ndarray((2240, 2240), dtype=np.float32)\ndatay.fill(333.33)\n\ntotal_forward = 0\ncount = 0\nniter = 5\nn_dry = 3\n\nfor i in range(niter):\n x = np.asarray(data),\n gy = np.asarray(datay),\n\n start = time.time()\n # model.forward(x)\n f_relu = F.ReLU(False)\n f_relu.forward_cpu(x)\n f_relu.backward_cpu(x, gy)\n end = time.time()\n if i > n_dry - 1:\n count += 1\n total_forward += (end-start)*1000\n\n\nprint(\"Average Forward: \", total_forward/count, \"ms\")\n",
"import chainer.links as L\nfrom chainer import Variable\n\nimport numpy as np\nimport time\n\nbatch = 1000\ntotal_backward = 0\ntotal_forward = 0\ncount = 0\nniter = 10\nn_dry = 3\n\ndata = np.ndarray((batch, 1000), dtype=np.float32)\ndata.fill(333.33)\n\ny_grad = np.ones((batch, 1000), dtype=np.float32)\n\nlinear = L.Linear(1000, 1000)\n\nx = Variable(data)\n\nfor i in range(niter):\n print(\"iter:\", i)\n x = np.asarray(data)\n start = time.time()\n y = linear(x)\n end = time.time()\n if i > n_dry - 1:\n count += 1\n total_forward += (end-start) * 1000\n y.grad = y_grad\n start = time.time()\n y.backward()\n end = time.time()\n if i > n_dry - 1:\n total_backward += (end-start) * 1000\n\nprint(\"Average Forward: \", total_forward/count, \"ms\")\nprint(\"Average Backward: \", total_backward/count, \"ms\")\nprint(\"Average Total: \", (total_forward + total_backward)/count, \"ms\")\n",
"import binascii\nimport itertools\nimport os\nimport time\n\nimport numpy\nimport six\n\nfrom chainer import configuration\nfrom chainer import cuda\nfrom chainer import function\nfrom chainer.functions.activation import lstm\nfrom chainer.functions.array import concat\nfrom chainer.functions.array import reshape\nfrom chainer.functions.array import split_axis\nfrom chainer.functions.array import stack\nfrom chainer.functions.connection import linear\nfrom chainer.functions.noise import dropout\nfrom chainer.utils import type_check\n\n\nif cuda.cudnn_enabled:\n cudnn = cuda.cudnn\n libcudnn = cuda.cudnn.cudnn\n _cudnn_version = libcudnn.getVersion()\n\n\nclass PointerArray(object):\n\n def __init__(self, lst, back_pointer):\n self._value = numpy.array(lst, dtype=numpy.intp)\n # Store back_pointer to prevent the GC removes the original variable\n self._back_pointer = back_pointer\n\n @property\n def data(self):\n return self._value.ctypes.data\n\n\ndef _make_tensor_descriptor_array(xs):\n \"\"\"Make an array of pointers denoting pointers of tensor descriptors.\n\n \"\"\"\n descs = []\n for x in xs:\n if x.ndim < 3:\n shape = x.shape + (1,) * (3 - x.ndim)\n x = x.reshape(shape)\n desc = cudnn.create_tensor_nd_descriptor(x)\n descs.append(desc)\n return PointerArray([d.value for d in descs], descs)\n\n\ndef _make_ptr_array(xs):\n \"\"\"Make an array of pointers denoting pointers of ndarrays.\n\n \"\"\"\n return PointerArray([x.data.ptr for x in xs], xs)\n\n\nclass DropoutStates(object):\n\n def __init__(self, states, desc):\n self.states = states\n self.desc = desc\n\n def set_dropout_ratio(self, handle, dropout):\n cudnn.set_dropout_descriptor(self.desc, handle, dropout)\n\n @staticmethod\n def create(handle, dropout, seed):\n states = cudnn.create_dropout_states(handle)\n desc = cudnn.create_dropout_descriptor(\n handle, dropout, states.data.ptr, states.size, seed)\n return DropoutStates(states, desc)\n\n\nclass DropoutRandomStates(object):\n\n def __init__(self, seed):\n self._states = None\n\n if seed is None:\n try:\n seed_str = binascii.hexlify(os.urandom(8))\n seed = numpy.uint64(int(seed_str, 16))\n except NotImplementedError:\n seed = numpy.uint64(time.clock() * 1000000)\n else:\n seed = numpy.uint64(seed)\n\n self._seed = seed\n\n def create_dropout_states(self, dropout):\n handle = cudnn.get_handle()\n if self._states is None:\n self._states = DropoutStates.create(handle, dropout, self._seed)\n else:\n self._states.set_dropout_ratio(handle, dropout)\n\n return self._states\n\n\n_random_states = {}\n\n\ndef get_random_state():\n global _random_states\n dev = cuda.Device()\n rs = _random_states.get(dev.id, None)\n if rs is None:\n rs = DropoutRandomStates(os.getenv('CHAINER_SEED'))\n _random_states[dev.id] = rs\n return rs\n\n\ndef _split(inputs, pos):\n return inputs[:pos], inputs[pos:]\n\n\nclass NStepLSTM(function.Function):\n\n def __init__(self, n_layers, states):\n self.n_layers = n_layers\n self.states = states\n\n def check_type_forward(self, in_types):\n type_check.expect(in_types.size() > 2 + 16 * self.n_layers)\n (h_type, c_type), in_types = _split(in_types, 2)\n type_check.expect(\n h_type.dtype == numpy.float32,\n c_type.dtype == numpy.float32,\n\n h_type.ndim == 3,\n h_type.shape[0] == self.n_layers,\n c_type.ndim == 3,\n c_type.shape[0] == self.n_layers,\n\n # mini-batch size\n h_type.shape[1] == c_type.shape[1],\n\n # hidden size\n h_type.shape[2] == c_type.shape[2],\n )\n w_types, in_types = _split(in_types, self.n_layers * 8)\n b_types, in_types = _split(in_types, self.n_layers * 8)\n x_types = in_types\n for x_type in x_types:\n type_check.expect(\n x_type.dtype == numpy.float32,\n x_type.ndim == 2,\n )\n for x1_type, x2_type in zip(x_types, x_types[1:]):\n type_check.expect(\n # Check if xs are sorted by descending lengths\n x1_type.shape[0] >= x2_type.shape[0],\n x1_type.shape[1] == x2_type.shape[1])\n\n in_size = x_types[0].shape[1]\n out_size = h_type.shape[2]\n\n for layer in six.moves.range(self.n_layers):\n for i in six.moves.range(8):\n ind = layer * 8 + i\n w_type = w_types[ind]\n b_type = b_types[ind]\n if layer == 0 and i < 4:\n w_in = in_size\n else:\n w_in = out_size\n\n type_check.expect(\n w_type.dtype == numpy.float32,\n w_type.ndim == 2,\n w_type.shape[0] == out_size,\n w_type.shape[1] == w_in,\n\n b_type.dtype == numpy.float32,\n b_type.ndim == 1,\n b_type.shape[0] == out_size,\n )\n\n def forward(self, inputs):\n (hx, cx), inputs = _split(inputs, 2)\n ws, inputs = _split(inputs, self.n_layers * 8)\n bs, inputs = _split(inputs, self.n_layers * 8)\n x_list = inputs\n\n hx = cuda.cupy.ascontiguousarray(hx)\n cx = cuda.cupy.ascontiguousarray(cx)\n\n x_desc = cudnn.create_tensor_nd_descriptor(x_list[0][..., None])\n\n length = len(x_list)\n n_units = hx.shape[2]\n\n xs = cuda.cupy.concatenate(x_list, axis=0)\n ys = cuda.cupy.empty((len(xs), n_units), dtype=xs.dtype)\n\n handle = cudnn.get_handle()\n self.handle = handle\n\n rnn_desc = cudnn.create_rnn_descriptor(\n n_units, self.n_layers, self.states.desc,\n libcudnn.CUDNN_LINEAR_INPUT, libcudnn.CUDNN_UNIDIRECTIONAL,\n libcudnn.CUDNN_LSTM, libcudnn.CUDNN_DATA_FLOAT)\n self.rnn_desc = rnn_desc\n\n c_x_descs = _make_tensor_descriptor_array(x_list)\n hx_desc = cudnn.create_tensor_nd_descriptor(hx)\n cx_desc = cudnn.create_tensor_nd_descriptor(cx)\n\n weights_size = libcudnn.getRNNParamsSize(\n handle, rnn_desc.value, x_desc.value, libcudnn.CUDNN_DATA_FLOAT)\n w = cuda.cupy.empty((weights_size // 4, 1, 1), dtype=numpy.float32)\n w_desc = cudnn.create_filter_descriptor(w)\n\n for layer in six.moves.range(self.n_layers):\n for lin_layer_id in six.moves.range(8):\n mat = cudnn.get_rnn_lin_layer_matrix_params(\n handle, rnn_desc, layer, x_desc, w_desc, w,\n lin_layer_id)\n m = mat.reshape(mat.size)\n m[...] = ws[layer * 8 + lin_layer_id].ravel()\n bias = cudnn.get_rnn_lin_layer_bias_params(\n handle, rnn_desc, layer, x_desc, w_desc, w,\n lin_layer_id)\n b = bias.reshape(bias.size)\n b[...] = bs[layer * 8 + lin_layer_id]\n self.w = w\n self.w_desc = w_desc\n\n sections = numpy.cumsum([len(x) for x in x_list[:-1]])\n y_list = cuda.cupy.split(ys, sections)\n\n c_y_descs = _make_tensor_descriptor_array(y_list)\n hy = cuda.cupy.empty_like(hx)\n cy = cuda.cupy.empty_like(cx)\n hy_desc = cudnn.create_tensor_nd_descriptor(hy)\n cy_desc = cudnn.create_tensor_nd_descriptor(cy)\n\n work_size = libcudnn.getRNNWorkspaceSize(\n handle, rnn_desc.value, length, c_x_descs.data)\n workspace = cuda.cupy.empty((work_size,), dtype='b')\n\n if not configuration.config.train:\n libcudnn.RNNForwardInference(\n handle, rnn_desc.value, length,\n c_x_descs.data, xs.data.ptr, hx_desc.value, hx.data.ptr,\n cx_desc.value, cx.data.ptr, w_desc.value, w.data.ptr,\n c_y_descs.data, ys.data.ptr, hy_desc.value, hy.data.ptr,\n cy_desc.value, cy.data.ptr, workspace.data.ptr, work_size)\n\n else:\n reserve_size = libcudnn.getRNNTrainingReserveSize(\n handle, rnn_desc.value, length, c_x_descs.data)\n self.reserve_space = cuda.cupy.empty((reserve_size,), dtype='b')\n libcudnn.RNNForwardTraining(\n handle, rnn_desc.value, length,\n c_x_descs.data, xs.data.ptr, hx_desc.value, hx.data.ptr,\n cx_desc.value, cx.data.ptr, w_desc.value, w.data.ptr,\n c_y_descs.data, ys.data.ptr, hy_desc.value, hy.data.ptr,\n cy_desc.value, cy.data.ptr,\n workspace.data.ptr, work_size,\n self.reserve_space.data.ptr, reserve_size)\n\n self.c_y_descs = c_y_descs\n self.ys = ys\n self.c_x_descs = c_x_descs\n\n return tuple([hy, cy] + y_list)\n\n def backward(self, inputs, grads):\n (hx, cx), inputs = _split(inputs, 2)\n ws, inputs = _split(inputs, self.n_layers * 8)\n bs, inputs = _split(inputs, self.n_layers * 8)\n x_list = inputs\n\n hx = cuda.cupy.ascontiguousarray(hx)\n cx = cuda.cupy.ascontiguousarray(cx)\n\n dhy, dcy = grads[:2]\n dy_list = list(grads[2:])\n if dhy is None:\n dhy = cuda.cupy.zeros_like(hx)\n if dcy is None:\n dcy = cuda.cupy.zeros_like(cx)\n for i in six.moves.range(len(dy_list)):\n if dy_list[i] is None:\n dy_list[i] = cuda.cupy.zeros_like(x_list[i])\n\n xs = cuda.cupy.concatenate(x_list, axis=0)\n length = len(x_list)\n\n dhx = cuda.cupy.empty_like(hx)\n dcx = cuda.cupy.empty_like(cx)\n\n hx_desc = cudnn.create_tensor_nd_descriptor(hx)\n cx_desc = cudnn.create_tensor_nd_descriptor(cx)\n dhy_desc = cudnn.create_tensor_nd_descriptor(dhy)\n dcy_desc = cudnn.create_tensor_nd_descriptor(dcy)\n\n c_dy_descs = _make_tensor_descriptor_array(dy_list)\n dys = cuda.cupy.concatenate(dy_list, axis=0)\n\n rnn_desc = self.rnn_desc\n handle = self.handle\n work_size = libcudnn.getRNNWorkspaceSize(\n handle, rnn_desc.value, length, self.c_x_descs.data)\n workspace = cuda.cupy.empty((work_size,), dtype='b')\n\n dhx_desc = cudnn.create_tensor_nd_descriptor(dhx)\n dcx_desc = cudnn.create_tensor_nd_descriptor(dcx)\n\n dxs = cuda.cupy.empty_like(xs)\n sections = numpy.cumsum([len(x) for x in x_list[:-1]])\n dx_list = cuda.cupy.split(dxs, sections, 0)\n c_dx_descs = _make_tensor_descriptor_array(dx_list)\n\n libcudnn.RNNBackwardData(\n handle, rnn_desc.value, length,\n self.c_y_descs.data, self.ys.data.ptr,\n c_dy_descs.data, dys.data.ptr, dhy_desc.value, dhy.data.ptr,\n dcy_desc.value, dcy.data.ptr, self.w_desc.value, self.w.data.ptr,\n hx_desc.value, hx.data.ptr, cx_desc.value, cx.data.ptr,\n c_dx_descs.data, dxs.data.ptr, dhx_desc.value, dhx.data.ptr,\n dcx_desc.value, dcx.data.ptr, workspace.data.ptr, work_size,\n self.reserve_space.data.ptr, self.reserve_space.size)\n\n dw = cuda.cupy.zeros_like(self.w)\n dw_desc = cudnn.create_filter_descriptor(dw)\n libcudnn.RNNBackwardWeights(\n handle, rnn_desc.value, length,\n self.c_x_descs.data, xs.data.ptr,\n hx_desc.value, hx.data.ptr, self.c_y_descs.data, self.ys.data.ptr,\n workspace.data.ptr, work_size, dw_desc.value, dw.data.ptr,\n self.reserve_space.data.ptr, self.reserve_space.size)\n\n dx = dx_list[0]\n dx = dx.reshape(dx.shape + (1,))\n dx_desc = cudnn.create_tensor_nd_descriptor(dx)\n dws = []\n dbs = []\n for layer in six.moves.range(self.n_layers):\n for lin_layer_id in six.moves.range(8):\n mat = cudnn.get_rnn_lin_layer_matrix_params(\n handle, rnn_desc, layer, dx_desc, dw_desc, dw,\n lin_layer_id)\n dws.append(mat.reshape(ws[layer * 8 + lin_layer_id].shape))\n bias = cudnn.get_rnn_lin_layer_bias_params(\n handle, rnn_desc, layer, dx_desc, dw_desc, dw,\n lin_layer_id)\n dbs.append(bias.reshape(bs[layer * 8 + lin_layer_id].shape))\n\n return tuple([dhx, dcx] + dws + dbs + dx_list)\n\n\ndef _stack_weight(ws):\n # TODO(unno): Input of the current LSTM implementaiton is shuffled\n w = stack.stack(ws, axis=1)\n shape = w.shape\n return reshape.reshape(w, (shape[0] * shape[1],) + shape[2:])\n\n\ndef n_step_lstm(\n n_layers, dropout_ratio, hx, cx, ws, bs, xs, use_cudnn=True):\n \"\"\"Stacked Long Short-Term Memory function for sequence inputs.\n\n This function calculates stacked LSTM with sequences. This function gets\n an initial hidden state :math:`h_0`, an initial cell state :math:`c_0`,\n an input sequence :math:`x`, weight matrices :math:`W`, and bias vectors\n :math:`b`.\n This function calculates hidden states :math:`h_t` and :math:`c_t` for each\n time :math:`t` from input :math:`x_t`.\n\n .. math::\n\n i_t &= \\\\sigma(W_0 x_t + W_4 h_{t-1} + b_0 + b_4) \\\\\\\\\n f_t &= \\\\sigma(W_1 x_t + W_5 h_{t-1} + b_1 + b_5) \\\\\\\\\n o_t &= \\\\sigma(W_2 x_t + W_6 h_{t-1} + b_2 + b_6) \\\\\\\\\n a_t &= \\\\tanh(W_3 x_t + W_7 h_{t-1} + b_3 + b_7) \\\\\\\\\n c_t &= f_t \\\\dot c_{t-1} + i_t \\\\dot a_t \\\\\\\\\n h_t &= o_t \\\\dot \\\\tanh(c_t)\n\n As the function accepts a sequence, it calculates :math:`h_t` for all\n :math:`t` with one call. Eight weight matrices and eight bias vectors are\n required for each layers. So, when :math:`S` layers exists, you need to\n prepare :math:`8S` weigth matrices and :math:`8S` bias vectors.\n\n If the number of layers ``n_layers`` is greather than :math:`1`, input\n of ``k``-th layer is hidden state ``h_t`` of ``k-1``-th layer.\n Note that all input variables except first layer may have different shape\n from the first layer.\n\n Args:\n n_layers(int): Number of layers.\n dropout_ratio(float): Dropout ratio.\n hx (chainer.Variable): Variable holding stacked hidden states.\n Its shape is ``(S, B, N)`` where ``S`` is number of layers and is\n equal to ``n_layers``, ``B`` is mini-batch size, and ``N`` is\n dimention of hidden units.\n cx (chainer.Variable): Variable holding stacked cell states.\n It has the same shape as ``hx``.\n ws (list of list of chainer.Variable): Weight matrices. ``ws[i]``\n represents weights for i-th layer.\n Each ``ws[i]`` is a list containing eight matrices.\n ``ws[i][j]`` is corresponding with ``W_j`` in the equation.\n Only ``ws[0][j]`` where ``0 <= j < 4`` is ``(I, N)`` shape as they\n are multiplied with input variables. All other matrices has\n ``(N, N)`` shape.\n bs (list of list of chainer.Variable): Bias vectors. ``bs[i]``\n represnents biases for i-th layer.\n Each ``bs[i]`` is a list containing eight vectors.\n ``bs[i][j]`` is corresponding with ``b_j`` in the equation.\n Shape of each matrix is ``(N,)`` where ``N`` is dimention of\n hidden units.\n xs (list of chainer.Variable): A list of :class:`~chainer.Variable`\n holding input values. Each element ``xs[t]`` holds input value\n for time ``t``. Its shape is ``(B_t, I)``, where ``B_t`` is\n mini-batch size for time ``t``, and ``I`` is size of input units.\n Note that this functions supports variable length sequences.\n When sequneces has different lengths, sort sequences in descending\n order by length, and transpose the sorted sequence.\n :func:`~chainer.functions.transpose_sequence` transpose a list\n of :func:`~chainer.Variable` holding sequence.\n So ``xs`` needs to satisfy\n ``xs[t].shape[0] >= xs[t + 1].shape[0]``.\n use_cudnn (bool): If ``True``, this function uses cuDNN if available.\n\n Returns:\n tuple: This functions returns a tuple concaining three elements,\n ``hy``, ``cy`` and ``ys``.\n\n - ``hy`` is an updated hidden states whose shape is same as ``hx``.\n - ``cy`` is an updated cell states whose shape is same as ``cx``.\n - ``ys`` is a list of :class:`~chainer.Variable` . Each element\n ``ys[t]`` holds hidden states of the last layer corresponding\n to an input ``xs[t]``. Its shape is ``(B_t, N)`` where ``B_t`` is\n mini-batch size for time ``t``, and ``N`` is size of hidden\n units. Note that ``B_t`` is the same value as ``xs[t]``.\n\n .. seealso::\n\n :func:`chainer.functions.lstm`\n\n \"\"\"\n\n xp = cuda.get_array_module(hx, hx.data)\n\n if use_cudnn and xp is not numpy and cuda.cudnn_enabled and \\\n _cudnn_version >= 5000:\n states = get_random_state().create_dropout_states(dropout_ratio)\n # flatten all input variables\n inputs = tuple(itertools.chain(\n (hx, cx),\n itertools.chain.from_iterable(ws),\n itertools.chain.from_iterable(bs),\n xs))\n rnn = NStepLSTM(n_layers, states)\n ret = rnn(*inputs)\n hy, cy = ret[:2]\n ys = ret[2:]\n return hy, cy, ys\n\n else:\n hx = split_axis.split_axis(hx, n_layers, axis=0, force_tuple=True)\n hx = [reshape.reshape(h, h.shape[1:]) for h in hx]\n cx = split_axis.split_axis(cx, n_layers, axis=0, force_tuple=True)\n cx = [reshape.reshape(c, c.shape[1:]) for c in cx]\n\n xws = [_stack_weight([w[2], w[0], w[1], w[3]]) for w in ws]\n hws = [_stack_weight([w[6], w[4], w[5], w[7]]) for w in ws]\n xbs = [_stack_weight([b[2], b[0], b[1], b[3]]) for b in bs]\n hbs = [_stack_weight([b[6], b[4], b[5], b[7]]) for b in bs]\n\n ys = []\n for x in xs:\n batch = x.shape[0]\n h_next = []\n c_next = []\n for layer in six.moves.range(n_layers):\n h = hx[layer]\n c = cx[layer]\n if h.shape[0] > batch:\n h, h_rest = split_axis.split_axis(h, [batch], axis=0)\n c, c_rest = split_axis.split_axis(c, [batch], axis=0)\n else:\n h_rest = None\n\n x = dropout.dropout(x, ratio=dropout_ratio)\n h = dropout.dropout(h, ratio=dropout_ratio)\n lstm_in = linear.linear(x, xws[layer], xbs[layer]) + \\\n linear.linear(h, hws[layer], hbs[layer])\n\n c_bar, h_bar = lstm.lstm(c, lstm_in)\n if h_rest is not None:\n h = concat.concat([h_bar, h_rest], axis=0)\n c = concat.concat([c_bar, c_rest], axis=0)\n else:\n h = h_bar\n c = c_bar\n h_next.append(h)\n c_next.append(c)\n x = h_bar\n hx = h_next\n cx = c_next\n ys.append(x)\n\n hy = stack.stack(hx)\n cy = stack.stack(cx)\n return hy, cy, tuple(ys)\n"
] | [
[
"numpy.random.uniform",
"numpy.tanh"
],
[
"numpy.random.uniform"
],
[
"numpy.asarray",
"numpy.ndarray"
],
[
"numpy.asarray",
"numpy.ndarray",
"numpy.ones"
],
[
"numpy.array",
"numpy.uint64"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
WuYff/ggnn.pytorch | [
"795bc7fb51876231406d71610aa5ec7ed29865c0",
"795bc7fb51876231406d71610aa5ec7ed29865c0"
] | [
"main_live.py",
"utils/data/wy_dataset3.py"
] | [
"import argparse\nimport random\n\nimport torch\nimport torch.nn as nn\nimport torch.optim as optim\n\nfrom model_live import GGNN\nfrom utils.train_live import train\nfrom utils.test_live import test\nfrom utils.validation_live import validation\nfrom utils.data.wy_dataset_live import bAbIDataset\nfrom utils.data.dataloader import bAbIDataloader\n\nparser = argparse.ArgumentParser()\nparser.add_argument('--task_id', type=int, default=4, help='bAbI task id')\nparser.add_argument('--question_id', type=int, default=0, help='question types')\nparser.add_argument('--workers', type=int, help='number of data loading workers', default=2)\n# parser.add_argument('--batchSize', type=int, default=10, help='input batch size')\nparser.add_argument('--batchSize', type=int, default=10, help='input batch size')\nparser.add_argument('--state_dim', type=int, default=4, help='GGNN hidden state size')\nparser.add_argument('--n_steps', type=int, default=1, help='propogation steps number of GGNN')\n# parser.add_argument('--niter', type=int, default=10, help='number of epochs to train for')\nparser.add_argument('--niter', type=int, default=15, help='number of epochs to train for')\nparser.add_argument('--lr', type=float, default=0.01, help='learning rate')\nparser.add_argument('--cuda', action='store_true', help='enables cuda')\nparser.add_argument('--verbal', action='store_true', help='print training info or not')\nparser.add_argument('--manualSeed', type=int, help='manual seed')\nparser.add_argument('--criterion', type=int, default=1)\nparser.add_argument('--choice_steps', type=int, default=2)\nparser.add_argument('--how_many', type=int, default=40)\n\nopt = parser.parse_args()\n\n# todo : shuffle before each epoch, specify the number od n_steps\n\nif opt.manualSeed is None:\n opt.manualSeed = random.randint(1, 10000)\nprint(\"Random Seed: \", opt.manualSeed)\nrandom.seed(opt.manualSeed)\ntorch.manual_seed(opt.manualSeed)\n\nopt.dataroot = '/home/yiwu/ggnn/wy/ggnn.pytorch/wy_data/live_jfree/lala'\n#opt.dataroot = '/home/yiwu/ggnn/wy/ggnn.pytorch/wy_data/one'\n\nif opt.cuda:\n torch.cuda.manual_seed_all(opt.manualSeed)\n\ndef main(opt):\n train_dataset = bAbIDataset(opt.dataroot, opt.question_id, \"t\",0,opt.how_many)\n print(\"len(train_dataset)\",len(train_dataset))\n # for i, (adj_matrix, annotation, target) in enumerate(train_dataset, 0):\n # print(\"annotation size\",annotation.shape)\n # print(\"adj_matrix size\",adj_matrix.shape)\n # print(\"target int\",target)\n # break\n \n # for i, (adj_matrix, annotation, target) in enumerate(train_dataloader, 0):\n # print(\"@annotation size\",annotation.shape)\n # print(\"@adj_matrix size\",adj_matrix.shape)\n # print(\"@target size\",target.shape)\n # break\n \n\n validation_dataset = bAbIDataset(opt.dataroot, opt.question_id, \"v\", train_dataset.n_node,opt.how_many)\n validation_dataloader = bAbIDataloader(validation_dataset, batch_size=opt.batchSize, \\\n shuffle=False, num_workers=2)\n print(\"len(validation_dataset)\",len(validation_dataset))\n\n test_dataset = bAbIDataset(opt.dataroot, opt.question_id, \"est\", train_dataset.n_node,opt.how_many)\n test_dataloader = bAbIDataloader(test_dataset, batch_size=opt.batchSize, \\\n shuffle=False, num_workers=2)\n print(\"len(test_dataset)\",len(test_dataset))\n opt.annotation_dim = train_dataset.n_def # for bAbI\n opt.n_edge_types = train_dataset.n_edge_types\n opt.n_node = train_dataset.n_node\n opt.state_dim = opt.annotation_dim\n opt.n_steps = opt.n_node\n \n if opt.choice_steps == 2:\n opt.n_steps = round(opt.n_node*0.5)\n elif opt.choice_steps == 3:\n opt.n_steps = opt.n_node*2\n elif opt.choice_steps == 4:\n opt.n_steps = opt.n_node*opt.n_node\n elif opt.choice_steps == 5:\n opt.n_steps = round(opt.n_node*0.3)\n\n net = GGNN(opt)\n net.double()\n \n \n criterion = nn.SmoothL1Loss()\n if opt.criterion == 2:\n criterion = torch.nn.L1Loss()\n elif opt.criterion == 3:\n criterion = torch.nn.MSELoss()\n \n\n if opt.cuda:\n net.cuda()\n criterion.cuda()\n\n optimizer = optim.Adam(net.parameters(), lr=opt.lr)\n print(\"opt\",opt)\n print(net)\n for epoch in range(0, opt.niter):\n train_dataloader = bAbIDataloader(train_dataset, batch_size=opt.batchSize, \\\n shuffle=True, num_workers=4)\n print(\"len(train_dataloader)\",len(train_dataloader))\n train(epoch, train_dataloader, net, criterion, optimizer, opt)\n validation(validation_dataloader, net, criterion, optimizer, opt)\n test(test_dataloader, net, criterion, optimizer, opt)\n\n\nif __name__ == \"__main__\":\n main(opt)\n\n",
"import os\nimport numpy as np\n\n# Can we assign -1 ? maybe it is better than 0.\n# data structure index starts from zero but node id value should start from one.\n# output a whole matrix\ndef load_graphs_from_file(path: str,how_many:int) -> (list, int):\n data_list = []\n max_node_id = 0\n path_list=os.listdir(path)\n key=\"graph\"\n skip_init = True\n count_ini =0 \n for filename in path_list:\n if key in filename:\n file = path + filename[:-10]\n # print(\"file: \"+filename[:-10])\n if os.path.exists(file + \"_graph.txt\"):\n edge_list = []\n label_list = []\n target_list = []\n max_node_of_one_graph = 0\n # [source node, target node]\n with open(file + \"_graph.txt\", 'r') as f:\n lines = f.readlines() # 读取所有行\n last_line = lines[-1] # 取最后一行\n n = last_line.split(\" \")\n node = int(n[0])\n if skip_init and ((len(lines) <= 3) or node > how_many ):\n count_ini += 1\n continue\n for line in lines:\n line_tokens = line.split(\" \")\n for i in range(1, len(line_tokens)):\n digits = [int(line_tokens[0]), 1, 0]\n if line_tokens[i] == \"\\n\":\n continue\n node_id = int(line_tokens[i])\n digits[2] = node_id\n if node_id > max_node_id:\n max_node_id = node_id\n if node_id > max_node_of_one_graph:\n max_node_of_one_graph = node_id\n edge_list.append(digits)\n\n # [node, rd1, rd2,....]\n with open(file + \"_target.txt\", 'r') as f:\n for line in f:\n digits = []\n line_tokens = line.split(\" \")\n for i in range(0, len(line_tokens)):\n if line_tokens[i] == \"\\n\":\n continue\n digits.append(int(line_tokens[i]))\n target_list.append(digits) # [[,,,][,,][,,]]\n # [node,variable]\n with open(file + \"_node_variable.txt\", 'r') as f:\n for line in f:\n digits = [0, 0]\n line_tokens = line.split(\" \")\n digits[0] = int(line_tokens[0])\n digits[1] = int(line_tokens[1])\n label_list.append(digits)\n data_list.append([edge_list, label_list, target_list,max_node_of_one_graph])\n print(\"totoal data : \", len(data_list))\n return (data_list, max_node_id)\n\n\ndef split_set(data_list:list):\n n_examples = len(data_list)\n idx = range(n_examples)\n num = round(n_examples*0.6)\n t= round(n_examples*0.2)\n train = idx[:num]\n test = idx[num: num+t]\n val = idx[num+t:]\n f = open(\"/home/yiwu/ggnn/wy/ggnn.pytorch/utils/data/vali_40.log\", 'wt')\n print(\"################################################\", file=f)\n for i in np.array(data_list)[val]:\n print(i, file=f)\n print(\"################################################\", file=f)\n return np.array(data_list)[train], np.array(data_list)[val], np.array(data_list)[test]\n\n\ndef data_convert(data_list: list, n_annotation_dim: int, n_nodes: int):\n n_tasks = 1\n task_data_list = []\n for i in range(n_tasks):\n task_data_list.append([])\n for item in data_list:\n edge_list = item[0]\n label_list = item[1]\n target_list = item[2]\n max_node_of_one_graph = item[3]\n task_type = 1\n task_output = create_task_output(target_list, n_nodes) # 原来是一个int，现在变成了长度为node_n * node_n 的 list\n annotation = np.zeros([n_nodes, n_annotation_dim])\n # annotation[target[1] - 1][0] = 1 # 你需要自己定义 annotation 和 n_annotation_dim\n annotation = create_annotation_output(label_list, annotation)\n task_data_list[task_type - 1].append([edge_list, annotation, task_output, max_node_of_one_graph])\n return task_data_list\n\n# Notice that the rd_id >= 1. Because zero means the corresponding node does not reach the current node \n# return target[ r0_1,r0_2,.....rn_1, ..., rn_n] with length = V*V\ndef create_task_output(target_list: list, n_nodes: int) -> np.array:\n a = np.zeros((n_nodes, n_nodes))\n # print(\"n_nodes\",n_nodes)\n # print(\"target_list\",target_list)\n for each_node_rd in target_list:\n # print(\"each_node_rd\",each_node_rd)\n for rd_id in each_node_rd[1:]:\n a[each_node_rd[0] - 1][rd_id - 1] = 1\n\n b = np.zeros(n_nodes*n_nodes)\n for i in range(n_nodes):\n for j in range(n_nodes):\n b[i*n_nodes+j] = a[i][j]\n return b\n\n# return annotation matrix [V, 1] (current annotation dim =1)\ndef create_annotation_output(label_list: list, annotation):\n for each_node_varible in label_list:\n annotation[each_node_varible[0] - 1][0] = each_node_varible[1]\n return annotation\n\n# return adjacency matrix[V,V]\ndef create_adjacency_matrix(edges, n_nodes, n_edge_types): # 我感觉应该就是一个点的in边 和 out边都记录了\n a = np.zeros([n_nodes, n_nodes * n_edge_types * 2])\n for edge in edges:\n src_idx = edge[0]\n e_type = edge[1]\n tgt_idx = edge[2]\n a[tgt_idx - 1][(e_type - 1) * n_nodes + src_idx - 1] = 1\n a[src_idx - 1][(e_type - 1 + n_edge_types) * n_nodes + tgt_idx - 1] = 1\n return a\n\n\nclass bAbIDataset():\n \"\"\"\n Load bAbI tasks for GGNN\n \"\"\"\n\n def __init__(self, path, task_id, is_train,node_number,how_many:int):\n self.n_edge_types = 1\n self.n_tasks = 1\n all_data, self.n_node = load_graphs_from_file(path,how_many)\n all_task_train_data, all_task_val_data, all_task_test_data = split_set(all_data)\n\n if is_train == \"t\":\n print(\"prepare train data\")\n all_task_train_data = data_convert(all_task_train_data, 1, self.n_node)\n self.data = all_task_train_data[task_id]\n \n elif is_train == \"v\":\n print(\"prepare validation data\")\n self.n_node = node_number\n all_task_val_data = data_convert(all_task_val_data, 1, self.n_node)\n self.data = all_task_val_data[task_id]\n else:\n print(\"prepare test data\")\n self.n_node = node_number\n all_task_test_data = data_convert(all_task_test_data, 1, self.n_node)\n self.data = all_task_test_data[task_id]\n \n \n\n def __getitem__(self, index):\n am = create_adjacency_matrix(self.data[index][0], self.n_node, self.n_edge_types)\n annotation = self.data[index][1]\n target = self.data[index][2]\n max_node_of_one_graph = self.data[index][3] # my: list , his: int\n return am, annotation, target, max_node_of_one_graph\n\n def __len__(self):\n return len(self.data)\n\n\nif __name__ == \"__main__\":\n train_dataset = bAbIDataset(\"\", 0, True)\n am, annotation, target, max_node_of_one_graph= train_dataset.__getitem__(0)\n print(\"am\", am) # [v,v]\n print(\"annotation\", annotation) # [v,1]\n print(\"target\", target) #[v*v]\n\n## 写文档！"
] | [
[
"torch.nn.SmoothL1Loss",
"torch.manual_seed",
"torch.nn.L1Loss",
"torch.cuda.manual_seed_all",
"torch.nn.MSELoss"
],
[
"numpy.array",
"numpy.zeros"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
sbl1996/pytorch-hrvvi-ext | [
"f19abcbedd844a700b2e2596dd817ea80cbb6287",
"f19abcbedd844a700b2e2596dd817ea80cbb6287",
"f19abcbedd844a700b2e2596dd817ea80cbb6287"
] | [
"horch/legacy/models/detection/enhance.py",
"horch/models/cifar/testnet2.py",
"horch/models/nas/cifar/darts.py"
] | [
"import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom horch.common import tuplify\nfrom horch.models.block import mb_conv_block, MBConv\nfrom horch.models.detection.nasfpn import ReLUConvBN\n\nfrom horch.models.modules import upsample_add, Conv2d, Sequential, Pool2d, upsample_concat\nfrom horch.models.detection.nasfpn import NASFPN\nfrom horch.models.utils import remove_stride_padding\n\n\nclass TopDown(nn.Module):\n def __init__(self, in_channels, f_channels, lite=False, aggregate='add'):\n super().__init__()\n self.aggregate = aggregate\n self.lat = Conv2d(\n in_channels, f_channels, kernel_size=1,\n norm='default')\n channels = f_channels * 2 if aggregate == 'cat' else f_channels\n self.conv = Conv2d(\n channels, f_channels, kernel_size=5 if lite else 3,\n norm='default', act='default', depthwise_separable=lite)\n\n def forward(self, c, p):\n if self.aggregate == 'cat':\n p = upsample_concat(p, self.lat(c))\n else:\n p = upsample_add(p, self.lat(c))\n p = self.conv(p)\n return p\n\n\nclass DeconvTopDown(nn.Module):\n def __init__(self, in_channels1, in_channels2, f_channels, lite=False, aggregate='add'):\n super().__init__()\n self.aggregate = aggregate\n self.lat = Conv2d(\n in_channels1, f_channels, kernel_size=1,\n norm='default')\n self.deconv = Conv2d(in_channels2, f_channels, kernel_size=4, stride=2,\n norm='default', depthwise_separable=lite, transposed=True)\n channels = f_channels * 2 if aggregate == 'cat' else f_channels\n self.conv = Conv2d(\n channels, f_channels, kernel_size=5 if lite else 3,\n norm='default', act='default', depthwise_separable=lite)\n\n def forward(self, c, p):\n if self.aggregate == 'cat':\n p = torch.cat([self.lat(c), self.deconv(p)], dim=1)\n else:\n p = self.lat(c) + self.deconv(p)\n p = self.conv(p)\n return p\n\n\nclass FPNExtraLayers(nn.Module):\n def __init__(self, in_channels, extra_layers=(6, 7), f_channels=None, downsample='conv', lite=False):\n super().__init__()\n self.extra_layers = nn.ModuleList([])\n for _ in extra_layers:\n if downsample == 'conv':\n l = ReLUConvBN(in_channels, f_channels, stride=2, lite=lite)\n elif downsample == 'maxpool':\n l = Pool2d('max', kernel_size=1, stride=2)\n elif downsample == 'avgpool':\n l = Pool2d('avg', kernel_size=1, stride=2)\n else:\n raise ValueError(\"%s as downsampling is invalid.\" % downsample)\n in_channels = f_channels\n self.extra_layers.append(l)\n\n def forward(self, p):\n ps = []\n for l in self.extra_layers:\n p = l(p)\n ps.append(p)\n return tuple(ps)\n\n\nclass BasicBlock(nn.Sequential):\n def __init__(self, in_channels, out_channels):\n super().__init__()\n self.conv1 = Conv2d(in_channels, out_channels // 2, kernel_size=1,\n norm='default', act='default')\n self.conv2 = Conv2d(out_channels // 2, out_channels, kernel_size=3, stride=2,\n norm='default', act='default')\n\n\nclass ExtraLayers(nn.Module):\n def __init__(self, in_channels_list, num_extra_layers=3, f_channels_list=(512, 256, 256), no_padding=0, block=BasicBlock, **kwargs):\n super().__init__()\n f_channels_list = tuplify(f_channels_list, num_extra_layers)\n in_channels_list = list(in_channels_list)\n self.extra_layers = nn.ModuleList([])\n for f_channels in f_channels_list:\n l = block(in_channels_list[-1], f_channels, **kwargs)\n self.extra_layers.append(l)\n in_channels_list.append(f_channels)\n\n for i in range(no_padding, 0):\n remove_stride_padding(self.extra_layers[i])\n\n self.out_channels = in_channels_list\n\n def forward(self, *cs):\n ps = list(cs)\n for l in self.extra_layers:\n ps.append(l(ps[-1]))\n return tuple(ps)\n\n\nclass SSDExtraLayers(ExtraLayers):\n def __init__(self, in_channels_list, num_extra_layers=3, f_channels_list=(512, 256, 256), no_padding=-1):\n super().__init__(\n in_channels_list,\n num_extra_layers,\n f_channels_list,\n no_padding,\n BasicBlock\n )\n\n\nclass SSDLiteExtraLayers(ExtraLayers):\n def __init__(self, in_channels_list, num_extra_layers=3, f_channels_list=(512, 256, 256), no_padding=-1, kernel_size=3):\n super().__init__(\n in_channels_list,\n num_extra_layers,\n f_channels_list,\n no_padding,\n mb_conv_block,\n expand_ratio=4,\n kernel_size=kernel_size\n )\n\n\nclass FPN(nn.Module):\n r\"\"\"\n Feature Pyramid Network which enhance features of different levels.\n\n Parameters\n ----------\n in_channels_list : sequence of ints\n Number of input channels of every level, e.g., ``(256,512,1024)``\n f_channels : int\n Number of output channels.\n extra_layers : tuple of ints\n Extra layers to add, e.g., ``(6, 7)``\n lite : bool\n Whether to replace conv3x3 with depthwise seperable conv.\n Default: False\n upsample : str\n Use bilinear upsampling when `interpolate` and ConvTransposed when `deconv`\n Default: `interpolate`\n \"\"\"\n\n def __init__(self, in_channels_list, f_channels=256, extra_layers=(), downsample='conv', lite=False,\n upsample='interpolate', aggregate='add'):\n super().__init__()\n self.lat = Conv2d(in_channels_list[-1], f_channels, kernel_size=1, norm='default')\n self.extra_layers = extra_layers\n if extra_layers:\n self.extras = FPNExtraLayers(f_channels, extra_layers, f_channels, downsample=downsample, lite=lite)\n if upsample == 'deconv':\n self.topdowns = nn.ModuleList([\n DeconvTopDown(c, f_channels, f_channels, lite=lite, aggregate=aggregate)\n for c in in_channels_list[:-1]\n ])\n else:\n self.topdowns = nn.ModuleList([\n TopDown(c, f_channels, lite=lite, aggregate=aggregate)\n for c in in_channels_list[:-1]\n ])\n self.out_channels = [f_channels] * (len(in_channels_list) + len(extra_layers))\n\n def forward(self, *cs):\n p = self.lat(cs[-1])\n ps = (p,)\n if self.extra_layers:\n ps = ps + self.extras(p)\n for c, topdown in zip(reversed(cs[:-1]), reversed(self.topdowns)):\n p = topdown(c, ps[0])\n ps = (p,) + ps\n return ps\n\n\nclass BottomUp(nn.Module):\n def __init__(self, f_channels, lite=False):\n super().__init__()\n self.down = Conv2d(\n f_channels, f_channels, kernel_size=3, stride=2,\n norm='default', act='default', depthwise_separable=lite)\n self.conv = Conv2d(\n f_channels, f_channels, kernel_size=3,\n norm='default', act='default', depthwise_separable=lite)\n\n def forward(self, p, n):\n n = p + self.down(n)\n n = self.conv(n)\n return n\n\n\nclass FPN2(nn.Module):\n r\"\"\"\n Bottom-up path augmentation.\n\n Parameters\n ----------\n in_channels_list : sequence of ints\n Number of input channels of every level, e.g., ``(256,256,256)``\n Notice: they must be the same.\n f_channels : int\n Number of output channels.\n \"\"\"\n\n def __init__(self, in_channels_list, f_channels, lite=False):\n super().__init__()\n assert len(set(in_channels_list)) == 1, \"Input channels of every level must be the same\"\n assert in_channels_list[0] == f_channels, \"Input channels must be the same as `f_channels`\"\n self.bottomups = nn.ModuleList([\n BottomUp(f_channels, lite=lite)\n for _ in in_channels_list[1:]\n ])\n self.out_channels = [f_channels] * len(in_channels_list)\n\n def forward(self, *ps):\n ns = [ps[0]]\n for p, bottomup in zip(ps[1:], self.bottomups):\n n = bottomup(p, ns[-1])\n ns.append(n)\n return tuple(ns)\n\n\nclass ContextEnhance(nn.Module):\n def __init__(self, in_channels, out_channels):\n super().__init__()\n self.lats = nn.ModuleList([\n Conv2d(c, out_channels, kernel_size=1, norm='default')\n for c in in_channels\n ])\n self.lat_glb = Conv2d(in_channels[-1], out_channels, kernel_size=1,\n norm='default')\n\n def forward(self, *cs):\n size = cs[0].size()[2:4]\n p = self.lats[0](cs[0])\n for c, lat in zip(cs[1:], self.lats[1:]):\n p += F.interpolate(lat(c), size=size, mode='bilinear', align_corners=False)\n c_glb = F.adaptive_avg_pool2d(cs[-1], 1)\n p_glb = self.lat_glb(c_glb)\n p += p_glb\n return p\n\n\ndef stacked_fpn(num_stacked, in_channels_list, extra_layers=(), f_channels=256, lite=False, upsample='interpolate'):\n r\"\"\"\n Stacked FPN with alternant top down block and bottom up block.\n\n Parameters\n ----------\n num_stacked : int\n Number of stacked fpns.\n in_channels_list : sequence of ints\n Number of input channels of every level, e.g., ``(128,256,512)``\n extra_layers : tuple of ints\n Extra layers to add, e.g., ``(6, 7)``\n f_channels : int\n Number of feature (output) channels.\n Default: 256\n lite : bool\n Whether to replace conv3x3 with depthwise seperable conv.\n Default: False\n upsample : str\n Use bilinear upsampling if `interpolate` and ConvTransposed if `deconv`\n Default: `interpolate`\n \"\"\"\n assert num_stacked >= 2, \"Use FPN directly if `num_stacked` is smaller than 2.\"\n layers = [FPN(in_channels_list, f_channels, extra_layers, lite=lite, upsample=upsample)]\n for i in range(1, num_stacked):\n if i % 2 == 0:\n layers.append(FPN(layers[-1].out_channels, f_channels, lite=lite, upsample=upsample))\n else:\n layers.append(FPN2(layers[-1].out_channels, f_channels, lite=lite))\n m = Sequential(*layers)\n m.out_channels = m[-1].out_channels\n return m\n\n\ndef stacked_nas_fpn(num_stacked, in_channels_list, extra_layers=(), f_channels=256, lite=False, upsample='interpolate'):\n r\"\"\"\n Stacked FPN with alternant top down block and bottom up block.\n\n Parameters\n ----------\n num_stacked : int\n Number of stacked fpns.\n in_channels_list : sequence of ints\n Number of input channels of every level, e.g., ``(128,256,512)``\n extra_layers : tuple of ints\n Extra layers to add, e.g., ``(6, 7)``\n f_channels : int\n Number of feature (output) channels.\n Default: 256\n lite : bool\n Whether to replace conv3x3 with depthwise seperable conv.\n Default: False\n upsample : str\n Use bilinear upsampling if `interpolate` and ConvTransposed if `deconv`\n Default: `interpolate`\n \"\"\"\n assert num_stacked >= 2, \"Use FPN directly if `num_stacked` is smaller than 2.\"\n layers = [FPN(in_channels_list, f_channels, extra_layers, downsample='maxpool', lite=lite, upsample=upsample)]\n for i in range(1, num_stacked):\n layers.append(NASFPN(f_channels))\n m = Sequential(*layers)\n m.out_channels = m[-1].out_channels\n return m\n\n\nclass IDA(nn.Module):\n def __init__(self, in_channels_list, f_channels, lite=False):\n super().__init__()\n self.num_levels = len(in_channels_list)\n self.topdowns = nn.ModuleList([\n DeconvTopDown(in_channels_list[i], in_channels_list[i + 1], f_channels, lite=lite)\n for i in range(self.num_levels - 1)\n ])\n if self.num_levels > 2:\n self.deep = IDA([f_channels] * (self.num_levels - 1), f_channels)\n\n def forward(self, *xs):\n xs = [\n l(xs[i], xs[i + 1]) for i, l in enumerate(self.topdowns)\n ]\n if self.num_levels > 2:\n return self.deep(*xs)\n else:\n return xs[0]\n\n\nclass IDA2(nn.Module):\n def __init__(self, in_channels, lite=False):\n super().__init__()\n self.num_levels = len(in_channels)\n self.topdowns = nn.ModuleList([\n DeconvTopDown(in_channels[i], in_channels[i + 1], in_channels[i + 1], lite=lite)\n for i in range(self.num_levels - 1)\n ])\n if self.num_levels > 2:\n self.deep = IDA2(in_channels[1:], lite=lite)\n\n def forward(self, *xs):\n xs = [\n l(xs[i], xs[i + 1]) for i, l in enumerate(self.topdowns)\n ]\n if self.num_levels > 2:\n return self.deep(*xs)\n else:\n return xs[0]\n\n\nclass YOLOFPN(nn.Module):\n def __init__(self, in_channels_list, f_channels_list=(256, 512, 1024), kernel_size=5):\n super().__init__()\n assert len(in_channels_list) == len(f_channels_list)\n num_levels = len(in_channels_list)\n self.convs = nn.ModuleList([])\n self.lats = nn.ModuleList([])\n self.outs = nn.ModuleList([])\n for i in range(num_levels):\n f_channels = f_channels_list[-(i+1)]\n in_channels = in_channels_list[-(i+1)]\n if i == 0:\n self.convs.append(nn.Sequential(\n MBConv(in_channels, in_channels, f_channels // 4, kernel_size=kernel_size),\n MBConv(f_channels // 4, f_channels, f_channels // 4, kernel_size=kernel_size),\n ))\n else:\n self.lats.append(Conv2d(f_channels_list[-i] // 4, f_channels // 4, kernel_size=1,\n norm='default'))\n self.convs.append(nn.Sequential(\n MBConv(in_channels + f_channels // 4, in_channels + f_channels // 4, f_channels // 4, kernel_size=kernel_size),\n MBConv(f_channels // 4, f_channels, f_channels // 4, kernel_size=kernel_size),\n ))\n self.outs.append(MBConv(f_channels // 4, f_channels, None, kernel_size=kernel_size))\n\n self.out_channels = tuple(f_channels_list)\n\n def forward(self, *cs):\n ps = []\n p1 = self.convs[0](cs[-1])\n p2 = self.outs[0](p1)\n ps.append(p2)\n for lat, conv, out, c in zip(self.lats, self.convs[1:], self.outs[1:], reversed(cs[:-1])):\n c = upsample_concat(lat(p1), c)\n p1 = conv(c)\n p2 = out(p1)\n ps.append(p2)\n return tuple(reversed(ps))\n\n\n",
"import torch.nn as nn\nfrom horch.models.layers import Conv2d, Norm, Act, Linear\nfrom horch.nn import GlobalAvgPool\n\n\nclass PreActResBlock(nn.Module):\n def __init__(self, in_channels, out_channels, stride=1, depthwise=True):\n super().__init__()\n self.layers = nn.Sequential(\n Norm(in_channels),\n Act(),\n Conv2d(in_channels, out_channels, kernel_size=1),\n Norm(out_channels),\n Act(),\n Conv2d(out_channels, out_channels, kernel_size=3, stride=stride,\n groups=out_channels if depthwise else 1),\n Norm(out_channels),\n Act(),\n Conv2d(out_channels, out_channels, kernel_size=1),\n )\n\n if in_channels != out_channels or stride != 1:\n self.shortcut = Conv2d(in_channels, out_channels, kernel_size=1, stride=stride)\n else:\n self.shortcut = nn.Identity()\n\n def forward(self, x):\n return self.shortcut(x) + self.layers(x)\n\n\nclass ResNet(nn.Module):\n stages = [16, 16, 32, 64]\n\n def __init__(self, depth, k, num_classes=10, depthwise=True):\n super().__init__()\n num_blocks = (depth - 4) // 6\n self.stem = Conv2d(3, self.stages[0], kernel_size=3)\n\n self.layer1 = self._make_layer(\n self.stages[0] * 1, self.stages[1] * k, num_blocks, stride=1, depthwise=depthwise)\n self.layer2 = self._make_layer(\n self.stages[1] * k, self.stages[2] * k, num_blocks, stride=2, depthwise=depthwise)\n self.layer3 = self._make_layer(\n self.stages[2] * k, self.stages[3] * k, num_blocks, stride=2, depthwise=depthwise)\n\n self.norm = Norm(self.stages[3] * k)\n self.act = Act()\n self.avgpool = GlobalAvgPool()\n self.fc = Linear(self.stages[3] * k, num_classes)\n\n def _make_layer(self, in_channels, out_channels, blocks, stride, depthwise):\n layers = [PreActResBlock(in_channels, out_channels, stride=stride, depthwise=depthwise)]\n for i in range(1, blocks):\n layers.append(\n PreActResBlock(out_channels, out_channels, depthwise=depthwise))\n return nn.Sequential(*layers)\n\n def forward(self, x):\n x = self.stem(x)\n\n x = self.layer1(x)\n x = self.layer2(x)\n x = self.layer3(x)\n\n x = self.norm(x)\n x = self.act(x)\n\n x = self.avgpool(x)\n x = self.fc(x)\n return x",
"from toolz.curried import concat\n\nimport torch\nimport torch.nn as nn\n\nfrom horch.nn import DropPath, GlobalAvgPool\nfrom horch.models.layers import Act, Pool2d, Conv2d, Linear\n\nfrom horch.models.nas.genotypes import Genotype\nfrom horch.models.nas.operations import FactorizedReduce, ReLUConvBN, OPS\n\n\ndef standardize(genotype: Genotype):\n if len(genotype.normal[0]) == 2:\n assert all(len(c) == 2 for c in genotype.normal)\n n = len(genotype.normal) // 2\n op_indices = concat([(i, i) for i in range(2, 2 + n)])\n op_names, indices = zip(*genotype.normal)\n normal = list(zip(op_names, op_indices, indices))\n\n assert all(len(c) == 2 for c in genotype.reduce)\n n = len(genotype.reduce) // 2\n op_indices = concat([(i, i) for i in range(2, 2 + n)])\n op_names, indices = zip(*genotype.reduce)\n reduce = list(zip(op_names, op_indices, indices))\n else:\n normal = genotype.normal\n reduce = genotype.reduce\n normal = sorted(normal, key=lambda c: (c[1], c[2]))\n reduce = sorted(reduce, key=lambda c: (c[1], c[2]))\n return Genotype(\n normal=normal, normal_concat=genotype.normal_concat,\n reduce=reduce, reduce_concat=genotype.reduce_concat)\n\n\nclass Cell(nn.Module):\n\n def __init__(self, genotype, C_prev_prev, C_prev, C, reduction, reduction_prev, drop_path):\n super().__init__()\n genotype = standardize(genotype)\n self.drop_path = drop_path\n if reduction_prev:\n self.preprocess0 = FactorizedReduce(C_prev_prev, C)\n else:\n self.preprocess0 = ReLUConvBN(C_prev_prev, C, 1, 1)\n self.preprocess1 = ReLUConvBN(C_prev, C, 1, 1)\n\n if reduction:\n op_names, op_indices, indices = zip(*genotype.reduce)\n concat = genotype.reduce_concat\n else:\n op_names, op_indices, indices = zip(*genotype.normal)\n concat = genotype.normal_concat\n self._compile(C, op_names, op_indices, indices, concat, reduction)\n\n def _compile(self, C, op_names, op_indices, indices, concat, reduction):\n self._concat = concat\n self.multiplier = len(concat)\n\n self._ops = nn.ModuleList()\n self._indices = []\n prev_op_index = 1\n for name, op_index, index in zip(op_names, op_indices, indices):\n if op_index != prev_op_index:\n self._ops.append(nn.ModuleList())\n self._indices.append([])\n\n stride = 2 if reduction and index < 2 else 1\n op = OPS[name](C, stride)\n\n if self.drop_path and not isinstance(op, nn.Identity):\n op = nn.Sequential(\n op,\n DropPath(self.drop_path),\n )\n\n self._ops[-1].append(op)\n self._indices[-1].append(index)\n prev_op_index = op_index\n\n def forward(self, s0, s1):\n s0 = self.preprocess0(s0)\n s1 = self.preprocess1(s1)\n\n states = [s0, s1]\n for ops, indices in zip(self._ops, self._indices):\n s = sum([op(states[index]) for op, index in zip(ops, indices)])\n states.append(s)\n return torch.cat([states[i] for i in self._concat], dim=1)\n\n\nclass AuxiliaryHeadCIFAR(nn.Module):\n\n def __init__(self, C, num_classes):\n \"\"\"assuming input size 8x8\"\"\"\n super().__init__()\n self.features = nn.Sequential(\n Act('relu', inplace=True),\n Pool2d(5, stride=3, padding=0, type='avg'),\n Conv2d(C, 128, 1, norm='def', act='relu'),\n Conv2d(128, 768, 2, norm='def', act='relu', padding=0),\n )\n self.classifier = nn.Sequential(\n GlobalAvgPool(),\n Linear(768, num_classes),\n )\n\n def forward(self, x):\n x = self.features(x)\n x = self.classifier(x)\n return x\n\n\nclass DARTS(nn.Module):\n\n def __init__(self, C, layers, auxiliary, drop_path, num_classes, genotype):\n super().__init__()\n self._num_layers = layers\n self._auxiliary = auxiliary\n self._drop_path = drop_path\n\n stem_multiplier = 3\n C_curr = stem_multiplier * C\n self.stem = Conv2d(3, C_curr, 3, norm='def')\n\n C_prev_prev, C_prev, C_curr = C_curr, C_curr, C\n self.cells = nn.ModuleList()\n reduction_prev = False\n for i in range(layers):\n if i in [layers // 3, 2 * layers // 3]:\n C_curr *= 2\n reduction = True\n else:\n reduction = False\n cell = Cell(genotype, C_prev_prev, C_prev, C_curr, reduction, reduction_prev, drop_path)\n reduction_prev = reduction\n self.cells.append(cell)\n C_prev_prev, C_prev = C_prev, cell.multiplier * C_curr\n if auxiliary and i == 2 * layers // 3:\n C_to_auxiliary = C_prev\n\n if auxiliary:\n self.auxiliary_head = AuxiliaryHeadCIFAR(C_to_auxiliary, num_classes)\n self.classifier = nn.Sequential(\n GlobalAvgPool(),\n Linear(C_prev, num_classes),\n )\n\n def forward(self, x):\n s0 = s1 = self.stem(x)\n for i, cell in enumerate(self.cells):\n s0, s1 = s1, cell(s0, s1)\n if self._auxiliary and i == 2 * self._num_layers // 3:\n logits_aux = self.auxiliary_head(s1)\n logits = self.classifier(s1)\n if self._auxiliary and self.training:\n return logits, logits_aux\n else:\n return logits\n"
] | [
[
"torch.nn.ModuleList",
"torch.nn.functional.adaptive_avg_pool2d"
],
[
"torch.nn.Sequential",
"torch.nn.Identity"
],
[
"torch.nn.ModuleList",
"torch.cat"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
dvorotnev/NNEF-Tools | [
"0219a509c34bb5b291bee497cbd658d6a5922171",
"0219a509c34bb5b291bee497cbd658d6a5922171"
] | [
"nnef_tools/io/tf/graphdef/reader.py",
"nnef_tests/conversion/onnx_test.py"
] | [
"# Copyright (c) 2020 The Khronos Group Inc.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nfrom __future__ import division, print_function, absolute_import\n\nfrom collections import namedtuple\nfrom ....model import *\nfrom ....utils.types import as_str\nfrom .protobuf import *\nimport numpy as np\nimport six\n\n\nFunction = namedtuple('Function', ['name', 'attrs'])\n\n\n_DtypeToNumpy = {\n 'DT_INVALID': None,\n 'DT_RESOURCE': np.dtype([('resource', np.int32)]),\n 'DT_HALF': np.float16,\n 'DT_FLOAT': np.float32,\n 'DT_DOUBLE': np.float64,\n 'DT_INT8': np.int8,\n 'DT_INT16': np.int16,\n 'DT_INT32': np.int32,\n 'DT_INT64': np.int64,\n 'DT_UINT8': np.uint8,\n 'DT_UINT16': np.uint16,\n 'DT_UINT32': np.uint32,\n 'DT_UINT64': np.uint64,\n 'DT_BOOL': np.bool,\n 'DT_STRING': np.str,\n 'DT_COMPLEX64': np.complex64,\n 'DT_COMPLEX128': np.complex128,\n}\n\n\ndef _get_shape(shape_proto):\n return tuple(int(dim.size) if dim.size >= 0 else None for dim in shape_proto.dim) \\\n if not shape_proto.unknown_rank else None\n\n\ndef _get_dtype(dtype_enum):\n dtype = _DtypeToNumpy[DataType.Name(dtype_enum)]\n assert dtype is not None, \"non-numeric dtype '{}' in attribute\".format(DataType.Name(dtype_enum))\n return dtype\n\n\ndef _get_nonempty_items(message, fields):\n for field in fields:\n items = getattr(message, field)\n if len(items):\n return field, items\n\n return None, None\n\n\ndef _get_tensor(tensor_proto):\n shape = _get_shape(tensor_proto.tensor_shape)\n dtype = _get_dtype(tensor_proto.dtype)\n\n if len(tensor_proto.tensor_content):\n data = np.frombuffer(tensor_proto.tensor_content, dtype=dtype).reshape(shape)\n else:\n field, items = _get_nonempty_items(tensor_proto,\n fields=['half_val', 'float_val', 'double_val', 'int_val', 'int64_val',\n 'bool_val', 'string_val', 'uint32_val', 'uint64_val',\n 'resource_handle_val', 'scomplex_val', 'dcomplex_val'])\n assert items is not None, \"tensor items are empty, dtype = {}\".format(dtype)\n\n items = [item for item in items]\n if len(items) == int(np.prod(shape)):\n data = np.array(items, dtype=dtype).reshape(shape)\n else:\n assert len(items) == 1\n data = np.full(shape=shape, dtype=dtype, fill_value=items[0])\n\n return data\n\n\ndef _get_func(name_attrlist_proto):\n return Function(name_attrlist_proto.name, _get_attributes(name_attrlist_proto.attr))\n\n\ndef _get_attribute(field, value):\n if field == 'i' or field == 'f' or field == 'b' or field == 'placeholder':\n return value\n elif field == 's':\n return as_str(value.decode())\n elif field == 'shape':\n return _get_shape(value)\n elif field == 'type':\n return _get_dtype(value)\n elif field == 'tensor':\n return _get_tensor(value)\n elif field == 'func':\n return _get_func(value)\n elif field == 'list':\n field, items = _get_nonempty_items(value, fields=['i', 'f', 'b', 's', 'shape', 'type', 'tensor', 'func'])\n return [_get_attribute(field, item) for item in items] if items is not None else []\n\n assert False\n\n\ndef _get_attributes(attr_map_proto):\n attributes = {}\n for name, value in attr_map_proto.items():\n field = value.WhichOneof('value')\n if field is not None:\n value = getattr(value, field)\n attributes[as_str(name)] = _get_attribute(field, value)\n else:\n attributes[as_str(name)] = None\n\n return attributes\n\n\ndef _get_output_name(node_name, idx):\n return node_name + ':' + str(idx) if idx > 0 else node_name\n\n\ndef _has_output_shapes(graph_def):\n return all('_output_shapes' in node.attr and node.attr['_output_shapes'].WhichOneof('value') is not None\n for node in graph_def.node)\n\n\ndef _add_output_shapes(graph_def):\n try:\n import tensorflow.compat.v1 as tf\n except ImportError:\n import tensorflow as tf\n\n tf.import_graph_def(graph_def, name='')\n return tf.get_default_graph().as_graph_def(add_shapes=True)\n\n\ndef _get_dtypes(graph_def):\n try:\n import tensorflow.compat.v1 as tf\n except ImportError:\n import tensorflow as tf\n\n dtypes = {}\n\n graph = tf.Graph()\n with graph.as_default():\n tf.import_graph_def(graph_def, name='')\n for op in graph.get_operations():\n for tensor in op.outputs:\n name = tensor.name[:-2] if tensor.name.endswith(':0') else tensor.name\n dtypes[name] = tensor.dtype.as_numpy_dtype if tensor.dtype != tf.resource else _DtypeToNumpy['DT_RESOURCE'].type\n\n return dtypes\n\n\ndef _get_output_shapes(attr_map_proto):\n value = attr_map_proto['_output_shapes']\n field = value.WhichOneof('value')\n if field is None:\n return None\n\n value = getattr(value, field)\n return _get_attribute(field, value)\n\n\ndef build_graph(graph_def):\n graph = Graph()\n\n dtypes = _get_dtypes(graph_def)\n\n # create tensors\n node_outputs = {}\n for node in graph_def.node:\n output_shapes = _get_output_shapes(node.attr)\n if output_shapes is not None:\n name = as_str(node.name)\n node_outputs[name] = [Tensor(graph, _get_output_name(name, idx), shape=shape, dtype=dtypes.get(name))\n for idx, shape in enumerate(output_shapes)]\n\n tensors = {tensor.name: tensor for outputs in six.itervalues(node_outputs) for tensor in outputs}\n\n # create ops\n for node in graph_def.node:\n attributes = _get_attributes(node.attr)\n inputs = [tensors[name] for name in node.input if not name.startswith('^')]\n outputs = node_outputs[node.name] if node.name in node_outputs else []\n\n Operation(graph,\n type=as_str(node.op),\n name=as_str(node.name),\n inputs=inputs,\n outputs=outputs,\n attribs=attributes)\n\n graph.inputs = [node_outputs[node.name][0] for node in graph_def.node if node.op == 'Placeholder']\n graph.outputs = [output for op in graph.operations if all(len(output.consumers) == 0 for output in op.outputs)\n for output in op.outputs]\n return graph\n\n\ndef _unpack_custom_ops(graph):\n for op in graph.operations:\n if op.type == 'PyFunc':\n op.custom = True\n op.type = op.attribs['token']\n op.attribs = {key[2:-2]: value for key, value in six.iteritems(op.attribs)\n if key.startswith('_$') and key.endswith('$_')}\n\n\ndef read_graphdef(filename, input_shapes, fold_constants):\n graph_def = GraphDef()\n with open(filename, 'rb') as file:\n graph_def.ParseFromString(file.read())\n\n if not _has_output_shapes(graph_def):\n graph_def = _add_output_shapes(graph_def)\n\n if input_shapes is not None:\n from .utils import set_input_shapes\n graph_def = set_input_shapes(graph_def, input_shapes)\n\n if fold_constants:\n from .utils import fold_constant_tensors\n graph_def = fold_constant_tensors(graph_def)\n\n graph = build_graph(graph_def)\n _unpack_custom_ops(graph)\n\n return graph\n\n\nclass Reader(object):\n\n def __init__(self, fold_constants=False):\n self._fold_constants = fold_constants\n\n def __call__(self, filename, input_shapes=None):\n return read_graphdef(filename, input_shapes, self._fold_constants)\n",
"# Copyright (c) 2020 The Khronos Group Inc.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport nnef_tools.io.nnef as nnef_io\nimport nnef_tools.io.onnx as onnx_io\nimport nnef_tools.conversion.onnx_to_nnef as onnx_to_nnef\nimport nnef_tools.conversion.nnef_to_onnx as nnef_to_onnx\nimport nnef_tools.optimization.nnef_optimizer as nnef_opt\nimport nnef_tools.optimization.onnx_optimizer as onnx_opt\nimport numpy as np\nimport unittest\nimport tempfile\nimport onnx\nfrom onnx import helper, TensorProto\nfrom onnx.mapping import NP_TYPE_TO_TENSOR_TYPE\n\n\nclass TestEnv(unittest.TestCase):\n\n _type_to_numpy = {\n \"tensor(float)\": np.float32,\n \"tensor(double)\": np.float64,\n \"tensor(int8)\": np.int8,\n \"tensor(int16)\": np.int16,\n \"tensor(int32)\": np.int32,\n \"tensor(int64)\": np.int64,\n \"tensor(uint8)\": np.uint8,\n \"tensor(uint16)\": np.uint16,\n \"tensor(uint32)\": np.uint32,\n \"tensor(uint64)\": np.uint64,\n \"tensor(bool)\": np.bool,\n }\n\n _network_folder = '/Users/viktor.gyenes/Khronos/unittest/onnx/nets/'\n _output_folder = '/Users/viktor.gyenes/Khronos/unittest/onnx/ops/'\n _optimize = True\n\n def setUp(self) -> None:\n self._onnx_reader = onnx_io.Reader(simplify=True)\n self._onnx_writer = onnx_io.Writer()\n self._onnx_to_nnef_converter = onnx_to_nnef.Converter()\n self._nnef_to_onnx_converter = nnef_to_onnx.Converter()\n self._nnef_reader = nnef_io.Reader(custom_shapes=self._nnef_to_onnx_converter.custom_shapes(),\n decomposed=self._nnef_to_onnx_converter.decomposed_operations())\n self._nnef_writer = nnef_io.Writer(fragments=self._onnx_to_nnef_converter.defined_operations())\n self._nnef_optimizer = nnef_opt.Optimizer()\n self._onnx_optimizer = onnx_opt.Optimizer()\n\n def tearDown(self) -> None:\n pass\n\n def _convert_to_nnef(self, filename):\n onnx_graph = self._onnx_reader(filename)\n if self._optimize:\n onnx_graph = self._onnx_optimizer(onnx_graph)\n nnef_graph = self._onnx_to_nnef_converter(onnx_graph)\n if self._optimize:\n nnef_graph = self._nnef_optimizer(nnef_graph)\n self._nnef_writer(nnef_graph, filename + '.nnef')\n\n def _convert_from_nnef(self, filename):\n nnef_graph = self._nnef_reader(filename)\n onnx_graph = self._nnef_to_onnx_converter(nnef_graph)\n self._onnx_writer(onnx_graph, filename + '.onnx')\n\n @staticmethod\n def _random_data(dtype, shape):\n if dtype == np.bool:\n return np.random.random(shape) > 0.5\n else:\n return np.random.random(shape).astype(dtype)\n\n @staticmethod\n def _exec_model(filename):\n import onnxruntime\n np.random.seed(0)\n\n options = onnxruntime.SessionOptions()\n options.inter_op_num_threads = 1\n options.intra_op_num_threads = 1\n options.graph_optimization_level = onnxruntime.GraphOptimizationLevel.ORT_DISABLE_ALL\n\n session = onnxruntime.InferenceSession(filename, sess_options=options)\n\n inputs = {input.name: TestEnv._random_data(TestEnv._type_to_numpy[input.type], input.shape)\n for input in session.get_inputs()}\n outputs = session.run([output.name for output in session.get_outputs()], inputs)\n\n return outputs\n\n @staticmethod\n def _create_tensor(value_info, data):\n name, shape, dtype = onnx_io.reader._get_value_info(value_info)\n if data is None:\n data = TestEnv._random_data(dtype, shape)\n elif not isinstance(data, np.ndarray):\n data = np.array(data)\n return helper.make_tensor(name, NP_TYPE_TO_TENSOR_TYPE[np.dtype(dtype)], shape, vals=data.flat)\n\n @staticmethod\n def _create_model(name, nodes, inputs, outputs, constants, values, opset_version, ir_version):\n tensors = [TestEnv._create_tensor(item, values.get(item.name)) for item in constants]\n graph_def = helper.make_graph(nodes, name, inputs, outputs, value_info=constants, initializer=tensors)\n model_def = helper.make_model(graph_def, producer_name='nnef-to-onnx-test')\n model_def.opset_import[0].version = opset_version\n model_def.ir_version = ir_version\n onnx.checker.check_model(model_def, full_check=True)\n return model_def\n\n @staticmethod\n def _save_model(model_def, filename):\n with open(filename, 'wb') as file:\n file.write(model_def.SerializeToString())\n\n def _test_conversion(self, name, nodes, inputs, outputs, constants=None, values=None, opset_version=11, ir_version=6, epsilon=1e-5):\n filename = tempfile.mktemp() if self._output_folder is None else TestEnv._output_folder + name + '.onnx'\n model_def = self._create_model('G', nodes, inputs, outputs, constants or [], values or {}, opset_version, ir_version)\n self._save_model(model_def, filename)\n self._test_conversion_from_file(filename, epsilon=epsilon)\n\n def _test_conversion_from_file(self, filename, epsilon=1e-5):\n self._convert_to_nnef(filename)\n self._convert_from_nnef(filename + '.nnef')\n\n original_outputs = self._exec_model(filename)\n converted_outputs = self._exec_model(filename + '.nnef.onnx')\n\n self.assertEqual(len(original_outputs), len(converted_outputs))\n for original, converted in zip(original_outputs, converted_outputs):\n if original.dtype == np.bool:\n self.assertTrue(np.all(original == converted))\n else:\n diff = np.max(np.abs(original - converted))\n self.assertLess(diff, epsilon)\n\n def _test_unary(self, op_type, dtype=TensorProto.FLOAT):\n input = helper.make_tensor_value_info('input', dtype, [1, 3, 32, 32])\n output = helper.make_tensor_value_info('output', dtype, [1, 3, 32, 32])\n node = helper.make_node(\n op_type=op_type,\n inputs=['input'],\n outputs=['output'],\n )\n\n self._test_conversion(op_type.lower(), [node], [input], [output])\n\n def _test_binary(self, op_type, input_dtype=TensorProto.FLOAT, output_dtype=TensorProto.FLOAT):\n input1 = helper.make_tensor_value_info('input1', input_dtype, [1, 3, 32, 32])\n input2 = helper.make_tensor_value_info('input2', input_dtype, [1, 3, 32, 32])\n output = helper.make_tensor_value_info('output', output_dtype, [1, 3, 32, 32])\n node = helper.make_node(\n op_type=op_type,\n inputs=['input1', 'input2'],\n outputs=['output'],\n )\n\n self._test_conversion(op_type.lower(), [node], [input1, input2], [output])\n\n def _test_reduce(self, op_type, keepdims, dtype=TensorProto.FLOAT, p=None):\n input = helper.make_tensor_value_info('input', dtype, [1, 16, 32, 32])\n output = helper.make_tensor_value_info('output', dtype, [1, 1, 32, 32] if keepdims else [1, 32, 32])\n node = helper.make_node(\n op_type=op_type,\n inputs=['input'],\n outputs=['output'],\n axes=[1],\n keepdims=keepdims,\n )\n\n self._test_conversion(op_type.lower(), [node], [input], [output])\n\n\nclass TestCases(TestEnv):\n\n def test_conv1d(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 3, 32])\n filter = helper.make_tensor_value_info('filter', TensorProto.FLOAT, [16, 3, 5])\n bias = helper.make_tensor_value_info('bias', TensorProto.FLOAT, [16])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 16, 32])\n node = helper.make_node(\n op_type='Conv',\n inputs=['input', 'filter', 'bias'],\n outputs=['output'],\n auto_pad='SAME_UPPER',\n )\n\n self._test_conversion('conv1d', [node], [input], [output], constants=[filter, bias])\n\n def test_conv2d(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 3, 32, 32])\n filter = helper.make_tensor_value_info('filter', TensorProto.FLOAT, [16, 3, 5, 5])\n bias = helper.make_tensor_value_info('bias', TensorProto.FLOAT, [16])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 16, 32, 32])\n node = helper.make_node(\n op_type='Conv',\n inputs=['input', 'filter', 'bias'],\n outputs=['output'],\n auto_pad='SAME_UPPER',\n )\n\n self._test_conversion('conv2d', [node], [input], [output], constants=[filter, bias])\n\n def test_conv2d_nobias(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 3, 32, 32])\n filter = helper.make_tensor_value_info('filter', TensorProto.FLOAT, [16, 3, 5, 5])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 16, 32, 32])\n node = helper.make_node(\n op_type='Conv',\n inputs=['input', 'filter'],\n outputs=['output'],\n auto_pad='SAME_UPPER',\n )\n\n self._test_conversion('conv2d-nobias', [node], [input], [output], constants=[filter])\n\n def test_conv2d_valid(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 3, 32, 32])\n filter = helper.make_tensor_value_info('filter', TensorProto.FLOAT, [16, 3, 5, 5])\n bias = helper.make_tensor_value_info('bias', TensorProto.FLOAT, [16])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 16, 28, 28])\n node = helper.make_node(\n op_type='Conv',\n inputs=['input', 'filter', 'bias'],\n outputs=['output'],\n auto_pad='VALID',\n )\n\n self._test_conversion('conv2d-valid', [node], [input], [output], constants=[filter, bias])\n\n def test_conv2d_pads(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 3, 32, 32])\n filter = helper.make_tensor_value_info('filter', TensorProto.FLOAT, [16, 3, 5, 5])\n bias = helper.make_tensor_value_info('bias', TensorProto.FLOAT, [16])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 16, 30, 30])\n node = helper.make_node(\n op_type='Conv',\n inputs=['input', 'filter', 'bias'],\n outputs=['output'],\n pads=[1, 1, 1, 1],\n )\n\n self._test_conversion('conv2d-pads', [node], [input], [output], constants=[filter, bias])\n\n def test_conv2d_same_lower(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 3, 32, 32])\n filter = helper.make_tensor_value_info('filter', TensorProto.FLOAT, [16, 3, 5, 5])\n bias = helper.make_tensor_value_info('bias', TensorProto.FLOAT, [16])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 16, 32, 32])\n node = helper.make_node(\n op_type='Conv',\n inputs=['input', 'filter', 'bias'],\n outputs=['output'],\n auto_pad=\"SAME_LOWER\",\n )\n\n self._test_conversion('conv2d-same-lower', [node], [input], [output], constants=[filter, bias])\n\n def test_conv2d_transpose(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 16, 32, 32])\n filter = helper.make_tensor_value_info('filter', TensorProto.FLOAT, [16, 3, 5, 5])\n bias = helper.make_tensor_value_info('bias', TensorProto.FLOAT, [3])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 3, 32, 32])\n node = helper.make_node(\n op_type='ConvTranspose',\n inputs=['input', 'filter', 'bias'],\n outputs=['output'],\n auto_pad='SAME_UPPER',\n )\n\n self._test_conversion('conv2d_transpose', [node], [input], [output], constants=[filter, bias])\n\n\n def test_conv2d_transpose_output_shape(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 16, 32, 32])\n filter = helper.make_tensor_value_info('filter', TensorProto.FLOAT, [16, 3, 5, 5])\n bias = helper.make_tensor_value_info('bias', TensorProto.FLOAT, [3])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 3, 32, 32])\n node = helper.make_node(\n op_type='ConvTranspose',\n inputs=['input', 'filter', 'bias'],\n outputs=['output'],\n auto_pad='SAME_UPPER',\n output_shape=[1, 3, 32, 32],\n )\n\n self._test_conversion('conv2d_transpose-output_shape', [node], [input], [output], constants=[filter, bias])\n\n\n def test_conv3d(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 3, 32, 32, 32])\n filter = helper.make_tensor_value_info('filter', TensorProto.FLOAT, [16, 3, 5, 5, 5])\n bias = helper.make_tensor_value_info('bias', TensorProto.FLOAT, [16])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 16, 32, 32, 32])\n node = helper.make_node(\n op_type='Conv',\n inputs=['input', 'filter', 'bias'],\n outputs=['output'],\n auto_pad='SAME_UPPER',\n )\n\n self._test_conversion('conv3d', [node], [input], [output], constants=[filter, bias])\n\n def test_max_pool1d(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 3, 32])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 3, 32])\n node = helper.make_node(\n op_type='MaxPool',\n inputs=['input'],\n outputs=['output'],\n kernel_shape=[3],\n auto_pad='SAME_UPPER',\n )\n\n self._test_conversion('max_pool1d', [node], [input], [output])\n\n def test_max_pool2d(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 3, 32, 32])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 3, 32, 32])\n node = helper.make_node(\n op_type='MaxPool',\n inputs=['input'],\n outputs=['output'],\n kernel_shape=[3, 3],\n auto_pad='SAME_UPPER',\n )\n\n self._test_conversion('max_pool2d', [node], [input], [output])\n\n def test_max_pool2d_valid(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 3, 32, 32])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 3, 30, 30])\n node = helper.make_node(\n op_type='MaxPool',\n inputs=['input'],\n outputs=['output'],\n kernel_shape=[3, 3],\n auto_pad='VALID',\n )\n\n self._test_conversion('max_pool2d-valid', [node], [input], [output])\n\n def test_max_pool2d_pads(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 3, 32, 32])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 3, 32, 32])\n node = helper.make_node(\n op_type='MaxPool',\n inputs=['input'],\n outputs=['output'],\n kernel_shape=[3, 3],\n pads=[1, 1, 1, 1],\n )\n\n self._test_conversion('max_pool2d-pads', [node], [input], [output])\n\n def test_max_pool3d(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 3, 32, 32, 32])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 3, 32, 32, 32])\n node = helper.make_node(\n op_type='MaxPool',\n inputs=['input'],\n outputs=['output'],\n kernel_shape=[3, 3, 3],\n auto_pad='SAME_UPPER',\n )\n\n self._test_conversion('max_pool3d', [node], [input], [output])\n\n def test_avg_pool2d(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 3, 32, 32])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 3, 32, 32])\n node = helper.make_node(\n op_type='AveragePool',\n inputs=['input'],\n outputs=['output'],\n kernel_shape=[3, 3],\n auto_pad='SAME_UPPER',\n )\n\n self._test_conversion('avg_pool2d', [node], [input], [output])\n\n def test_global_avg_pool2d(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 3, 32, 32])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 3, 1, 1])\n node = helper.make_node(\n op_type='GlobalAveragePool',\n inputs=['input'],\n outputs=['output'],\n )\n\n self._test_conversion('global_avg_pool2d', [node], [input], [output])\n\n def test_global_max_pool2d(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 3, 32, 32])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 3, 1, 1])\n node = helper.make_node(\n op_type='GlobalMaxPool',\n inputs=['input'],\n outputs=['output'],\n )\n\n self._test_conversion('global_max_pool2d', [node], [input], [output])\n\n def test_lp_pool2d(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 3, 32, 32])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 3, 32, 32])\n node = helper.make_node(\n op_type='LpPool',\n inputs=['input'],\n outputs=['output'],\n kernel_shape=[3, 3],\n auto_pad='SAME_UPPER',\n p=2,\n )\n\n self._test_conversion('lp_pool2d', [node], [input], [output])\n\n def test_global_lp_pool2d(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 3, 32, 32])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 3, 1, 1])\n node = helper.make_node(\n op_type='GlobalLpPool',\n inputs=['input'],\n outputs=['output'],\n p=2,\n )\n\n self._test_conversion('global_lp_pool2d', [node], [input], [output])\n\n def test_batch_norm(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 3, 32, 32])\n mean = helper.make_tensor_value_info('mean', TensorProto.FLOAT, [3])\n variance = helper.make_tensor_value_info('variance', TensorProto.FLOAT, [3])\n offset = helper.make_tensor_value_info('offset', TensorProto.FLOAT, [3])\n scale = helper.make_tensor_value_info('scale', TensorProto.FLOAT, [3])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 3, 32, 32])\n node = helper.make_node(\n op_type='BatchNormalization',\n inputs=['input', 'scale', 'offset', 'mean', 'variance'],\n outputs=['output'],\n )\n\n self._test_conversion('max_pool3d', [node], [input], [output], [mean, variance, offset, scale])\n\n def test_transpose(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 3, 32, 32])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 32, 32, 3])\n node = helper.make_node(\n op_type='Transpose',\n inputs=['input'],\n outputs=['output'],\n perm=[0, 2, 3, 1],\n )\n\n self._test_conversion('transpose', [node], [input], [output])\n\n def test_reshape(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 3, 32, 32])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 3 * 32 * 32])\n shape = helper.make_tensor_value_info('shape', TensorProto.INT64, [2])\n node = helper.make_node(\n op_type='Reshape',\n inputs=['input', 'shape'],\n outputs=['output'],\n )\n\n self._test_conversion('reshape', [node], [input, shape], [output], constants=[shape],\n values={'shape': [1, 3 * 32 * 32]})\n\n def test_flatten(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 3, 32, 32])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 3 * 32 * 32])\n node = helper.make_node(\n op_type='Flatten',\n inputs=['input'],\n outputs=['output'],\n axis=1,\n )\n\n self._test_conversion('flatten', [node], [input], [output])\n\n def test_squeeze(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 1, 32, 32])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 32, 32])\n node = helper.make_node(\n op_type='Squeeze',\n inputs=['input'],\n outputs=['output'],\n axes=[1],\n )\n\n self._test_conversion('squeeze', [node], [input], [output])\n\n def test_unsqueeze(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 32, 32])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 1, 32, 32])\n node = helper.make_node(\n op_type='Unsqueeze',\n inputs=['input'],\n outputs=['output'],\n axes=[1],\n )\n\n self._test_conversion('unsqueeze', [node], [input], [output])\n\n def test_matmul(self):\n input1 = helper.make_tensor_value_info('input1', TensorProto.FLOAT, [10, 20])\n input2 = helper.make_tensor_value_info('input2', TensorProto.FLOAT, [20, 30])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [10, 30])\n node = helper.make_node(\n op_type='MatMul',\n inputs=['input1', 'input2'],\n outputs=['output'],\n )\n\n self._test_conversion('matmul', [node], [input1, input2], [output])\n\n def test_gemm(self):\n input1 = helper.make_tensor_value_info('input1', TensorProto.FLOAT, [10, 20])\n input2 = helper.make_tensor_value_info('input2', TensorProto.FLOAT, [20, 30])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [10, 30])\n node = helper.make_node(\n op_type='Gemm',\n inputs=['input1', 'input2'],\n outputs=['output'],\n )\n\n self._test_conversion('gemm', [node], [input1, input2], [output])\n\n def test_linear(self):\n input1 = helper.make_tensor_value_info('input1', TensorProto.FLOAT, [10, 20])\n input2 = helper.make_tensor_value_info('input2', TensorProto.FLOAT, [30, 20])\n input3 = helper.make_tensor_value_info('input3', TensorProto.FLOAT, [30])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [10, 30])\n node = helper.make_node(\n op_type='Gemm',\n inputs=['input1', 'input2', 'input3'],\n outputs=['output'],\n transB=1,\n )\n\n self._test_conversion('linear', [node], [input1], [output], constants=[input2, input3])\n\n def test_lrn(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 16, 32, 32])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 16, 32, 32])\n node = helper.make_node(\n op_type='LRN',\n inputs=['input'],\n outputs=['output'],\n size=5,\n )\n\n self._test_conversion('lrn', [node], [input], [output])\n\n def test_concat(self):\n input1 = helper.make_tensor_value_info('input1', TensorProto.FLOAT, [1, 3, 32, 32])\n input2 = helper.make_tensor_value_info('input2', TensorProto.FLOAT, [1, 3, 32, 32])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 6, 32, 32])\n node = helper.make_node(\n op_type='Concat',\n inputs=['input1', 'input2'],\n outputs=['output'],\n axis=1,\n )\n\n self._test_conversion('concat', [node], [input1, input2], [output])\n\n def test_split(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 6, 32, 32])\n output1 = helper.make_tensor_value_info('output1', TensorProto.FLOAT, [1, 3, 32, 32])\n output2 = helper.make_tensor_value_info('output2', TensorProto.FLOAT, [1, 3, 32, 32])\n node = helper.make_node(\n op_type='Split',\n inputs=['input'],\n outputs=['output1', 'output2'],\n axis=1,\n split=[3, 3],\n )\n\n self._test_conversion('split', [node], [input], [output1, output2])\n\n def test_sum(self):\n input1 = helper.make_tensor_value_info('input1', TensorProto.FLOAT, [1, 3, 32, 32])\n input2 = helper.make_tensor_value_info('input2', TensorProto.FLOAT, [1, 3, 32, 32])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 3, 32, 32])\n node = helper.make_node(\n op_type='Sum',\n inputs=['input1', 'input2'],\n outputs=['output'],\n )\n\n self._test_conversion('sum', [node], [input1, input2], [output])\n\n def test_softmax(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 16, 32, 32])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 16, 32, 32])\n node = helper.make_node(\n op_type='Softmax',\n inputs=['input'],\n outputs=['output'],\n axis=1,\n )\n\n self._test_conversion('softmax', [node], [input], [output])\n\n def test_leaky_relu(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 16, 32, 32])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 16, 32, 32])\n node = helper.make_node(\n op_type='LeakyRelu',\n inputs=['input'],\n outputs=['output'],\n )\n\n self._test_conversion('leaky_relu', [node], [input], [output])\n\n def test_prelu(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 16, 32, 32])\n alpha = helper.make_tensor_value_info('alpha', TensorProto.FLOAT, [16, 1, 1])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 16, 32, 32])\n node = helper.make_node(\n op_type='PRelu',\n inputs=['input', 'alpha'],\n outputs=['output'],\n )\n\n self._test_conversion('prelu', [node], [input, alpha], [output])\n\n def test_where(self):\n cond = helper.make_tensor_value_info('cond', TensorProto.BOOL, [1, 1, 32, 32])\n input1 = helper.make_tensor_value_info('input1', TensorProto.FLOAT, [1, 3, 32, 32])\n input2 = helper.make_tensor_value_info('input2', TensorProto.FLOAT, [1, 3, 1, 1])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 3, 32, 32])\n node = helper.make_node(\n op_type='Where',\n inputs=['cond', 'input1', 'input2'],\n outputs=['output'],\n )\n\n self._test_conversion('where', [node], [cond, input1, input2], [output])\n\n def test_clip(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 3, 32, 32])\n min = helper.make_tensor_value_info('min', TensorProto.FLOAT, [])\n max = helper.make_tensor_value_info('max', TensorProto.FLOAT, [])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 3, 32, 32])\n node = helper.make_node(\n op_type='Clip',\n inputs=['input', 'min', 'max'],\n outputs=['output'],\n )\n\n self._test_conversion('clip', [node], [input, min, max], [output])\n\n def test_argmin(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 16, 32, 32])\n output = helper.make_tensor_value_info('output', TensorProto.INT64, [1, 1, 32, 32])\n node = helper.make_node(\n op_type='ArgMin',\n inputs=['input'],\n outputs=['output'],\n axis=1,\n keepdims=True,\n )\n\n self._test_conversion('argmin_reduce', [node], [input], [output])\n\n def test_argmax(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 16, 32, 32])\n output = helper.make_tensor_value_info('output', TensorProto.INT64, [1, 32, 32])\n node = helper.make_node(\n op_type='ArgMax',\n inputs=['input'],\n outputs=['output'],\n axis=1,\n keepdims=False,\n )\n\n self._test_conversion('argmax_reduce', [node], [input], [output])\n\n def test_pad(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 3, 32, 32])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 3, 34, 34])\n pads = helper.make_tensor_value_info('pads', TensorProto.INT64, [8])\n node = helper.make_node(\n op_type='Pad',\n inputs=['input', 'pads'],\n outputs=['output'],\n )\n\n self._test_conversion('pad', [node], [input], [output], constants=[pads],\n values={'pads': [0, 0, 1, 1, 0, 0, 1, 1]})\n\n def test_tile(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 3, 32, 32])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 3, 64, 64])\n repeats = helper.make_tensor_value_info('repeats', TensorProto.INT64, [4])\n node = helper.make_node(\n op_type='Tile',\n inputs=['input', 'repeats'],\n outputs=['output'],\n )\n\n self._test_conversion('tile', [node], [input], [output], constants=[repeats],\n values={'repeats': [1, 1, 2, 2]})\n\n def test_slice(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 3, 32, 32])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 3, 30, 30])\n starts = helper.make_tensor_value_info('starts', TensorProto.INT64, [2])\n ends = helper.make_tensor_value_info('ends', TensorProto.INT64, [2])\n axes = helper.make_tensor_value_info('axes', TensorProto.INT64, [2])\n node = helper.make_node(\n op_type='Slice',\n inputs=['input', 'starts', 'ends', 'axes'],\n outputs=['output'],\n )\n\n self._test_conversion('slice', [node], [input], [output], constants=[starts, ends, axes],\n values={'starts': [1, 1], 'ends': [-1, -1], 'axes': [2, 3]})\n\n def test_l1_normalization(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 16, 32, 32])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 16, 32, 32])\n node = helper.make_node(\n op_type='LpNormalization',\n inputs=['input'],\n outputs=['output'],\n axis=1,\n p=1,\n )\n\n self._test_conversion('l1_normalization', [node], [input], [output])\n\n def test_l2_normalization(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 16, 32, 32])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 16, 32, 32])\n node = helper.make_node(\n op_type='LpNormalization',\n inputs=['input'],\n outputs=['output'],\n axis=1,\n p=2,\n )\n\n self._test_conversion('l2_normalization', [node], [input], [output])\n\n def test_mean_variance_normalization(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 16, 32, 32])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 16, 32, 32])\n node = helper.make_node(\n op_type='MeanVarianceNormalization',\n inputs=['input'],\n outputs=['output'],\n axes=[2, 3],\n )\n\n self._test_conversion('mean_variance_normalization', [node], [input], [output])\n\n def test_instance_normalization(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 16, 32, 32])\n scale = helper.make_tensor_value_info('scale', TensorProto.FLOAT, [16])\n offset = helper.make_tensor_value_info('offset', TensorProto.FLOAT, [16])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 16, 32, 32])\n node = helper.make_node(\n op_type='InstanceNormalization',\n inputs=['input', 'scale', 'offset'],\n outputs=['output'],\n )\n\n self._test_conversion('instance_normalization', [node], [input], [output], constants=[scale, offset])\n\n def test_lp_reduce(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 16, 32, 32])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 1, 32, 32])\n node = helper.make_node(\n op_type='ReduceL1',\n inputs=['input'],\n outputs=['output'],\n axes=[1],\n keepdims=True,\n )\n\n self._test_conversion('lp_reduce', [node], [input], [output])\n\n def test_nearest_upsample(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 3, 32, 32])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 3, 64, 64])\n node = helper.make_node(\n op_type='Upsample',\n inputs=['input'],\n outputs=['output'],\n scales=[1.0, 1.0, 2.0, 2.0],\n mode='nearest',\n )\n\n self._test_conversion('nearest_upsample', [node], [input], [output], opset_version=8)\n\n def test_linear_upsample(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 3, 32, 32])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 3, 64, 64])\n node = helper.make_node(\n op_type='Upsample',\n inputs=['input'],\n outputs=['output'],\n scales=[1.0, 1.0, 2.0, 2.0],\n mode='linear',\n )\n\n self._test_conversion('linear_upsample', [node], [input], [output], opset_version=8)\n\n def test_resize_nearest_upsample(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 3, 32, 32])\n scales = helper.make_tensor_value_info('scales', TensorProto.FLOAT, [4])\n roi = helper.make_tensor_value_info('roi', TensorProto.FLOAT, [0])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 3, 64, 64])\n node = helper.make_node(\n op_type='Resize',\n inputs=['input', 'roi', 'scales'],\n outputs=['output'],\n mode='nearest',\n )\n\n self._test_conversion('resize_nearest_upsample', [node], [input], [output], constants=[scales, roi],\n values={'scales': [1.0, 1.0, 2.0, 2.0], 'roi': []})\n\n def test_resize_linear_upsample(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 3, 32, 32])\n scales = helper.make_tensor_value_info('scales', TensorProto.FLOAT, [4])\n roi = helper.make_tensor_value_info('roi', TensorProto.FLOAT, [0])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 3, 64, 64])\n node = helper.make_node(\n op_type='Resize',\n inputs=['input', 'roi', 'scales'],\n outputs=['output'],\n mode='linear',\n )\n\n self._test_conversion('resize_liner_upsample', [node], [input], [output], constants=[scales, roi],\n values={'scales': [1.0, 1.0, 2.0, 2.0], 'roi': []})\n\n def test_resize_nearest_downsample(self):\n input = helper.make_tensor_value_info('input', TensorProto.FLOAT, [1, 3, 32, 32])\n scales = helper.make_tensor_value_info('scales', TensorProto.FLOAT, [4])\n roi = helper.make_tensor_value_info('roi', TensorProto.FLOAT, [0])\n output = helper.make_tensor_value_info('output', TensorProto.FLOAT, [1, 3, 16, 16])\n node = helper.make_node(\n op_type='Resize',\n inputs=['input', 'roi', 'scales'],\n outputs=['output'],\n mode='nearest',\n )\n\n self._test_conversion('resize_nearest_downsample', [node], [input], [output], constants=[scales, roi],\n values={'scales': [1.0, 1.0, 0.5, 0.5], 'roi': []})\n\n def test_min_recude(self):\n self._test_reduce('ReduceMin', keepdims=False)\n\n def test_max_recude(self):\n self._test_reduce('ReduceMax', keepdims=False)\n\n def test_mean_recude(self):\n self._test_reduce('ReduceMean', keepdims=False)\n\n def test_sum_recude(self):\n self._test_reduce('ReduceSum', keepdims=False)\n\n def test_max_recude_keepdims(self):\n self._test_reduce('ReduceMax', keepdims=True)\n\n def test_relu(self):\n self._test_unary('Relu')\n\n def test_sigmoid(self):\n self._test_unary('Sigmoid')\n\n def test_tanh(self):\n self._test_unary('Tanh')\n\n def test_softplus(self):\n self._test_unary('Softplus')\n\n def test_not(self):\n self._test_unary('Not', dtype=TensorProto.BOOL)\n\n def test_elu(self):\n self._test_unary('Elu')\n\n def test_abs(self):\n self._test_unary('Abs')\n\n def test_sign(self):\n self._test_unary('Sign')\n\n def test_cos(self):\n self._test_unary('Cos')\n\n def test_sin(self):\n self._test_unary('Sin')\n\n def test_exp(self):\n self._test_unary('Exp')\n\n def test_log(self):\n self._test_unary('Log')\n\n def test_neg(self):\n self._test_unary('Neg')\n\n def test_sqrt(self):\n self._test_unary('Sqrt')\n\n def test_ceil(self):\n self._test_unary('Ceil')\n\n def test_floor(self):\n self._test_unary('Floor')\n\n def test_round(self):\n self._test_unary('Round')\n\n def test_add(self):\n self._test_binary('Add')\n\n def test_sub(self):\n self._test_binary('Sub')\n\n def test_mul(self):\n self._test_binary('Mul')\n\n def test_div(self):\n self._test_binary('Div')\n\n def test_pow(self):\n self._test_binary('Pow')\n\n def test_min(self):\n self._test_binary('Min')\n\n def test_max(self):\n self._test_binary('Max')\n\n def test_and(self):\n self._test_binary('And', input_dtype=TensorProto.BOOL, output_dtype=TensorProto.BOOL)\n\n def test_or(self):\n self._test_binary('Or', input_dtype=TensorProto.BOOL, output_dtype=TensorProto.BOOL)\n\n def test_equal(self):\n self._test_binary('Equal', output_dtype=TensorProto.BOOL)\n\n def test_less(self):\n self._test_binary('Less', output_dtype=TensorProto.BOOL)\n\n def test_greater(self):\n self._test_binary('Greater', output_dtype=TensorProto.BOOL)\n\n\nclass NetworkTestCases(TestEnv):\n\n def test_alexnet(self):\n self._test_conversion_from_file(self._network_folder + 'alexnet.onnx')\n\n def test_googlenet(self):\n self._test_conversion_from_file(self._network_folder + 'googlenet.onnx')\n\n def test_inception_v1(self):\n self._test_conversion_from_file(self._network_folder + 'inception_v1.onnx')\n\n def test_inception_v2(self):\n self._test_conversion_from_file(self._network_folder + 'inception_v2.onnx')\n\n def test_mobilenet_v2(self):\n self._test_conversion_from_file(self._network_folder + 'mobilenet_v2.onnx', epsilon=1e-4)\n\n def test_resnet18_v1(self):\n self._test_conversion_from_file(self._network_folder + 'resnet18_v1.onnx')\n\n def test_resnet18_v2(self):\n self._test_conversion_from_file(self._network_folder + 'resnet18_v2.onnx')\n\n def test_squeezenet_v1(self):\n self._test_conversion_from_file(self._network_folder + 'squeezenet_v1.onnx')\n\n def test_squeezenet_v2(self):\n self._test_conversion_from_file(self._network_folder + 'squeezenet_v2.onnx')\n\n def test_shufflenet(self):\n self._test_conversion_from_file(self._network_folder + 'shufflenet.onnx')\n\n\nif __name__ == '__main__':\n unittest.main()"
] | [
[
"tensorflow.Graph",
"tensorflow.import_graph_def",
"numpy.dtype",
"numpy.full",
"numpy.frombuffer",
"numpy.prod",
"tensorflow.get_default_graph",
"numpy.array"
],
[
"numpy.random.random",
"numpy.abs",
"numpy.random.seed",
"numpy.dtype",
"numpy.all",
"numpy.array"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"1.10",
"1.12",
"1.4",
"1.5",
"1.7",
"0.12",
"1.0",
"1.2"
]
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
dbradf/signal-processing-algorithms | [
"75312e873543f0f89aace75f43ded783395425c5"
] | [
"src/signal_processing_algorithms/gesd.py"
] | [
"# -*- coding: utf-8 -*-\n\"\"\"\nGESD based Detect outliers.\n\nGeneralized ESD Test for Outliers\nsee 'GESD<https://www.itl.nist.gov/div898/handbook/eda/section3/eda35h3.htm>'\n\"\"\"\nimport collections\n\nfrom typing import List\n\nimport numpy as np\nimport numpy.ma as ma\nimport structlog\n\nfrom scipy.stats import t\n\nLOG = structlog.get_logger()\n\nGesdResult = collections.namedtuple(\n \"GesdResult\",\n [\"count\", \"suspicious_indexes\", \"test_statistics\", \"critical_values\", \"all_z_scores\"],\n)\n\"\"\"\nA named tuple for the results of the GESD algorithm.\n\nThe outliers are in suspicious_indexes[count:].\nThe low confidence outliers are in suspicious_indexes[:count].\n\n:type count: int,\n:type suspicious_indexes: list(int)\n:type test_statistics: list(float)\n:type critical_values: list(float)\n:type all_z_scores: list(float, float)\n:type series: list(float)\n\"\"\"\n\n\ndef gesd(\n data: List[float], max_outliers: int = 10, significance_level: float = 0.05, mad: bool = False\n) -> GesdResult:\n \"\"\"\n Perform a Generalized ESD Test for Outliers.\n\n The generalized ESD(Extreme Studentized Deviate) test (Rosner 1983) is used to detect one or\n more outliers in a univariate data set that follows an approximately normal distribution.\n\n Usage:\n gesd_result = gesd(\n series,\n max_outliers,\n significance_level=significance,\n mad=True)\n\n count = gesd_result.count\n indexes = gesd_result.suspicious_indexes\n\n print(\"outliers indexes {}\".format(indexes[:count])\n print(\"low confidence outliers indexes {}\".format(indexes[count:])\n\n\n If the standard deviation of the series data is zero then the outlier detection will bail out.\n For non-mad this entails a constant series or sub-series so this behaviour makes sense.\n\n In the MAD case, this may mean that the series is constant or that a majority of the series\n are the median value. The data should be validated to avoid this issue.\n\n Note: the test_statistics array is signed, this allows determination of the outlier above\n or below the mean.\n\n :param data: The data to test.\n :param max_outliers: Test for up to max outliers.\n :param significance_level: Test for up to max outliers.\n :param mad: Use Median Absolute Deviation.\n :return: The number of outliers, suspicious indexes, test_statistics, critical_values, z_values.\n see 'here<https://www.itl.nist.gov/div898/handbook/eda/section3/eda35h3.htm>'\n \"\"\"\n if data is None or np.size(data) == 0:\n raise ValueError(\"No Data ({})\".format(data))\n length = len(data)\n if max_outliers < 1:\n raise ValueError(\n \"max_outliers({max_outliers}) must be >= 1\".format(max_outliers=max_outliers)\n )\n if max_outliers >= len(data):\n raise ValueError(\n \"max_outliers({max_outliers}) <= length({length})\".format(\n length=len(data) if data is not None else None, max_outliers=max_outliers\n )\n )\n if significance_level <= 0.0 or significance_level >= 1.0:\n raise ValueError(\n \"invalid significance_level({significance_level})\".format(\n significance_level=significance_level\n )\n )\n\n series = ma.array(data)\n test_statistics = []\n critical_values = []\n potential_outlier_indices = []\n\n # max outliers must be less than length, the standard deviation and mad of a single entry list\n # are 0 so z score would be nan.\n m_outliers = min(max_outliers, length - 1)\n\n indexes = np.arange(m_outliers, dtype=int)\n for i in indexes:\n LOG.debug(\"iteration\", i=i, mad=mad, series=series)\n if mad:\n # sigma in this case is an estimate of .75 quantile * MAD\n # note : 1.4826 == 1 / Q(.75) == 1 / 0.675\n center = np.ma.median(series)\n sigma = 1.4826 * np.ma.median(np.fabs(series - center))\n else:\n center = series.mean()\n sigma = series.std(ddof=1)\n\n if sigma == 0:\n break\n\n z_scores = (series - center) / sigma\n if i == 0:\n all_z_scores = (series - center) / sigma\n\n LOG.debug(\"calculate\", z_scores=np.array([np.arange(length, dtype=int), z_scores]).T)\n\n max_z_score_index = np.fabs(z_scores).argmax()\n max_z_score = z_scores[max_z_score_index]\n\n # 2 sided test for significance.\n significance_result = 1.0 - significance_level / (2.0 * (length - i))\n\n # Percent point function with df (degrees of freedom).\n percentage_point = t.ppf(significance_result, df=length - i - 2)\n value = (\n (length - i - 1)\n * percentage_point\n / np.sqrt((length - i - 2 + percentage_point ** 2) * (length - i))\n )\n\n # Update results.\n potential_outlier_indices.append(max_z_score_index)\n test_statistics.append(max_z_score)\n critical_values.append(value)\n\n LOG.debug(\n \"iteration complete\",\n z_scores=np.array(\n [\n np.arange(max_outliers, dtype=int),\n test_statistics,\n critical_values,\n np.greater(test_statistics, critical_values),\n ]\n ).T,\n )\n\n # Mask and exclude the selected value from the next iteration.\n series[max_z_score_index] = ma.masked\n\n LOG.debug(\"values calculated\", max_z_scores=test_statistics, lambda_values=critical_values)\n if potential_outlier_indices:\n for number_outliers in range(len(potential_outlier_indices), 0, -1):\n if np.abs(test_statistics[number_outliers - 1]) > critical_values[number_outliers - 1]:\n LOG.debug(\n \"outliers discovered\",\n number_outliers=number_outliers,\n outliers=potential_outlier_indices[0:number_outliers],\n )\n\n return GesdResult(\n number_outliers,\n potential_outlier_indices,\n test_statistics,\n critical_values,\n all_z_scores[potential_outlier_indices],\n )\n return GesdResult(\n 0,\n potential_outlier_indices,\n test_statistics,\n critical_values,\n all_z_scores[potential_outlier_indices] if potential_outlier_indices else [],\n )\n"
] | [
[
"numpy.sqrt",
"numpy.abs",
"numpy.greater",
"numpy.arange",
"numpy.ma.median",
"scipy.stats.t.ppf",
"numpy.size",
"numpy.ma.array",
"numpy.fabs"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
prjemian/XAnoS | [
"8a70380a88421042feff6f4aa9f5cf1f79ab4efc"
] | [
"Functions/FormFactors/SphericalShell_expDecay.py"
] | [
"####Please do not remove lines below####\nfrom lmfit import Parameters\nimport numpy as np\nimport sys\nimport os\nsys.path.append(os.path.abspath('.'))\nsys.path.append(os.path.abspath('./Functions'))\nsys.path.append(os.path.abspath('./Fortran_rountines'))\n\n####Please do not remove lines above####\n\n####Import your modules below if needed####\nfrom xraydb import XrayDB\n#from pyEQL import chemical_formula\n\n\nclass SphericalShell_expDecay: #Please put the class name same as the function name\n No = 6.023e23 # Avagadro number\n re2= (2.817e-5)**2 # Square of classical electron radius in Angs^2\n def __init__(self, x=0, rmin=0.0, rmax=30.0, Nr=31, Rc=10.0, strho=1.0, tst=2.0, lrho=0.5, lexp=10.0, rhosol=0.0, norm=1.0, bkg=0.0, mpar={}):\n \"\"\"\n Documentation\n x \t: independent variable in the form of a scalar or an array\n Rc \t: Radial distance in Angstroms after which the solvent contribution starts\n strho \t: Concentration of the ions of interest in the stern layer in Molar\n tst \t: Thickness of stern layer in Angstroms\n lrho \t: The maximum concentration of the diffuse layer in Molars\n lexp \t: The decay length of the diffuse layer assuming exponential decay\n rhosol\t: The surrounding bulk density\n norm \t: Density of particles in Moles/Liter\n bkg \t: Constant background\n \"\"\"\n if type(x)==list:\n self.x=np.array(x)\n else:\n self.x=x\n self.rmin=rmin\n self.rmax=rmax\n self.Nr=Nr\n self.Rc=Rc\n self.strho=strho\n self.tst=tst\n self.lrho=lrho\n self.lexp=lexp\n self.rhosol=rhosol\n self.norm=norm\n self.bkg=bkg\n self.__mpar__=mpar #If there is any multivalued parameter\n self.choices={} #If there are choices available for any fixed parameters\n self.__xrdb__=XrayDB()\n self.init_params()\n\n def init_params(self):\n \"\"\"\n Define all the fitting parameters like\n self.param.add('sig',value=0,vary=0)\n \"\"\"\n self.params=Parameters()\n self.params.add('Rc',value=self.Rc,vary=0,min=-np.inf,max=np.inf,expr=None,brute_step=0.1)\n self.params.add('strho', value=self.strho, vary=0, min=-np.inf, max=np.inf, expr=None, brute_step=0.1)\n self.params.add('tst', value=self.tst, vary=0, min=-np.inf, max=np.inf, expr=None, brute_step=0.1)\n self.params.add('lrho', value=self.lrho, vary=0, min=-np.inf, max=np.inf, expr=None, brute_step=0.1)\n self.params.add('lexp', value=self.lexp, vary=0, min=-np.inf, max=np.inf, expr=None, brute_step=0.1)\n self.params.add('norm', value=self.norm, vary=0, min=-np.inf, max=np.inf, expr=None, brute_step=0.1)\n self.params.add('bkg', value=self.bkg, vary=0, min=-np.inf, max=np.inf, expr=None, brute_step=0.1)\n\n\n\n def solrho(self, r, Rp=100.0, Rc=12.5, strho=1.0, tst=2.0, lrho=0.5, lexp=10.0, rhosol=0.0):\n \"\"\"\n Calculates the electron density for the distribution of ions as a function of radial distance surrounding a spherical particle\n\n Rp :: Radius of the sphere in Angstroms enclosing the spherical particle\n Rc :: Radial distance in Angstroms after which the solvent contribution starts\n strho :: Concentration of the ions of interest in the stern layer in Molar\n tst :: Thickness of stern layer in Angstroms\n lrho :: The maximum concentration of the diffuse layer in Molars\n lexp :: The decay length of the diffuse layer assuming exponential decay\n rhosol :: The surrounding bulk density\n \"\"\"\n R1=Rc\n R2=Rc+tst\n #integral=np.sum([r1**2*np.exp(-(r1-R2)/lexp) for r1 in np.linspace(R2,Rp,1001)])*(Rp-R2)/1000\n integral=lexp*(R2**2*np.exp(-R2/lexp)-Rp**2*np.exp(-Rp/lexp))+2*lexp**2*(R2*np.exp(-R2/lexp)-Rp*np.exp(-Rp/lexp))+2*lexp**3*(np.exp(-Rp/lexp)-np.exp(-R2/lexp))\n rhos=(rhosol*(Rp**3-R1**3)-strho*(R2**3-R1**3)-3*lrho*integral*np.exp(R2/lexp))/(Rp**3-R2**3)\n self.output_params['scaler_parameters']['rho_bulk']=rhos\n stern = np.where(r > R1, strho, 0.0) * np.where(r > R2, 0.0, 1.0)\n diffuse = np.where(r > R2, lrho * np.exp(-(r - R2) / lexp) + rhos, 0.0)\n rho = (stern + diffuse)\n return rho # in Moles/Liter\n\n\n def calc_form(self, q, r, rho):\n \"\"\"\n Calculates the isotropic form factor using the isotropic electron density as a funciton of radial distance\n\n q :: scaler or array of reciprocal reciprocal wave vector in inv. Angstroms at which the form factor needs to be calculated in\n r :: array of radial distances at which the element/ion density in known in Angstroms\n rho :: array of element/ion densities as a function of radial distance in el/Angstroms^3. Note: The electron density should decay to zero at the last radial distance\n \"\"\"\n dr = r[1] - r[0]\n form = np.zeros_like(q)\n rho = (rho - rho[-1])* self.No/1e27 #converting it to moles/Angs^3\n for r1, rho1 in zip(r, rho):\n form = form + 4 * np.pi * r1 * rho1 * np.sin(q * r1) / q\n form = (np.absolute(form) * dr)**2\n return self.re2 * form * 1e-16 * self.No / 1e3 # in cm^-1\n\n def y(self):\n \"\"\"\n Define the function in terms of x to return some value\n \"\"\"\n self.output_params={}\n self.output_params['scaler_parameters']={}\n r=np.linspace(self.rmin, self.rmax, self.Nr)\n strho=self.params['strho'].value\n tst=self.params['tst'].value\n lrho=self.params['lrho'].value\n lexp=self.params['lexp'].value\n #rhosol=self.params['rhosol'].value\n norm=self.params['norm'].value\n bkg=self.params['bkg'].value\n Rc = self.params['Rc'].value\n Rp=(3/(4*np.pi*norm*6.022e23))**(1.0/3.0)*1e9\n rho=self.solrho(r, Rp=Rp, Rc=Rc, strho=strho, tst=tst, lrho=lrho, lexp=lexp, rhosol=self.rhosol)\n self.output_params['Electron_Density']={'x':r,'y':rho}\n self.output_params['scaler_parameters']['Rp']=Rp\n form=norm*self.calc_form(self.x,r,rho)+bkg\n return form\n\nif __name__=='__main__':\n x=np.arange(0.001,1.0,0.1)\n fun=SphericalShell_expDecay(x=x)\n print(fun.y())\n"
] | [
[
"numpy.absolute",
"numpy.linspace",
"numpy.arange",
"numpy.sin",
"numpy.zeros_like",
"numpy.exp",
"numpy.array",
"numpy.where"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
alexandru-dinu/PRML | [
"acd823e098df67abe0306a70225e7539f8edda40"
] | [
"prml/linear/_bayesian_regression.py"
] | [
"import numpy as np\n\nfrom prml.linear._regression import Regression\n\n\nclass BayesianRegression(Regression):\n \"\"\"Bayesian regression model.\n\n w ~ N(w|0, alpha^(-1)I)\n y = X @ w\n t ~ N(t|X @ w, beta^(-1))\n \"\"\"\n\n def __init__(self, alpha: float = 1.0, beta: float = 1.0):\n \"\"\"Initialize bayesian linear regression model.\n\n Parameters\n ----------\n alpha : float, optional\n Precision parameter of the prior, by default 1.\n beta : float, optional\n Precision parameter of the likelihood, by default 1.\n \"\"\"\n self.alpha = alpha\n self.beta = beta\n self.w_mean = None\n self.w_precision = None\n\n def _is_prior_defined(self) -> bool:\n return self.w_mean is not None and self.w_precision is not None\n\n def _get_prior(self, ndim: int) -> tuple:\n if self._is_prior_defined():\n return self.w_mean, self.w_precision\n else:\n return np.zeros(ndim), self.alpha * np.eye(ndim)\n\n def fit(self, x_train: np.ndarray, y_train: np.ndarray):\n \"\"\"Bayesian update of parameters given training dataset.\n\n Parameters\n ----------\n x_train : np.ndarray\n training data independent variable (N, n_features)\n y_train : np.ndarray\n training data dependent variable\n \"\"\"\n mean_prev, precision_prev = self._get_prior(np.size(x_train, 1))\n\n w_precision = precision_prev + self.beta * x_train.T @ x_train\n w_mean = np.linalg.solve(\n w_precision,\n precision_prev @ mean_prev + self.beta * x_train.T @ y_train,\n )\n self.w_mean = w_mean\n self.w_precision = w_precision\n self.w_cov = np.linalg.inv(self.w_precision)\n\n def predict(\n self,\n x: np.ndarray,\n return_std: bool = False,\n sample_size: int = None,\n ):\n \"\"\"Return mean (and standard deviation) of predictive distribution.\n\n Parameters\n ----------\n x : np.ndarray\n independent variable (N, n_features)\n return_std : bool, optional\n flag to return standard deviation (the default is False)\n sample_size : int, optional\n number of samples to draw from the predictive distribution\n (the default is None, no sampling from the distribution)\n\n Returns\n -------\n y : np.ndarray\n mean of the predictive distribution (N,)\n y_std : np.ndarray\n standard deviation of the predictive distribution (N,)\n y_sample : np.ndarray\n samples from the predictive distribution (N, sample_size)\n \"\"\"\n if sample_size is not None:\n w_sample = np.random.multivariate_normal(\n self.w_mean,\n self.w_cov,\n size=sample_size,\n )\n y_sample = x @ w_sample.T\n return y_sample\n y = x @ self.w_mean\n if return_std:\n y_var = 1 / self.beta + np.sum(x @ self.w_cov * x, axis=1)\n y_std = np.sqrt(y_var)\n return y, y_std\n return y\n"
] | [
[
"numpy.linalg.solve",
"numpy.sqrt",
"numpy.linalg.inv",
"numpy.random.multivariate_normal",
"numpy.eye",
"numpy.size",
"numpy.zeros",
"numpy.sum"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
jnorwood/tensorflow | [
"67ab6c9cebc4cbb2103246a1523d04261bef22d2"
] | [
"tensorflow/python/saved_model/save.py"
] | [
"# Copyright 2018 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"Exports a SavedModel from a Trackable Python object.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport collections\nimport os\n\nfrom tensorflow.core.framework import versions_pb2\nfrom tensorflow.core.protobuf import meta_graph_pb2\nfrom tensorflow.core.protobuf import saved_model_pb2\nfrom tensorflow.core.protobuf import saved_object_graph_pb2\nfrom tensorflow.python.eager import context\nfrom tensorflow.python.eager import def_function\nfrom tensorflow.python.eager import function as defun\nfrom tensorflow.python.framework import constant_op\nfrom tensorflow.python.framework import dtypes\nfrom tensorflow.python.framework import meta_graph\nfrom tensorflow.python.framework import ops\nfrom tensorflow.python.framework import tensor_util\nfrom tensorflow.python.framework import versions\nfrom tensorflow.python.lib.io import file_io\nfrom tensorflow.python.ops import array_ops\nfrom tensorflow.python.ops import control_flow_ops\nfrom tensorflow.python.ops import resource_variable_ops\nfrom tensorflow.python.saved_model import builder_impl\nfrom tensorflow.python.saved_model import constants\nfrom tensorflow.python.saved_model import function_serialization\nfrom tensorflow.python.saved_model import nested_structure_coder\nfrom tensorflow.python.saved_model import revived_types\nfrom tensorflow.python.saved_model import signature_constants\nfrom tensorflow.python.saved_model import signature_def_utils\nfrom tensorflow.python.saved_model import signature_serialization\nfrom tensorflow.python.saved_model import tag_constants\nfrom tensorflow.python.saved_model import utils_impl\nfrom tensorflow.python.training.saving import functional_saver\nfrom tensorflow.python.training.tracking import base\nfrom tensorflow.python.training.tracking import graph_view\nfrom tensorflow.python.training.tracking import object_identity\nfrom tensorflow.python.training.tracking import tracking\nfrom tensorflow.python.training.tracking import util\nfrom tensorflow.python.util import compat\nfrom tensorflow.python.util.tf_export import tf_export\n\n_UNCOPIABLE_DTYPES = frozenset((dtypes.resource, dtypes.variant))\n\n\n# A container for an EagerTensor constant which has been copied to the exported\n# Graph.\n_CapturedConstant = collections.namedtuple(\n \"_CapturedConstant\", [\"eager_tensor\", \"graph_tensor\"])\n\n\nclass _AugmentedGraphView(graph_view.ObjectGraphView):\n \"\"\"An extendable graph which also tracks functions attached to objects.\n\n Extensions through `add_object` appear in the object graph and any checkpoints\n generated from it, even if they are not dependencies of the node they were\n attached to in the saving program. For example a `.signatures` attribute is\n added to exported SavedModel root objects without modifying the root object\n itself.\n\n Also tracks functions attached to objects in the graph, through the caching\n `list_functions` method. Enumerating functions only through this method\n ensures that we get a consistent view of functions, even if object attributes\n create new functions every time they are accessed.\n \"\"\"\n\n def __init__(self, root):\n if (not context.executing_eagerly()\n and not ops.inside_function()):\n saveables_cache = object_identity.ObjectIdentityWeakKeyDictionary()\n else:\n saveables_cache = None\n super(_AugmentedGraphView, self).__init__(root, saveables_cache)\n # Object -> (name -> dep)\n self._extra_dependencies = object_identity.ObjectIdentityDictionary()\n self._functions = object_identity.ObjectIdentityDictionary()\n\n def add_object(self, parent_node, name_in_parent, subgraph_root):\n \"\"\"Attach an object to `parent_node`, overriding any existing dependency.\"\"\"\n self._extra_dependencies.setdefault(\n parent_node, {})[name_in_parent] = subgraph_root\n\n def list_dependencies(self, obj):\n \"\"\"Overrides a parent method to include `add_object` objects.\"\"\"\n extra_dependencies = self._extra_dependencies.get(obj, {})\n used_names = set()\n for name, dep in super(_AugmentedGraphView, self).list_dependencies(obj):\n used_names.add(name)\n if name in extra_dependencies:\n yield base.TrackableReference(name, extra_dependencies[name])\n else:\n yield base.TrackableReference(name, dep)\n for name, dep in extra_dependencies.items():\n if name in used_names:\n continue\n yield base.TrackableReference(name, dep)\n\n def list_functions(self, obj):\n obj_functions = self._functions.get(obj, None)\n if obj_functions is None:\n obj_functions = obj._list_functions_for_serialization() # pylint: disable=protected-access\n self._functions[obj] = obj_functions\n return obj_functions\n\n\nclass _SaveableView(object):\n \"\"\"Provides a frozen view over a trackable root.\n\n This class helps creating a single stable view over an object to save. The\n saving code should access properties and functions via this class and not via\n the original object as there are cases where an object construct their\n trackable attributes and functions dynamically per call and will yield\n different objects if invoked more than once.\n\n Changes to the graph, for example adding objects, must happen in\n `checkpoint_view` (an `_AugmentedGraphView`) before the `_SaveableView` is\n constructed. Changes after the `_SaveableView` has been constructed will be\n ignored.\n \"\"\"\n\n def __init__(self, checkpoint_view):\n self.checkpoint_view = checkpoint_view\n trackable_objects, node_ids, slot_variables = (\n self.checkpoint_view.objects_ids_and_slot_variables())\n self.nodes = trackable_objects\n self.node_ids = node_ids\n self.captured_tensor_node_ids = object_identity.ObjectIdentityDictionary()\n self.slot_variables = slot_variables\n self.concrete_functions = []\n\n # Also add `Function`s as nodes.\n nodes_without_functions = list(self.nodes)\n seen_function_names = set()\n for node in nodes_without_functions:\n for function in checkpoint_view.list_functions(node).values():\n if function not in self.node_ids:\n self.node_ids[function] = len(self.nodes)\n self.nodes.append(function)\n if isinstance(function, def_function.Function):\n # Force listing the concrete functions for the side effects:\n # - populate the cache for functions that have an input_signature\n # and have not been called.\n # - force side effects of creation of concrete functions, e.g. create\n # variables on first run.\n concrete_functions = (\n function._list_all_concrete_functions_for_serialization()) # pylint: disable=protected-access\n else:\n concrete_functions = [function]\n for concrete_function in concrete_functions:\n if concrete_function.name not in seen_function_names:\n seen_function_names.add(concrete_function.name)\n self.concrete_functions.append(concrete_function)\n\n @property\n def root(self):\n return self.nodes[0]\n\n def fill_object_graph_proto(self, proto):\n \"\"\"Populate the nodes, children and slot_variables of a SavedObjectGraph.\"\"\"\n for node_id, node in enumerate(self.nodes):\n assert self.node_ids[node] == node_id\n object_proto = proto.nodes.add()\n object_proto.slot_variables.extend(self.slot_variables.get(node, ()))\n if isinstance(node, (def_function.Function, defun.ConcreteFunction,\n _CapturedConstant)):\n continue\n for child in self.checkpoint_view.list_dependencies(node):\n child_proto = object_proto.children.add()\n child_proto.node_id = self.node_ids[child.ref]\n child_proto.local_name = child.name\n for local_name, ref_function in (\n self.checkpoint_view.list_functions(node).items()):\n child_proto = object_proto.children.add()\n child_proto.node_id = self.node_ids[ref_function]\n child_proto.local_name = local_name\n\n def map_resources(self):\n \"\"\"Makes new resource handle ops corresponding to existing resource tensors.\n\n Creates resource handle ops in the current default graph, whereas\n `accessible_objects` will be from an eager context. Resource mapping adds\n resource handle ops to the main GraphDef of a SavedModel, which allows the\n C++ loader API to interact with variables.\n\n Returns:\n A tuple of (object_map, resource_map, asset_info):\n object_map: A dictionary mapping from object in `accessible_objects` to\n replacement objects created to hold the new resource tensors.\n resource_map: A dictionary mapping from resource tensors extracted from\n `accessible_objects` to newly created resource tensors.\n asset_info: An _AssetInfo tuple describing external assets referenced\n from accessible_objects.\n \"\"\"\n # Only makes sense when adding to the export Graph\n assert not context.executing_eagerly()\n # TODO(allenl): Handle MirroredVariables and other types of variables which\n # may need special casing.\n object_map = object_identity.ObjectIdentityDictionary()\n resource_map = {}\n asset_info = _AssetInfo(\n asset_defs=[],\n asset_initializers_by_resource={},\n asset_filename_map={},\n asset_index={})\n for node_id, obj in enumerate(self.nodes):\n if isinstance(obj, tracking.CapturableResource):\n # pylint: disable=protected-access\n with ops.device(obj._resource_device):\n new_resource = obj._create_resource()\n # pylint: enable=protected-access\n resource_map[obj.resource_handle] = new_resource\n self.captured_tensor_node_ids[obj.resource_handle] = node_id\n elif resource_variable_ops.is_resource_variable(obj):\n new_variable = resource_variable_ops.copy_to_graph_uninitialized(obj)\n object_map[obj] = new_variable\n resource_map[obj.handle] = new_variable.handle\n self.captured_tensor_node_ids[obj.handle] = node_id\n elif isinstance(obj, tracking.TrackableAsset):\n _process_asset(obj, asset_info, resource_map)\n self.captured_tensor_node_ids[obj.asset_path] = node_id\n\n for concrete_function in self.concrete_functions:\n for capture in concrete_function.captured_inputs:\n if (tensor_util.is_tensor(capture)\n and capture.dtype not in _UNCOPIABLE_DTYPES\n and capture not in self.captured_tensor_node_ids):\n copied_tensor = constant_op.constant(\n tensor_util.constant_value(capture))\n node_id = len(self.nodes)\n node = _CapturedConstant(\n eager_tensor=capture, graph_tensor=copied_tensor)\n self.nodes.append(node)\n self.node_ids[capture] = node_id\n self.node_ids[node] = node_id\n self.captured_tensor_node_ids[capture] = node_id\n resource_map[capture] = copied_tensor\n\n return object_map, resource_map, asset_info\n\n\ndef _tensor_dict_to_tensorinfo(tensor_dict):\n return {key: utils_impl.build_tensor_info_internal(value)\n for key, value in tensor_dict.items()}\n\n\ndef _map_captures_to_created_tensors(\n original_captures, resource_map):\n \"\"\"Maps eager tensors captured by a function to Graph resources for export.\n\n Args:\n original_captures: A dictionary mapping from tensors captured by the\n function to interior placeholders for those tensors (inside the function\n body).\n resource_map: A dictionary mapping from resource tensors owned by the eager\n context to resource tensors in the exported graph.\n\n Returns:\n A list of stand-in tensors which belong to the exported graph, corresponding\n to the function's captures.\n\n Raises:\n AssertionError: If the function references a resource which is not part of\n `resource_map`.\n \"\"\"\n export_captures = []\n for exterior, interior in original_captures.items():\n mapped_resource = resource_map.get(exterior, None)\n if mapped_resource is None:\n raise AssertionError(\n (\"Tried to export a function which references untracked object {}.\"\n \"TensorFlow objects (e.g. tf.Variable) captured by functions must \"\n \"be tracked by assigning them to an attribute of a tracked object \"\n \"or assigned to an attribute of the main object directly.\")\n .format(interior))\n export_captures.append(mapped_resource)\n return export_captures\n\n\ndef _map_function_arguments_to_created_inputs(\n function_arguments, signature_key, function_name):\n \"\"\"Creates exterior placeholders in the exported graph for function arguments.\n\n Functions have two types of inputs: tensors captured from the outside (eager)\n context, and arguments to the function which we expect to receive from the\n user at each call. `_map_captures_to_created_tensors` replaces\n captured tensors with stand-ins (typically these are resource dtype tensors\n associated with variables). `_map_function_inputs_to_created_inputs` runs over\n every argument, creating a new placeholder for each which will belong to the\n exported graph rather than the function body.\n\n Args:\n function_arguments: A list of argument placeholders in the function body.\n signature_key: The name of the signature being exported, for error messages.\n function_name: The name of the function, for error messages.\n\n Returns:\n A tuple of (mapped_inputs, exterior_placeholders)\n mapped_inputs: A list with entries corresponding to `function_arguments`\n containing all of the inputs of the function gathered from the exported\n graph (both captured resources and arguments).\n exterior_argument_placeholders: A dictionary mapping from argument names\n to placeholders in the exported graph, containing the explicit arguments\n to the function which a user is expected to provide.\n\n Raises:\n ValueError: If argument names are not unique.\n \"\"\"\n # `exterior_argument_placeholders` holds placeholders which are outside the\n # function body, directly contained in a MetaGraph of the SavedModel. The\n # function body itself contains nearly identical placeholders used when\n # running the function, but these exterior placeholders allow Session-based\n # APIs to call the function using feeds and fetches which name Tensors in the\n # MetaGraph.\n exterior_argument_placeholders = {}\n mapped_inputs = []\n for placeholder in function_arguments:\n # `export_captures` contains an exhaustive set of captures, so if we don't\n # find the input there then we now know we have an argument.\n user_input_name = compat.as_str_any(\n placeholder.op.get_attr(\"_user_specified_name\"))\n # If the internal placeholders for a function have names which were\n # uniquified by TensorFlow, then a single user-specified argument name\n # must refer to multiple Tensors. The resulting signatures would be\n # confusing to call. Instead, we throw an exception telling the user to\n # specify explicit names.\n if user_input_name != placeholder.op.name:\n # This should be unreachable, since concrete functions may not be\n # generated with non-unique argument names.\n raise ValueError(\n (\"Got non-flat/non-unique argument names for SavedModel \"\n \"signature '{}': more than one argument to '{}' was named '{}'. \"\n \"Signatures have one Tensor per named input, so to have \"\n \"predictable names Python functions used to generate these \"\n \"signatures should avoid *args and Tensors in nested \"\n \"structures unless unique names are specified for each. Use \"\n \"tf.TensorSpec(..., name=...) to provide a name for a Tensor \"\n \"input.\")\n .format(signature_key, compat.as_str_any(function_name),\n user_input_name))\n arg_placeholder = array_ops.placeholder(\n shape=placeholder.shape,\n dtype=placeholder.dtype,\n name=\"{}_{}\".format(signature_key, user_input_name))\n exterior_argument_placeholders[user_input_name] = arg_placeholder\n mapped_inputs.append(arg_placeholder)\n return mapped_inputs, exterior_argument_placeholders\n\n\ndef _call_function_with_mapped_captures(function, args, resource_map):\n \"\"\"Calls `function` in the exported graph, using mapped resource captures.\"\"\"\n export_captures = _map_captures_to_created_tensors(\n function.graph.captures, resource_map)\n mapped_inputs = args + export_captures\n # Calls the function quite directly, since we have new captured resource\n # tensors we need to feed in which weren't part of the original function\n # definition.\n # pylint: disable=protected-access\n outputs = function._build_call_outputs(\n function._inference_function.call(context.context(), mapped_inputs))\n return outputs\n\n\ndef _generate_signatures(signature_functions, resource_map):\n \"\"\"Validates and calls `signature_functions` in the default graph.\n\n Args:\n signature_functions: A dictionary mapping string keys to concrete TensorFlow\n functions (e.g. from `signature_serialization.canonicalize_signatures`)\n which will be used to generate SignatureDefs.\n resource_map: A dictionary mapping from resource tensors in the eager\n context to resource tensors in the Graph being exported. This dictionary\n is used to re-bind resources captured by functions to tensors which will\n exist in the SavedModel.\n\n Returns:\n Each function in the `signature_functions` dictionary is called with\n placeholder Tensors, generating a function call operation and output\n Tensors. The placeholder Tensors, the function call operation, and the\n output Tensors from the function call are part of the default Graph.\n\n This function then returns a dictionary with the same structure as\n `signature_functions`, with the concrete functions replaced by SignatureDefs\n implicitly containing information about how to call each function from a\n TensorFlow 1.x Session / the C++ Loader API. These SignatureDefs reference\n the generated placeholders and Tensor outputs by name.\n\n The caller is expected to include the default Graph set while calling this\n function as a MetaGraph in a SavedModel, including the returned\n SignatureDefs as part of that MetaGraph.\n \"\"\"\n signatures = {}\n for signature_key, function in sorted(signature_functions.items()):\n if function.graph.captures:\n argument_inputs = function.graph.inputs[:-len(function.graph.captures)]\n else:\n argument_inputs = function.graph.inputs\n mapped_inputs, exterior_argument_placeholders = (\n _map_function_arguments_to_created_inputs(\n argument_inputs, signature_key, function.name))\n outputs = _call_function_with_mapped_captures(\n function, mapped_inputs, resource_map)\n signatures[signature_key] = signature_def_utils.build_signature_def(\n _tensor_dict_to_tensorinfo(exterior_argument_placeholders),\n _tensor_dict_to_tensorinfo(outputs),\n method_name=signature_constants.PREDICT_METHOD_NAME)\n return signatures\n\n\ndef _trace_resource_initializers(accessible_objects):\n \"\"\"Create concrete functions from `CapturableResource` objects.\"\"\"\n resource_initializers = []\n\n def _wrap_initializer(obj):\n obj._initialize() # pylint: disable=protected-access\n return constant_op.constant(1.) # Dummy control output\n\n def _wrap_obj_initializer(obj):\n return lambda: _wrap_initializer(obj)\n\n for obj in accessible_objects:\n if isinstance(obj, tracking.CapturableResource):\n resource_initializers.append(def_function.function(\n _wrap_obj_initializer(obj),\n # All inputs are captures.\n input_signature=[]).get_concrete_function())\n return resource_initializers\n\n\n_AssetInfo = collections.namedtuple(\n \"_AssetInfo\", [\n # List of AssetFileDef protocol buffers\n \"asset_defs\",\n # Map from asset variable resource Tensors to their init ops\n \"asset_initializers_by_resource\",\n # Map from base asset filenames to full paths\n \"asset_filename_map\",\n # Map from TrackableAsset to index of corresponding AssetFileDef\n \"asset_index\"])\n\n\ndef _process_asset(trackable_asset, asset_info, resource_map):\n \"\"\"Add `trackable_asset` to `asset_info` and `resource_map`.\"\"\"\n original_path_tensor = trackable_asset.asset_path\n original_path = tensor_util.constant_value(original_path_tensor)\n try:\n original_path = str(original_path.astype(str))\n except AttributeError:\n # Already a string rather than a numpy array\n pass\n path = builder_impl.get_asset_filename_to_add(\n asset_filepath=original_path,\n asset_filename_map=asset_info.asset_filename_map)\n # TODO(andresp): Instead of mapping 1-1 between trackable asset\n # and asset in the graph def consider deduping the assets that\n # point to the same file.\n asset_path_initializer = array_ops.placeholder(\n shape=original_path_tensor.shape,\n dtype=dtypes.string,\n name=\"asset_path_initializer\")\n asset_variable = resource_variable_ops.ResourceVariable(\n asset_path_initializer)\n asset_info.asset_filename_map[path] = original_path\n asset_def = meta_graph_pb2.AssetFileDef()\n asset_def.filename = path\n asset_def.tensor_info.name = asset_path_initializer.name\n asset_info.asset_defs.append(asset_def)\n asset_info.asset_initializers_by_resource[original_path_tensor] = (\n asset_variable.initializer)\n asset_info.asset_index[trackable_asset] = len(asset_info.asset_defs) - 1\n resource_map[original_path_tensor] = asset_variable\n\n\ndef _fill_meta_graph_def(meta_graph_def, saveable_view, signature_functions):\n \"\"\"Generates a MetaGraph which calls `signature_functions`.\n\n Args:\n meta_graph_def: The MetaGraphDef proto to fill.\n saveable_view: The _SaveableView being exported.\n signature_functions: A dictionary mapping signature keys to concrete\n functions containing signatures to add to the MetaGraph.\n\n Returns:\n An _AssetInfo, which contains information to help creating the SavedModel.\n \"\"\"\n # List objects from the eager context to make sure Optimizers give us the\n # right Graph-dependent variables.\n accessible_objects = saveable_view.nodes\n resource_initializer_functions = _trace_resource_initializers(\n accessible_objects)\n exported_graph = ops.Graph()\n resource_initializer_ops = []\n with exported_graph.as_default():\n object_map, resource_map, asset_info = saveable_view.map_resources()\n for resource_initializer_function in resource_initializer_functions:\n asset_dependencies = []\n for capture in resource_initializer_function.graph.external_captures:\n asset_initializer = asset_info.asset_initializers_by_resource.get(\n capture, None)\n if asset_initializer is not None:\n asset_dependencies.append(asset_initializer)\n with ops.control_dependencies(asset_dependencies):\n resource_initializer_ops.append(\n _call_function_with_mapped_captures(\n resource_initializer_function, [], resource_map))\n resource_initializer_ops.extend(\n asset_info.asset_initializers_by_resource.values())\n with ops.control_dependencies(resource_initializer_ops):\n init_op = control_flow_ops.no_op()\n # Add the same op to the main_op collection and to the init_op\n # signature. The collection is for compatibility with older loader APIs;\n # only one will be executed.\n meta_graph_def.collection_def[constants.MAIN_OP_KEY].node_list.value.append(\n init_op.name)\n meta_graph_def.signature_def[constants.INIT_OP_SIGNATURE_KEY].CopyFrom(\n signature_def_utils.op_signature_def(\n init_op, constants.INIT_OP_SIGNATURE_KEY))\n\n # Saving an object-based checkpoint again gathers variables. We need to do the\n # gathering from the eager context so Optimizers save the right set of\n # variables, but want any operations associated with the save/restore to be in\n # the exported graph (thus the `to_graph` argument).\n saver = functional_saver.MultiDeviceSaver(\n saveable_view.checkpoint_view.frozen_saveable_objects(\n object_map=object_map, to_graph=exported_graph))\n\n with exported_graph.as_default():\n signatures = _generate_signatures(signature_functions, resource_map)\n for concrete_function in saveable_view.concrete_functions:\n concrete_function.add_to_graph()\n saver_def = saver.to_proto()\n meta_graph_def.saver_def.CopyFrom(saver_def)\n graph_def = exported_graph.as_graph_def(add_shapes=True)\n\n meta_graph_def.graph_def.CopyFrom(graph_def)\n meta_graph_def.meta_info_def.tags.append(tag_constants.SERVING)\n meta_graph_def.meta_info_def.tensorflow_version = versions.__version__\n meta_graph_def.meta_info_def.tensorflow_git_version = (\n versions.__git_version__)\n # We currently always strip default attributes.\n meta_graph_def.meta_info_def.stripped_default_attrs = True\n meta_graph_def.meta_info_def.stripped_op_list.MergeFrom(\n meta_graph.stripped_op_list_for_graph(meta_graph_def.graph_def))\n meta_graph_def.asset_file_def.extend(asset_info.asset_defs)\n for signature_key, signature in signatures.items():\n meta_graph_def.signature_def[signature_key].CopyFrom(signature)\n meta_graph.strip_graph_default_valued_attrs(meta_graph_def)\n return asset_info, exported_graph\n\n\ndef _serialize_object_graph(saveable_view, asset_file_def_index):\n \"\"\"Save a SavedObjectGraph proto for `root`.\"\"\"\n # SavedObjectGraph is similar to the TrackableObjectGraph proto in the\n # checkpoint. It will eventually go into the SavedModel.\n proto = saved_object_graph_pb2.SavedObjectGraph()\n saveable_view.fill_object_graph_proto(proto)\n\n coder = nested_structure_coder.StructureCoder()\n for concrete_function in saveable_view.concrete_functions:\n serialized = function_serialization.serialize_concrete_function(\n concrete_function, saveable_view.captured_tensor_node_ids, coder)\n if serialized is not None:\n proto.concrete_functions[concrete_function.name].CopyFrom(\n serialized)\n\n for obj, obj_proto in zip(saveable_view.nodes, proto.nodes):\n _write_object_proto(obj, obj_proto, asset_file_def_index)\n return proto\n\n\ndef _write_object_proto(obj, proto, asset_file_def_index):\n \"\"\"Saves an object into SavedObject proto.\"\"\"\n if isinstance(obj, tracking.TrackableAsset):\n proto.asset.SetInParent()\n proto.asset.asset_file_def_index = asset_file_def_index[obj]\n elif resource_variable_ops.is_resource_variable(obj):\n proto.variable.SetInParent()\n if not obj.name.endswith(\":0\"):\n raise ValueError(\"Cowardly refusing to save variable %s because of\"\n \" unexpected suffix which won't be restored.\")\n proto.variable.name = meta_graph._op_name(obj.name) # pylint: disable=protected-access\n proto.variable.trainable = obj.trainable\n proto.variable.dtype = obj.dtype.as_datatype_enum\n proto.variable.synchronization = obj.synchronization.value\n proto.variable.aggregation = obj.aggregation.value\n proto.variable.shape.CopyFrom(obj.shape.as_proto())\n elif isinstance(obj, def_function.Function):\n proto.function.CopyFrom(\n function_serialization.serialize_function(obj))\n elif isinstance(obj, defun.ConcreteFunction):\n proto.bare_concrete_function.CopyFrom(\n function_serialization.serialize_bare_concrete_function(obj))\n elif isinstance(obj, _CapturedConstant):\n proto.constant.operation = obj.graph_tensor.op.name\n elif isinstance(obj, tracking.CapturableResource):\n proto.resource.device = obj._resource_device # pylint: disable=protected-access\n else:\n registered_type_proto = revived_types.serialize(obj)\n if registered_type_proto is None:\n # Fallback for types with no matching registration\n registered_type_proto = saved_object_graph_pb2.SavedUserObject(\n identifier=\"_generic_user_object\",\n version=versions_pb2.VersionDef(\n producer=1, min_consumer=1, bad_consumers=[]))\n proto.user_object.CopyFrom(registered_type_proto)\n\n\n@tf_export(\"saved_model.save\",\n v1=[\"saved_model.save\", \"saved_model.experimental.save\"])\ndef save(obj, export_dir, signatures=None):\n # pylint: disable=line-too-long\n \"\"\"Exports the Trackable object `obj` to [SavedModel format](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/python/saved_model/README.md).\n\n Example usage:\n\n ```python\n class Adder(tf.Module):\n\n @tf.function(input_signature=[tf.TensorSpec(shape=None, dtype=tf.float32)])\n def add(self, x):\n return x + x + 1.\n\n to_export = Adder()\n tf.saved_model.save(to_export, '/tmp/adder')\n ```\n\n The resulting SavedModel is then servable with an input named \"x\", its value\n having any shape and dtype float32.\n\n The optional `signatures` argument controls which methods in `obj` will be\n available to programs which consume `SavedModel`s, for example serving\n APIs. Python functions may be decorated with\n `@tf.function(input_signature=...)` and passed as signatures directly, or\n lazily with a call to `get_concrete_function` on the method decorated with\n `@tf.function`.\n\n If the `signatures` argument is omitted, `obj` will be searched for\n `@tf.function`-decorated methods. If exactly one `@tf.function` is found, that\n method will be used as the default signature for the SavedModel. This behavior\n is expected to change in the future, when a corresponding\n `tf.saved_model.load` symbol is added. At that point signatures will be\n completely optional, and any `@tf.function` attached to `obj` or its\n dependencies will be exported for use with `load`.\n\n When invoking a signature in an exported SavedModel, `Tensor` arguments are\n identified by name. These names will come from the Python function's argument\n names by default. They may be overridden by specifying a `name=...` argument\n in the corresponding `tf.TensorSpec` object. Explicit naming is required if\n multiple `Tensor`s are passed through a single argument to the Python\n function.\n\n The outputs of functions used as `signatures` must either be flat lists, in\n which case outputs will be numbered, or a dictionary mapping string keys to\n `Tensor`, in which case the keys will be used to name outputs.\n\n Signatures are available in objects returned by `tf.saved_model.load` as a\n `.signatures` attribute. This is a reserved attribute: `tf.saved_model.save`\n on an object with a custom `.signatures` attribute will raise an exception.\n\n Since `tf.keras.Model` objects are also Trackable, this function can be\n used to export Keras models. For example, exporting with a signature\n specified:\n\n ```python\n class Model(tf.keras.Model):\n\n @tf.function(input_signature=[tf.TensorSpec(shape=[None], dtype=tf.string)])\n def serve(self, serialized):\n ...\n\n m = Model()\n tf.saved_model.save(m, '/tmp/saved_model/')\n ```\n\n Exporting from a function without a fixed signature:\n\n ```python\n class Model(tf.keras.Model):\n\n @tf.function\n def call(self, x):\n ...\n\n m = Model()\n tf.saved_model.save(\n m, '/tmp/saved_model/',\n signatures=m.call.get_concrete_function(\n tf.TensorSpec(shape=[None, 3], dtype=tf.float32, name=\"inp\")))\n ```\n\n `tf.keras.Model` instances constructed from inputs and outputs already have a\n signature and so do not require a `@tf.function` decorator or a `signatures`\n argument. If neither are specified, the model's forward pass is exported.\n\n ```python\n x = input_layer.Input((4,), name=\"x\")\n y = core.Dense(5, name=\"out\")(x)\n model = training.Model(x, y)\n tf.saved_model.save(model, '/tmp/saved_model/')\n # The exported SavedModel takes \"x\" with shape [None, 4] and returns \"out\"\n # with shape [None, 5]\n ```\n\n Variables must be tracked by assigning them to an attribute of a tracked\n object or to an attribute of `obj` directly. TensorFlow objects (e.g. layers\n from `tf.keras.layers`, optimizers from `tf.train`) track their variables\n automatically. This is the same tracking scheme that `tf.train.Checkpoint`\n uses, and an exported `Checkpoint` object may be restored as a training\n checkpoint by pointing `tf.train.Checkpoint.restore` to the SavedModel's\n \"variables/\" subdirectory. Currently variables are the only stateful objects\n supported by `tf.saved_model.save`, but others (e.g. tables) will be supported\n in the future.\n\n `tf.function` does not hard-code device annotations from outside the function\n body, instead using the calling context's device. This means for example that\n exporting a model which runs on a GPU and serving it on a CPU will generally\n work, with some exceptions. `tf.device` annotations inside the body of the\n function will be hard-coded in the exported model; this type of annotation is\n discouraged. Device-specific operations, e.g. with \"cuDNN\" in the name or with\n device-specific layouts, may cause issues. Currently a `DistributionStrategy`\n is another exception: active distribution strategies will cause device\n placements to be hard-coded in a function. Exporting a single-device\n computation and importing under a `DistributionStrategy` is not currently\n supported, but may be in the future.\n\n SavedModels exported with `tf.saved_model.save` [strip default-valued\n attributes](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/python/saved_model/README.md#stripping-default-valued-attributes)\n automatically, which removes one source of incompatibilities when the consumer\n of a SavedModel is running an older TensorFlow version than the\n producer. There are however other sources of incompatibilities which are not\n handled automatically, such as when the exported model contains operations\n which the consumer does not have definitions for.\n\n Args:\n obj: A trackable object to export.\n export_dir: A directory in which to write the SavedModel.\n signatures: Optional, either a `tf.function` with an input signature\n specified or the result of `f.get_concrete_function` on a\n `@tf.function`-decorated function `f`, in which case `f` will be used to\n generate a signature for the SavedModel under the default serving\n signature key. `signatures` may also be a dictionary, in which case it\n maps from signature keys to either `tf.function` instances with input\n signatures or concrete functions. The keys of such a dictionary may be\n arbitrary strings, but will typically be from the\n `tf.saved_model.signature_constants` module.\n\n Raises:\n ValueError: If `obj` is not trackable.\n\n @compatibility(eager)\n Not well supported when graph building. From TensorFlow 1.x,\n `tf.compat.v1.enable_eager_execution()` should run first. Calling\n tf.saved_model.save in a loop when graph building from TensorFlow 1.x will\n add new save operations to the default graph each iteration.\n\n May not be called from within a function body.\n @end_compatibility\n \"\"\"\n if ops.inside_function():\n raise AssertionError(\n \"tf.saved_model.save is not supported inside a traced \"\n \"@tf.function. Move the call to the outer eagerly-executed \"\n \"context.\")\n # pylint: enable=line-too-long\n if not isinstance(obj, base.Trackable):\n raise ValueError(\n \"Expected a Trackable object for export, got {}.\".format(obj))\n\n checkpoint_graph_view = _AugmentedGraphView(obj)\n if signatures is None:\n signatures = signature_serialization.find_function_to_export(\n checkpoint_graph_view)\n\n signatures = signature_serialization.canonicalize_signatures(signatures)\n signature_serialization.validate_saveable_view(checkpoint_graph_view)\n signature_map = signature_serialization.create_signature_map(signatures)\n checkpoint_graph_view.add_object(\n parent_node=checkpoint_graph_view.root,\n name_in_parent=signature_serialization.SIGNATURE_ATTRIBUTE_NAME,\n subgraph_root=signature_map)\n\n # Use _SaveableView to provide a frozen listing of properties and functions.\n # Note we run this twice since, while constructing the view the first time\n # there can be side effects of creating variables.\n _ = _SaveableView(checkpoint_graph_view)\n saveable_view = _SaveableView(checkpoint_graph_view)\n\n # TODO(allenl): Factor out some subset of SavedModelBuilder which is 2.x\n # compatible (no sessions) and share it with this export API rather than\n # making a SavedModel proto and writing it directly.\n saved_model = saved_model_pb2.SavedModel()\n meta_graph_def = saved_model.meta_graphs.add()\n object_saver = util.TrackableSaver(checkpoint_graph_view)\n asset_info, exported_graph = _fill_meta_graph_def(\n meta_graph_def, saveable_view, signatures)\n saved_model.saved_model_schema_version = (\n constants.SAVED_MODEL_SCHEMA_VERSION)\n # So far we've just been generating protocol buffers with no I/O. Now we write\n # the checkpoint, copy assets into the assets directory, and write out the\n # SavedModel proto itself.\n utils_impl.get_or_create_variables_dir(export_dir)\n object_saver.save(utils_impl.get_variables_path(export_dir))\n builder_impl.copy_assets_to_destination_dir(asset_info.asset_filename_map,\n export_dir)\n path = os.path.join(\n compat.as_bytes(export_dir),\n compat.as_bytes(constants.SAVED_MODEL_FILENAME_PB))\n object_graph_proto = _serialize_object_graph(\n saveable_view, asset_info.asset_index)\n meta_graph_def.object_graph_def.CopyFrom(object_graph_proto)\n file_io.write_string_to_file(path, saved_model.SerializeToString())\n # Clean reference cycles so repeated export()s don't make work for the garbage\n # collector. Before this point we need to keep references to captured\n # constants in the saved graph.\n ops.dismantle_graph(exported_graph)\n"
] | [
[
"tensorflow.python.training.tracking.object_identity.ObjectIdentityDictionary",
"tensorflow.python.util.compat.as_str_any",
"tensorflow.python.saved_model.utils_impl.get_variables_path",
"tensorflow.core.protobuf.meta_graph_pb2.AssetFileDef",
"tensorflow.python.saved_model.builder_impl.copy_assets_to_destination_dir",
"tensorflow.python.ops.array_ops.placeholder",
"tensorflow.python.training.tracking.object_identity.ObjectIdentityWeakKeyDictionary",
"tensorflow.python.framework.ops.device",
"tensorflow.python.ops.control_flow_ops.no_op",
"tensorflow.python.eager.context.context",
"tensorflow.python.eager.context.executing_eagerly",
"tensorflow.core.protobuf.saved_model_pb2.SavedModel",
"tensorflow.python.saved_model.builder_impl.get_asset_filename_to_add",
"tensorflow.python.framework.ops.inside_function",
"tensorflow.python.ops.resource_variable_ops.ResourceVariable",
"tensorflow.python.util.tf_export.tf_export",
"tensorflow.python.saved_model.signature_serialization.find_function_to_export",
"tensorflow.python.framework.tensor_util.constant_value",
"tensorflow.python.framework.meta_graph.stripped_op_list_for_graph",
"tensorflow.python.training.tracking.base.TrackableReference",
"tensorflow.python.saved_model.function_serialization.serialize_function",
"tensorflow.python.framework.ops.control_dependencies",
"tensorflow.python.framework.ops.dismantle_graph",
"tensorflow.python.saved_model.revived_types.serialize",
"tensorflow.python.saved_model.signature_serialization.canonicalize_signatures",
"tensorflow.python.framework.tensor_util.is_tensor",
"tensorflow.python.saved_model.nested_structure_coder.StructureCoder",
"tensorflow.python.training.tracking.util.TrackableSaver",
"tensorflow.python.framework.meta_graph.strip_graph_default_valued_attrs",
"tensorflow.python.ops.resource_variable_ops.copy_to_graph_uninitialized",
"tensorflow.python.saved_model.signature_serialization.create_signature_map",
"tensorflow.core.protobuf.saved_object_graph_pb2.SavedObjectGraph",
"tensorflow.python.saved_model.signature_def_utils.op_signature_def",
"tensorflow.python.saved_model.function_serialization.serialize_bare_concrete_function",
"tensorflow.python.framework.ops.Graph",
"tensorflow.python.saved_model.signature_serialization.validate_saveable_view",
"tensorflow.python.util.compat.as_bytes",
"tensorflow.core.framework.versions_pb2.VersionDef",
"tensorflow.python.framework.meta_graph._op_name",
"tensorflow.python.saved_model.utils_impl.build_tensor_info_internal",
"tensorflow.python.ops.resource_variable_ops.is_resource_variable",
"tensorflow.python.saved_model.function_serialization.serialize_concrete_function",
"tensorflow.python.saved_model.utils_impl.get_or_create_variables_dir",
"tensorflow.python.framework.constant_op.constant"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"2.8",
"2.7",
"2.6",
"2.4",
"2.3",
"2.9",
"2.5",
"2.2",
"2.10"
]
}
] |
Jianrong-Lu/MONAI | [
"c319ca8ff31aa980a045f1b913fb2eb22aadb080",
"c319ca8ff31aa980a045f1b913fb2eb22aadb080"
] | [
"monai/transforms/spatial/array.py",
"monai/utils/misc.py"
] | [
"# Copyright (c) MONAI Consortium\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\"\"\"\nA collection of \"vanilla\" transforms for spatial operations\nhttps://github.com/Project-MONAI/MONAI/wiki/MONAI_Design\n\"\"\"\nimport warnings\nfrom copy import deepcopy\nfrom typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Union\n\nimport numpy as np\nimport torch\n\nfrom monai.config import USE_COMPILED, DtypeLike\nfrom monai.config.type_definitions import NdarrayOrTensor\nfrom monai.data.utils import AFFINE_TOL, compute_shape_offset, reorient_spatial_axes, to_affine_nd, zoom_affine\nfrom monai.networks.layers import AffineTransform, GaussianFilter, grid_pull\nfrom monai.networks.utils import meshgrid_ij, normalize_transform\nfrom monai.transforms.croppad.array import CenterSpatialCrop, Pad\nfrom monai.transforms.transform import Randomizable, RandomizableTransform, ThreadUnsafe, Transform\nfrom monai.transforms.utils import (\n create_control_grid,\n create_grid,\n create_rotate,\n create_scale,\n create_shear,\n create_translate,\n map_spatial_axes,\n)\nfrom monai.transforms.utils_pytorch_numpy_unification import allclose, moveaxis\nfrom monai.utils import (\n GridSampleMode,\n GridSamplePadMode,\n InterpolateMode,\n NumpyPadMode,\n PytorchPadMode,\n ensure_tuple,\n ensure_tuple_rep,\n ensure_tuple_size,\n fall_back_tuple,\n issequenceiterable,\n optional_import,\n pytorch_after,\n)\nfrom monai.utils.deprecate_utils import deprecated_arg\nfrom monai.utils.enums import TransformBackends\nfrom monai.utils.module import look_up_option\nfrom monai.utils.type_conversion import convert_data_type, convert_to_dst_type\n\nnib, has_nib = optional_import(\"nibabel\")\n\n__all__ = [\n \"SpatialResample\",\n \"ResampleToMatch\",\n \"Spacing\",\n \"Orientation\",\n \"Flip\",\n \"GridDistortion\",\n \"Resize\",\n \"Rotate\",\n \"Zoom\",\n \"Rotate90\",\n \"RandRotate90\",\n \"RandRotate\",\n \"RandFlip\",\n \"RandGridDistortion\",\n \"RandAxisFlip\",\n \"RandZoom\",\n \"AffineGrid\",\n \"RandAffineGrid\",\n \"RandDeformGrid\",\n \"Resample\",\n \"Affine\",\n \"RandAffine\",\n \"Rand2DElastic\",\n \"Rand3DElastic\",\n]\n\nRandRange = Optional[Union[Sequence[Union[Tuple[float, float], float]], float]]\n\n\nclass SpatialResample(Transform):\n \"\"\"\n Resample input image from the orientation/spacing defined by ``src_affine`` affine matrix into\n the ones specified by ``dst_affine`` affine matrix.\n\n Internally this transform computes the affine transform matrix from ``src_affine`` to ``dst_affine``,\n by ``xform = linalg.solve(src_affine, dst_affine)``, and call ``monai.transforms.Affine`` with ``xform``.\n \"\"\"\n\n backend = [TransformBackends.TORCH]\n\n def __init__(\n self,\n mode: Union[GridSampleMode, str] = GridSampleMode.BILINEAR,\n padding_mode: Union[GridSamplePadMode, str] = GridSamplePadMode.BORDER,\n align_corners: bool = False,\n dtype: DtypeLike = np.float64,\n ):\n \"\"\"\n Args:\n mode: {``\"bilinear\"``, ``\"nearest\"``}\n Interpolation mode to calculate output values. Defaults to ``\"bilinear\"``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n When `USE_COMPILED` is `True`, this argument uses\n ``\"nearest\"``, ``\"bilinear\"``, ``\"bicubic\"`` to indicate 0, 1, 3 order interpolations.\n See also: https://docs.monai.io/en/stable/networks.html#grid-pull\n padding_mode: {``\"zeros\"``, ``\"border\"``, ``\"reflection\"``}\n Padding mode for outside grid values. Defaults to ``\"border\"``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n align_corners: Geometrically, we consider the pixels of the input as squares rather than points.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n dtype: data type for resampling computation. Defaults to ``np.float64`` for best precision.\n If ``None``, use the data type of input data. To be compatible with other modules,\n the output data type is always ``np.float32``.\n \"\"\"\n self.mode = mode\n self.padding_mode = padding_mode\n self.align_corners = align_corners\n self.dtype = dtype\n\n def __call__(\n self,\n img: NdarrayOrTensor,\n src_affine: Optional[NdarrayOrTensor] = None,\n dst_affine: Optional[NdarrayOrTensor] = None,\n spatial_size: Optional[Union[Sequence[int], np.ndarray, int]] = None,\n mode: Union[GridSampleMode, str, None] = GridSampleMode.BILINEAR,\n padding_mode: Union[GridSamplePadMode, str, None] = GridSamplePadMode.BORDER,\n align_corners: Optional[bool] = False,\n dtype: DtypeLike = None,\n ) -> Tuple[NdarrayOrTensor, NdarrayOrTensor]:\n \"\"\"\n Args:\n img: input image to be resampled. It currently supports channel-first arrays with\n at most three spatial dimensions.\n src_affine: source affine matrix. Defaults to ``None``, which means the identity matrix.\n the shape should be `(r+1, r+1)` where `r` is the spatial rank of ``img``.\n dst_affine: destination affine matrix. Defaults to ``None``, which means the same as `src_affine`.\n the shape should be `(r+1, r+1)` where `r` is the spatial rank of ``img``.\n when `dst_affine` and `spatial_size` are None, the input will be returned without resampling,\n but the data type will be `float32`.\n spatial_size: output image spatial size.\n if `spatial_size` and `self.spatial_size` are not defined,\n the transform will compute a spatial size automatically containing the previous field of view.\n if `spatial_size` is ``-1`` are the transform will use the corresponding input img size.\n mode: {``\"bilinear\"``, ``\"nearest\"``}\n Interpolation mode to calculate output values. Defaults to ``\"bilinear\"``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n When `USE_COMPILED` is `True`, this argument uses\n ``\"nearest\"``, ``\"bilinear\"``, ``\"bicubic\"`` to indicate 0, 1, 3 order interpolations.\n See also: https://docs.monai.io/en/stable/networks.html#grid-pull\n padding_mode: {``\"zeros\"``, ``\"border\"``, ``\"reflection\"``}\n Padding mode for outside grid values. Defaults to ``\"border\"``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n align_corners: Geometrically, we consider the pixels of the input as squares rather than points.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n dtype: data type for resampling computation. Defaults to ``self.dtype`` or\n ``np.float64`` (for best precision). If ``None``, use the data type of input data.\n To be compatible with other modules, the output data type is always `float32`.\n\n The spatial rank is determined by the smallest among ``img.ndim -1``, ``len(src_affine) - 1``, and ``3``.\n\n When both ``monai.config.USE_COMPILED`` and ``align_corners`` are set to ``True``,\n MONAI's resampling implementation will be used.\n Set `dst_affine` and `spatial_size` to `None` to turn off the resampling step.\n \"\"\"\n if src_affine is None:\n src_affine = np.eye(4, dtype=np.float64)\n spatial_rank = min(len(img.shape) - 1, src_affine.shape[0] - 1, 3)\n if (not isinstance(spatial_size, int) or spatial_size != -1) and spatial_size is not None:\n spatial_rank = min(len(ensure_tuple(spatial_size)), 3) # infer spatial rank based on spatial_size\n src_affine = to_affine_nd(spatial_rank, src_affine)\n dst_affine = to_affine_nd(spatial_rank, dst_affine) if dst_affine is not None else src_affine\n dst_affine, *_ = convert_to_dst_type(dst_affine, dst_affine, dtype=torch.float32)\n\n in_spatial_size = np.asarray(img.shape[1 : spatial_rank + 1])\n if isinstance(spatial_size, int) and (spatial_size == -1): # using the input spatial size\n spatial_size = in_spatial_size\n elif spatial_size is None and spatial_rank > 1: # auto spatial size\n spatial_size, _ = compute_shape_offset(in_spatial_size, src_affine, dst_affine) # type: ignore\n spatial_size = np.asarray(fall_back_tuple(ensure_tuple(spatial_size)[:spatial_rank], in_spatial_size))\n\n if (\n allclose(src_affine, dst_affine, atol=AFFINE_TOL)\n and allclose(spatial_size, in_spatial_size)\n or spatial_rank == 1\n ):\n # no significant change, return original image\n output_data, *_ = convert_to_dst_type(img, img, dtype=torch.float32)\n return output_data, dst_affine\n\n if has_nib and isinstance(img, np.ndarray):\n spatial_ornt, dst_r = reorient_spatial_axes(img.shape[1 : spatial_rank + 1], src_affine, dst_affine)\n if allclose(dst_r, dst_affine, atol=AFFINE_TOL) and allclose(spatial_size, in_spatial_size):\n # simple reorientation achieves the desired affine\n spatial_ornt[:, 0] += 1\n spatial_ornt = np.concatenate([np.array([[0, 1]]), spatial_ornt])\n img_ = nib.orientations.apply_orientation(img, spatial_ornt)\n output_data, *_ = convert_to_dst_type(img_, img, dtype=torch.float32)\n return output_data, dst_affine\n\n try:\n src_affine, *_ = convert_to_dst_type(src_affine, dst_affine)\n if isinstance(src_affine, np.ndarray):\n xform = np.linalg.solve(src_affine, dst_affine)\n else:\n xform = (\n torch.linalg.solve(src_affine, dst_affine)\n if pytorch_after(1, 8, 0)\n else torch.solve(dst_affine, src_affine).solution # type: ignore\n )\n except (np.linalg.LinAlgError, RuntimeError) as e:\n raise ValueError(f\"src affine is not invertible: {src_affine}\") from e\n xform = to_affine_nd(spatial_rank, xform)\n # no resampling if it's identity transform\n if allclose(xform, np.diag(np.ones(len(xform))), atol=AFFINE_TOL) and allclose(spatial_size, in_spatial_size):\n output_data, *_ = convert_to_dst_type(img, img, dtype=torch.float32)\n return output_data, dst_affine\n\n _dtype = dtype or self.dtype or img.dtype\n in_spatial_size = in_spatial_size.tolist()\n chns, additional_dims = img.shape[0], img.shape[spatial_rank + 1 :] # beyond three spatial dims\n # resample\n img_ = convert_data_type(img, torch.Tensor, dtype=_dtype)[0]\n xform = convert_to_dst_type(xform, img_)[0]\n align_corners = self.align_corners if align_corners is None else align_corners\n mode = mode or self.mode\n padding_mode = padding_mode or self.padding_mode\n if additional_dims:\n xform_shape = [-1] + in_spatial_size\n img_ = img_.reshape(xform_shape)\n if align_corners:\n _t_r = torch.diag(torch.ones(len(xform), dtype=xform.dtype, device=xform.device)) # type: ignore\n for idx, d_dst in enumerate(spatial_size[:spatial_rank]):\n _t_r[idx, -1] = (max(d_dst, 2) - 1.0) / 2.0\n xform = xform @ _t_r\n if not USE_COMPILED:\n _t_l = normalize_transform(\n in_spatial_size, xform.device, xform.dtype, align_corners=True # type: ignore\n )\n xform = _t_l @ xform # type: ignore\n affine_xform = Affine(\n affine=xform, spatial_size=spatial_size, norm_coords=False, image_only=True, dtype=_dtype\n )\n output_data = affine_xform(img_, mode=mode, padding_mode=padding_mode)\n else:\n affine_xform = AffineTransform(\n normalized=False,\n mode=mode,\n padding_mode=padding_mode,\n align_corners=align_corners,\n reverse_indexing=True,\n )\n output_data = affine_xform(img_.unsqueeze(0), theta=xform, spatial_size=spatial_size).squeeze(0)\n if additional_dims:\n full_shape = (chns, *spatial_size, *additional_dims)\n output_data = output_data.reshape(full_shape)\n # output dtype float\n output_data, *_ = convert_to_dst_type(output_data, img, dtype=torch.float32)\n return output_data, dst_affine\n\n\nclass ResampleToMatch(SpatialResample):\n \"\"\"Resample an image to match given meta data. The affine matrix will be aligned,\n and the size of the output image will match.\"\"\"\n\n def __call__( # type: ignore\n self,\n img: NdarrayOrTensor,\n src_meta: Optional[Dict] = None,\n dst_meta: Optional[Dict] = None,\n mode: Union[GridSampleMode, str, None] = GridSampleMode.BILINEAR,\n padding_mode: Union[GridSamplePadMode, str, None] = GridSamplePadMode.BORDER,\n align_corners: Optional[bool] = False,\n dtype: DtypeLike = None,\n ):\n if src_meta is None:\n raise RuntimeError(\"`in_meta` is missing\")\n if dst_meta is None:\n raise RuntimeError(\"`out_meta` is missing\")\n mode = mode or self.mode\n padding_mode = padding_mode or self.padding_mode\n align_corners = self.align_corners if align_corners is None else align_corners\n dtype = dtype or self.dtype\n src_affine = src_meta.get(\"affine\")\n dst_affine = dst_meta.get(\"affine\")\n img, updated_affine = super().__call__(\n img=img,\n src_affine=src_affine,\n dst_affine=dst_affine,\n spatial_size=dst_meta.get(\"spatial_shape\"),\n mode=mode,\n padding_mode=padding_mode,\n align_corners=align_corners,\n dtype=dtype,\n )\n dst_meta = deepcopy(dst_meta)\n dst_meta[\"affine\"] = updated_affine\n return img, dst_meta\n\n\nclass Spacing(Transform):\n \"\"\"\n Resample input image into the specified `pixdim`.\n \"\"\"\n\n backend = SpatialResample.backend\n\n def __init__(\n self,\n pixdim: Union[Sequence[float], float, np.ndarray],\n diagonal: bool = False,\n mode: Union[GridSampleMode, str] = GridSampleMode.BILINEAR,\n padding_mode: Union[GridSamplePadMode, str] = GridSamplePadMode.BORDER,\n align_corners: bool = False,\n dtype: DtypeLike = np.float64,\n image_only: bool = False,\n ) -> None:\n \"\"\"\n Args:\n pixdim: output voxel spacing. if providing a single number, will use it for the first dimension.\n items of the pixdim sequence map to the spatial dimensions of input image, if length\n of pixdim sequence is longer than image spatial dimensions, will ignore the longer part,\n if shorter, will pad with `1.0`.\n if the components of the `pixdim` are non-positive values, the transform will use the\n corresponding components of the original pixdim, which is computed from the `affine`\n matrix of input image.\n diagonal: whether to resample the input to have a diagonal affine matrix.\n If True, the input data is resampled to the following affine::\n\n np.diag((pixdim_0, pixdim_1, ..., pixdim_n, 1))\n\n This effectively resets the volume to the world coordinate system (RAS+ in nibabel).\n The original orientation, rotation, shearing are not preserved.\n\n If False, this transform preserves the axes orientation, orthogonal rotation and\n translation components from the original affine. This option will not flip/swap axes\n of the original data.\n mode: {``\"bilinear\"``, ``\"nearest\"``}\n Interpolation mode to calculate output values. Defaults to ``\"bilinear\"``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n When `USE_COMPILED` is `True`, this argument uses\n ``\"nearest\"``, ``\"bilinear\"``, ``\"bicubic\"`` to indicate 0, 1, 3 order interpolations.\n See also: https://docs.monai.io/en/stable/networks.html#grid-pull\n padding_mode: {``\"zeros\"``, ``\"border\"``, ``\"reflection\"``}\n Padding mode for outside grid values. Defaults to ``\"border\"``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n align_corners: Geometrically, we consider the pixels of the input as squares rather than points.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n dtype: data type for resampling computation. Defaults to ``np.float64`` for best precision.\n If None, use the data type of input data. To be compatible with other modules,\n the output data type is always ``np.float32``.\n image_only: return just the image or the image, the old affine and new affine. Default is `False`.\n\n \"\"\"\n self.pixdim = np.array(ensure_tuple(pixdim), dtype=np.float64)\n self.diagonal = diagonal\n self.image_only = image_only\n\n self.sp_resample = SpatialResample(\n mode=look_up_option(mode, GridSampleMode),\n padding_mode=look_up_option(padding_mode, GridSamplePadMode),\n align_corners=align_corners,\n dtype=dtype,\n )\n\n def __call__(\n self,\n data_array: NdarrayOrTensor,\n affine: Optional[NdarrayOrTensor] = None,\n mode: Optional[Union[GridSampleMode, str]] = None,\n padding_mode: Optional[Union[GridSamplePadMode, str]] = None,\n align_corners: Optional[bool] = None,\n dtype: DtypeLike = None,\n output_spatial_shape: Optional[Union[Sequence[int], np.ndarray, int]] = None,\n ) -> Union[NdarrayOrTensor, Tuple[NdarrayOrTensor, NdarrayOrTensor, NdarrayOrTensor]]:\n \"\"\"\n Args:\n data_array: in shape (num_channels, H[, W, ...]).\n affine (matrix): (N+1)x(N+1) original affine matrix for spatially ND `data_array`. Defaults to identity.\n mode: {``\"bilinear\"``, ``\"nearest\"``}\n Interpolation mode to calculate output values. Defaults to ``self.mode``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n When `USE_COMPILED` is `True`, this argument uses\n ``\"nearest\"``, ``\"bilinear\"``, ``\"bicubic\"`` to indicate 0, 1, 3 order interpolations.\n See also: https://docs.monai.io/en/stable/networks.html#grid-pull\n padding_mode: {``\"zeros\"``, ``\"border\"``, ``\"reflection\"``}\n Padding mode for outside grid values. Defaults to ``self.padding_mode``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n align_corners: Geometrically, we consider the pixels of the input as squares rather than points.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n dtype: data type for resampling computation. Defaults to ``self.dtype``.\n If None, use the data type of input data. To be compatible with other modules,\n the output data type is always ``np.float32``.\n output_spatial_shape: specify the shape of the output data_array. This is typically useful for\n the inverse of `Spacingd` where sometimes we could not compute the exact shape due to the quantization\n error with the affine.\n\n Raises:\n ValueError: When ``data_array`` has no spatial dimensions.\n ValueError: When ``pixdim`` is nonpositive.\n\n Returns:\n data_array (resampled into `self.pixdim`), original affine, current affine.\n\n \"\"\"\n sr = int(data_array.ndim - 1)\n if sr <= 0:\n raise ValueError(\"data_array must have at least one spatial dimension.\")\n if affine is None:\n # default to identity\n affine_np = affine = np.eye(sr + 1, dtype=np.float64)\n affine_ = np.eye(sr + 1, dtype=np.float64)\n else:\n affine_np, *_ = convert_data_type(affine, np.ndarray)\n affine_ = to_affine_nd(sr, affine_np)\n\n out_d = self.pixdim[:sr]\n if out_d.size < sr:\n out_d = np.append(out_d, [1.0] * (sr - out_d.size))\n\n # compute output affine, shape and offset\n new_affine = zoom_affine(affine_, out_d, diagonal=self.diagonal)\n output_shape, offset = compute_shape_offset(data_array.shape[1:], affine_, new_affine)\n new_affine[:sr, -1] = offset[:sr]\n output_data, new_affine = self.sp_resample(\n data_array,\n src_affine=affine,\n dst_affine=new_affine,\n spatial_size=list(output_shape) if output_spatial_shape is None else output_spatial_shape,\n mode=mode,\n padding_mode=padding_mode,\n align_corners=align_corners,\n dtype=dtype,\n )\n new_affine = to_affine_nd(affine_np, new_affine)\n new_affine, *_ = convert_to_dst_type(src=new_affine, dst=affine, dtype=torch.float32)\n\n if self.image_only:\n return output_data\n return output_data, affine, new_affine\n\n\nclass Orientation(Transform):\n \"\"\"\n Change the input image's orientation into the specified based on `axcodes`.\n \"\"\"\n\n backend = [TransformBackends.NUMPY, TransformBackends.TORCH]\n\n def __init__(\n self,\n axcodes: Optional[str] = None,\n as_closest_canonical: bool = False,\n labels: Optional[Sequence[Tuple[str, str]]] = tuple(zip(\"LPI\", \"RAS\")),\n image_only: bool = False,\n ) -> None:\n \"\"\"\n Args:\n axcodes: N elements sequence for spatial ND input's orientation.\n e.g. axcodes='RAS' represents 3D orientation:\n (Left, Right), (Posterior, Anterior), (Inferior, Superior).\n default orientation labels options are: 'L' and 'R' for the first dimension,\n 'P' and 'A' for the second, 'I' and 'S' for the third.\n as_closest_canonical: if True, load the image as closest to canonical axis format.\n labels: optional, None or sequence of (2,) sequences\n (2,) sequences are labels for (beginning, end) of output axis.\n Defaults to ``(('L', 'R'), ('P', 'A'), ('I', 'S'))``.\n image_only: if True return only the image volume, otherwise return (image, affine, new_affine).\n\n Raises:\n ValueError: When ``axcodes=None`` and ``as_closest_canonical=True``. Incompatible values.\n\n See Also: `nibabel.orientations.ornt2axcodes`.\n\n \"\"\"\n if axcodes is None and not as_closest_canonical:\n raise ValueError(\"Incompatible values: axcodes=None and as_closest_canonical=True.\")\n if axcodes is not None and as_closest_canonical:\n warnings.warn(\"using as_closest_canonical=True, axcodes ignored.\")\n self.axcodes = axcodes\n self.as_closest_canonical = as_closest_canonical\n self.labels = labels\n self.image_only = image_only\n\n def __call__(\n self, data_array: NdarrayOrTensor, affine: Optional[NdarrayOrTensor] = None\n ) -> Union[NdarrayOrTensor, Tuple[NdarrayOrTensor, NdarrayOrTensor, NdarrayOrTensor]]:\n \"\"\"\n original orientation of `data_array` is defined by `affine`.\n\n Args:\n data_array: in shape (num_channels, H[, W, ...]).\n affine (matrix): (N+1)x(N+1) original affine matrix for spatially ND `data_array`. Defaults to identity.\n\n Raises:\n ValueError: When ``data_array`` has no spatial dimensions.\n ValueError: When ``axcodes`` spatiality differs from ``data_array``.\n\n Returns:\n data_array [reoriented in `self.axcodes`] if `self.image_only`, else\n (data_array [reoriented in `self.axcodes`], original axcodes, current axcodes).\n\n \"\"\"\n spatial_shape = data_array.shape[1:]\n sr = len(spatial_shape)\n if sr <= 0:\n raise ValueError(\"data_array must have at least one spatial dimension.\")\n affine_: np.ndarray\n if affine is None:\n # default to identity\n affine_np = affine = np.eye(sr + 1, dtype=np.float64)\n affine_ = np.eye(sr + 1, dtype=np.float64)\n else:\n affine_np, *_ = convert_data_type(affine, np.ndarray)\n affine_ = to_affine_nd(sr, affine_np)\n\n src = nib.io_orientation(affine_)\n if self.as_closest_canonical:\n spatial_ornt = src\n else:\n if self.axcodes is None:\n raise ValueError(\"Incompatible values: axcodes=None and as_closest_canonical=True.\")\n if sr < len(self.axcodes):\n warnings.warn(\n f\"axcodes ('{self.axcodes}') length is smaller than the number of input spatial dimensions D={sr}.\\n\"\n f\"{self.__class__.__name__}: input spatial shape is {spatial_shape}, num. channels is {data_array.shape[0]},\"\n \"please make sure the input is in the channel-first format.\"\n )\n dst = nib.orientations.axcodes2ornt(self.axcodes[:sr], labels=self.labels)\n if len(dst) < sr:\n raise ValueError(\n f\"axcodes must match data_array spatially, got axcodes={len(self.axcodes)}D data_array={sr}D\"\n )\n spatial_ornt = nib.orientations.ornt_transform(src, dst)\n new_affine = affine_ @ nib.orientations.inv_ornt_aff(spatial_ornt, spatial_shape)\n _is_tensor = isinstance(data_array, torch.Tensor)\n spatial_ornt[:, 0] += 1 # skip channel dim\n spatial_ornt = np.concatenate([np.array([[0, 1]]), spatial_ornt])\n axes = [ax for ax, flip in enumerate(spatial_ornt[:, 1]) if flip == -1]\n if axes:\n data_array = (\n torch.flip(data_array, dims=axes) if _is_tensor else np.flip(data_array, axis=axes) # type: ignore\n )\n full_transpose = np.arange(len(data_array.shape))\n full_transpose[: len(spatial_ornt)] = np.argsort(spatial_ornt[:, 0])\n if not np.all(full_transpose == np.arange(len(data_array.shape))):\n if _is_tensor:\n data_array = data_array.permute(full_transpose.tolist()) # type: ignore\n else:\n data_array = data_array.transpose(full_transpose) # type: ignore\n out, *_ = convert_to_dst_type(src=data_array, dst=data_array)\n new_affine = to_affine_nd(affine_np, new_affine)\n new_affine, *_ = convert_to_dst_type(src=new_affine, dst=affine, dtype=torch.float32)\n\n if self.image_only:\n return out\n return out, affine, new_affine\n\n\nclass Flip(Transform):\n \"\"\"\n Reverses the order of elements along the given spatial axis. Preserves shape.\n Uses ``np.flip`` in practice. See numpy.flip for additional details:\n https://docs.scipy.org/doc/numpy/reference/generated/numpy.flip.html.\n\n Args:\n spatial_axis: spatial axes along which to flip over. Default is None.\n The default `axis=None` will flip over all of the axes of the input array.\n If axis is negative it counts from the last to the first axis.\n If axis is a tuple of ints, flipping is performed on all of the axes\n specified in the tuple.\n\n \"\"\"\n\n backend = [TransformBackends.TORCH, TransformBackends.NUMPY]\n\n def __init__(self, spatial_axis: Optional[Union[Sequence[int], int]] = None) -> None:\n self.spatial_axis = spatial_axis\n\n def __call__(self, img: NdarrayOrTensor) -> NdarrayOrTensor:\n \"\"\"\n Args:\n img: channel first array, must have shape: (num_channels, H[, W, ..., ]),\n \"\"\"\n if isinstance(img, np.ndarray):\n return np.ascontiguousarray(np.flip(img, map_spatial_axes(img.ndim, self.spatial_axis)))\n return torch.flip(img, map_spatial_axes(img.ndim, self.spatial_axis))\n\n\nclass Resize(Transform):\n \"\"\"\n Resize the input image to given spatial size (with scaling, not cropping/padding).\n Implemented using :py:class:`torch.nn.functional.interpolate`.\n\n Args:\n spatial_size: expected shape of spatial dimensions after resize operation.\n if some components of the `spatial_size` are non-positive values, the transform will use the\n corresponding components of img size. For example, `spatial_size=(32, -1)` will be adapted\n to `(32, 64)` if the second spatial dimension size of img is `64`.\n size_mode: should be \"all\" or \"longest\", if \"all\", will use `spatial_size` for all the spatial dims,\n if \"longest\", rescale the image so that only the longest side is equal to specified `spatial_size`,\n which must be an int number in this case, keeping the aspect ratio of the initial image, refer to:\n https://albumentations.ai/docs/api_reference/augmentations/geometric/resize/\n #albumentations.augmentations.geometric.resize.LongestMaxSize.\n mode: {``\"nearest\"``, ``\"linear\"``, ``\"bilinear\"``, ``\"bicubic\"``, ``\"trilinear\"``, ``\"area\"``}\n The interpolation mode. Defaults to ``\"area\"``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.interpolate.html\n align_corners: This only has an effect when mode is\n 'linear', 'bilinear', 'bicubic' or 'trilinear'. Default: None.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.interpolate.html\n \"\"\"\n\n backend = [TransformBackends.TORCH]\n\n def __init__(\n self,\n spatial_size: Union[Sequence[int], int],\n size_mode: str = \"all\",\n mode: Union[InterpolateMode, str] = InterpolateMode.AREA,\n align_corners: Optional[bool] = None,\n ) -> None:\n self.size_mode = look_up_option(size_mode, [\"all\", \"longest\"])\n self.spatial_size = spatial_size\n self.mode: InterpolateMode = look_up_option(mode, InterpolateMode)\n self.align_corners = align_corners\n\n def __call__(\n self,\n img: NdarrayOrTensor,\n mode: Optional[Union[InterpolateMode, str]] = None,\n align_corners: Optional[bool] = None,\n ) -> NdarrayOrTensor:\n \"\"\"\n Args:\n img: channel first array, must have shape: (num_channels, H[, W, ..., ]).\n mode: {``\"nearest\"``, ``\"linear\"``, ``\"bilinear\"``, ``\"bicubic\"``, ``\"trilinear\"``, ``\"area\"``}\n The interpolation mode. Defaults to ``self.mode``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.interpolate.html\n align_corners: This only has an effect when mode is\n 'linear', 'bilinear', 'bicubic' or 'trilinear'. Defaults to ``self.align_corners``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.interpolate.html\n\n Raises:\n ValueError: When ``self.spatial_size`` length is less than ``img`` spatial dimensions.\n\n \"\"\"\n img_, *_ = convert_data_type(img, torch.Tensor, dtype=torch.float)\n if self.size_mode == \"all\":\n input_ndim = img_.ndim - 1 # spatial ndim\n output_ndim = len(ensure_tuple(self.spatial_size))\n if output_ndim > input_ndim:\n input_shape = ensure_tuple_size(img_.shape, output_ndim + 1, 1)\n img_ = img_.reshape(input_shape)\n elif output_ndim < input_ndim:\n raise ValueError(\n \"len(spatial_size) must be greater or equal to img spatial dimensions, \"\n f\"got spatial_size={output_ndim} img={input_ndim}.\"\n )\n spatial_size_ = fall_back_tuple(self.spatial_size, img_.shape[1:])\n else: # for the \"longest\" mode\n img_size = img_.shape[1:]\n if not isinstance(self.spatial_size, int):\n raise ValueError(\"spatial_size must be an int number if size_mode is 'longest'.\")\n scale = self.spatial_size / max(img_size)\n spatial_size_ = tuple(int(round(s * scale)) for s in img_size)\n resized = torch.nn.functional.interpolate(\n input=img_.unsqueeze(0),\n size=spatial_size_,\n mode=look_up_option(self.mode if mode is None else mode, InterpolateMode).value,\n align_corners=self.align_corners if align_corners is None else align_corners,\n )\n out, *_ = convert_to_dst_type(resized.squeeze(0), img)\n return out\n\n\nclass Rotate(Transform, ThreadUnsafe):\n \"\"\"\n Rotates an input image by given angle using :py:class:`monai.networks.layers.AffineTransform`.\n\n Args:\n angle: Rotation angle(s) in radians. should a float for 2D, three floats for 3D.\n keep_size: If it is True, the output shape is kept the same as the input.\n If it is False, the output shape is adapted so that the\n input array is contained completely in the output. Default is True.\n mode: {``\"bilinear\"``, ``\"nearest\"``}\n Interpolation mode to calculate output values. Defaults to ``\"bilinear\"``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n padding_mode: {``\"zeros\"``, ``\"border\"``, ``\"reflection\"``}\n Padding mode for outside grid values. Defaults to ``\"border\"``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n align_corners: Defaults to False.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n dtype: data type for resampling computation. Defaults to ``np.float32``.\n If None, use the data type of input data. To be compatible with other modules,\n the output data type is always ``np.float32``.\n \"\"\"\n\n backend = [TransformBackends.TORCH]\n\n def __init__(\n self,\n angle: Union[Sequence[float], float],\n keep_size: bool = True,\n mode: Union[GridSampleMode, str] = GridSampleMode.BILINEAR,\n padding_mode: Union[GridSamplePadMode, str] = GridSamplePadMode.BORDER,\n align_corners: bool = False,\n dtype: Union[DtypeLike, torch.dtype] = np.float32,\n ) -> None:\n self.angle = angle\n self.keep_size = keep_size\n self.mode: GridSampleMode = look_up_option(mode, GridSampleMode)\n self.padding_mode: GridSamplePadMode = look_up_option(padding_mode, GridSamplePadMode)\n self.align_corners = align_corners\n self.dtype = dtype\n self._rotation_matrix: Optional[NdarrayOrTensor] = None\n\n def __call__(\n self,\n img: NdarrayOrTensor,\n mode: Optional[Union[GridSampleMode, str]] = None,\n padding_mode: Optional[Union[GridSamplePadMode, str]] = None,\n align_corners: Optional[bool] = None,\n dtype: Union[DtypeLike, torch.dtype] = None,\n ) -> NdarrayOrTensor:\n \"\"\"\n Args:\n img: channel first array, must have shape: [chns, H, W] or [chns, H, W, D].\n mode: {``\"bilinear\"``, ``\"nearest\"``}\n Interpolation mode to calculate output values. Defaults to ``self.mode``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n padding_mode: {``\"zeros\"``, ``\"border\"``, ``\"reflection\"``}\n Padding mode for outside grid values. Defaults to ``self.padding_mode``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n align_corners: Defaults to ``self.align_corners``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n align_corners: Defaults to ``self.align_corners``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n dtype: data type for resampling computation. Defaults to ``self.dtype``.\n If None, use the data type of input data. To be compatible with other modules,\n the output data type is always ``np.float32``.\n\n Raises:\n ValueError: When ``img`` spatially is not one of [2D, 3D].\n\n \"\"\"\n _dtype = dtype or self.dtype or img.dtype\n\n img_t, *_ = convert_data_type(img, torch.Tensor, dtype=_dtype)\n\n im_shape = np.asarray(img_t.shape[1:]) # spatial dimensions\n input_ndim = len(im_shape)\n if input_ndim not in (2, 3):\n raise ValueError(f\"Unsupported img dimension: {input_ndim}, available options are [2, 3].\")\n _angle = ensure_tuple_rep(self.angle, 1 if input_ndim == 2 else 3)\n transform = create_rotate(input_ndim, _angle)\n shift = create_translate(input_ndim, ((im_shape - 1) / 2).tolist())\n if self.keep_size:\n output_shape = im_shape\n else:\n corners = np.asarray(np.meshgrid(*[(0, dim) for dim in im_shape], indexing=\"ij\")).reshape(\n (len(im_shape), -1)\n )\n corners = transform[:-1, :-1] @ corners # type: ignore\n output_shape = np.asarray(corners.ptp(axis=1) + 0.5, dtype=int)\n shift_1 = create_translate(input_ndim, (-(output_shape - 1) / 2).tolist())\n transform = shift @ transform @ shift_1\n\n transform_t, *_ = convert_to_dst_type(transform, img_t)\n\n xform = AffineTransform(\n normalized=False,\n mode=look_up_option(mode or self.mode, GridSampleMode),\n padding_mode=look_up_option(padding_mode or self.padding_mode, GridSamplePadMode),\n align_corners=self.align_corners if align_corners is None else align_corners,\n reverse_indexing=True,\n )\n output: torch.Tensor = xform(img_t.unsqueeze(0), transform_t, spatial_size=output_shape).float().squeeze(0)\n self._rotation_matrix = transform\n out: NdarrayOrTensor\n out, *_ = convert_to_dst_type(output, dst=img, dtype=output.dtype)\n return out\n\n def get_rotation_matrix(self) -> Optional[NdarrayOrTensor]:\n \"\"\"\n Get the most recently applied rotation matrix\n This is not thread-safe.\n \"\"\"\n return self._rotation_matrix\n\n\nclass Zoom(Transform):\n \"\"\"\n Zooms an ND image using :py:class:`torch.nn.functional.interpolate`.\n For details, please see https://pytorch.org/docs/stable/generated/torch.nn.functional.interpolate.html.\n\n Different from :py:class:`monai.transforms.resize`, this transform takes scaling factors\n as input, and provides an option of preserving the input spatial size.\n\n Args:\n zoom: The zoom factor along the spatial axes.\n If a float, zoom is the same for each spatial axis.\n If a sequence, zoom should contain one value for each spatial axis.\n mode: {``\"nearest\"``, ``\"linear\"``, ``\"bilinear\"``, ``\"bicubic\"``, ``\"trilinear\"``, ``\"area\"``}\n The interpolation mode. Defaults to ``\"area\"``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.interpolate.html\n padding_mode: available modes for numpy array:{``\"constant\"``, ``\"edge\"``, ``\"linear_ramp\"``, ``\"maximum\"``,\n ``\"mean\"``, ``\"median\"``, ``\"minimum\"``, ``\"reflect\"``, ``\"symmetric\"``, ``\"wrap\"``, ``\"empty\"``}\n available modes for PyTorch Tensor: {``\"constant\"``, ``\"reflect\"``, ``\"replicate\"``, ``\"circular\"``}.\n One of the listed string values or a user supplied function. Defaults to ``\"constant\"``.\n The mode to pad data after zooming.\n See also: https://numpy.org/doc/1.18/reference/generated/numpy.pad.html\n https://pytorch.org/docs/stable/generated/torch.nn.functional.pad.html\n align_corners: This only has an effect when mode is\n 'linear', 'bilinear', 'bicubic' or 'trilinear'. Default: None.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.interpolate.html\n keep_size: Should keep original size (padding/slicing if needed), default is True.\n kwargs: other arguments for the `np.pad` or `torch.pad` function.\n note that `np.pad` treats channel dimension as the first dimension.\n\n \"\"\"\n\n backend = [TransformBackends.TORCH]\n\n def __init__(\n self,\n zoom: Union[Sequence[float], float],\n mode: Union[InterpolateMode, str] = InterpolateMode.AREA,\n padding_mode: Union[NumpyPadMode, PytorchPadMode, str] = NumpyPadMode.EDGE,\n align_corners: Optional[bool] = None,\n keep_size: bool = True,\n **kwargs,\n ) -> None:\n self.zoom = zoom\n self.mode: InterpolateMode = InterpolateMode(mode)\n self.padding_mode = padding_mode\n self.align_corners = align_corners\n self.keep_size = keep_size\n self.kwargs = kwargs\n\n def __call__(\n self,\n img: NdarrayOrTensor,\n mode: Optional[Union[InterpolateMode, str]] = None,\n padding_mode: Optional[Union[NumpyPadMode, PytorchPadMode, str]] = None,\n align_corners: Optional[bool] = None,\n ) -> NdarrayOrTensor:\n \"\"\"\n Args:\n img: channel first array, must have shape: (num_channels, H[, W, ..., ]).\n mode: {``\"nearest\"``, ``\"linear\"``, ``\"bilinear\"``, ``\"bicubic\"``, ``\"trilinear\"``, ``\"area\"``}\n The interpolation mode. Defaults to ``self.mode``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.interpolate.html\n padding_mode: available modes for numpy array:{``\"constant\"``, ``\"edge\"``, ``\"linear_ramp\"``, ``\"maximum\"``,\n ``\"mean\"``, ``\"median\"``, ``\"minimum\"``, ``\"reflect\"``, ``\"symmetric\"``, ``\"wrap\"``, ``\"empty\"``}\n available modes for PyTorch Tensor: {``\"constant\"``, ``\"reflect\"``, ``\"replicate\"``, ``\"circular\"``}.\n One of the listed string values or a user supplied function. Defaults to ``\"constant\"``.\n The mode to pad data after zooming.\n See also: https://numpy.org/doc/1.18/reference/generated/numpy.pad.html\n https://pytorch.org/docs/stable/generated/torch.nn.functional.pad.html\n align_corners: This only has an effect when mode is\n 'linear', 'bilinear', 'bicubic' or 'trilinear'. Defaults to ``self.align_corners``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.interpolate.html\n\n \"\"\"\n img_t, *_ = convert_data_type(img, torch.Tensor, dtype=torch.float32)\n\n _zoom = ensure_tuple_rep(self.zoom, img.ndim - 1) # match the spatial image dim\n zoomed: NdarrayOrTensor = torch.nn.functional.interpolate( # type: ignore\n recompute_scale_factor=True,\n input=img_t.unsqueeze(0),\n scale_factor=list(_zoom),\n mode=look_up_option(self.mode if mode is None else mode, InterpolateMode).value,\n align_corners=self.align_corners if align_corners is None else align_corners,\n )\n zoomed = zoomed.squeeze(0)\n\n if self.keep_size and not np.allclose(img_t.shape, zoomed.shape):\n\n pad_vec = [(0, 0)] * len(img_t.shape)\n slice_vec = [slice(None)] * len(img_t.shape)\n for idx, (od, zd) in enumerate(zip(img_t.shape, zoomed.shape)):\n diff = od - zd\n half = abs(diff) // 2\n if diff > 0: # need padding\n pad_vec[idx] = (half, diff - half)\n elif diff < 0: # need slicing\n slice_vec[idx] = slice(half, half + od)\n\n padder = Pad(pad_vec, padding_mode or self.padding_mode)\n zoomed = padder(zoomed)\n zoomed = zoomed[tuple(slice_vec)]\n\n out, *_ = convert_to_dst_type(zoomed, dst=img)\n return out\n\n\nclass Rotate90(Transform):\n \"\"\"\n Rotate an array by 90 degrees in the plane specified by `axes`.\n See np.rot90 for additional details:\n https://numpy.org/doc/stable/reference/generated/numpy.rot90.html.\n\n \"\"\"\n\n backend = [TransformBackends.TORCH, TransformBackends.NUMPY]\n\n def __init__(self, k: int = 1, spatial_axes: Tuple[int, int] = (0, 1)) -> None:\n \"\"\"\n Args:\n k: number of times to rotate by 90 degrees.\n spatial_axes: 2 int numbers, defines the plane to rotate with 2 spatial axes.\n Default: (0, 1), this is the first two axis in spatial dimensions.\n If axis is negative it counts from the last to the first axis.\n \"\"\"\n self.k = k\n spatial_axes_: Tuple[int, int] = ensure_tuple(spatial_axes) # type: ignore\n if len(spatial_axes_) != 2:\n raise ValueError(\"spatial_axes must be 2 int numbers to indicate the axes to rotate 90 degrees.\")\n self.spatial_axes = spatial_axes_\n\n def __call__(self, img: NdarrayOrTensor) -> NdarrayOrTensor:\n \"\"\"\n Args:\n img: channel first array, must have shape: (num_channels, H[, W, ..., ]),\n \"\"\"\n rot90: Callable = torch.rot90 if isinstance(img, torch.Tensor) else np.rot90 # type: ignore\n out: NdarrayOrTensor = rot90(img, self.k, map_spatial_axes(img.ndim, self.spatial_axes))\n out, *_ = convert_data_type(out, dtype=img.dtype)\n return out\n\n\nclass RandRotate90(RandomizableTransform):\n \"\"\"\n With probability `prob`, input arrays are rotated by 90 degrees\n in the plane specified by `spatial_axes`.\n \"\"\"\n\n backend = Rotate90.backend\n\n def __init__(self, prob: float = 0.1, max_k: int = 3, spatial_axes: Tuple[int, int] = (0, 1)) -> None:\n \"\"\"\n Args:\n prob: probability of rotating.\n (Default 0.1, with 10% probability it returns a rotated array)\n max_k: number of rotations will be sampled from `np.random.randint(max_k) + 1`, (Default 3).\n spatial_axes: 2 int numbers, defines the plane to rotate with 2 spatial axes.\n Default: (0, 1), this is the first two axis in spatial dimensions.\n \"\"\"\n RandomizableTransform.__init__(self, prob)\n self.max_k = max_k\n self.spatial_axes = spatial_axes\n\n self._rand_k = 0\n\n def randomize(self, data: Optional[Any] = None) -> None:\n super().randomize(None)\n if not self._do_transform:\n return None\n self._rand_k = self.R.randint(self.max_k) + 1\n\n def __call__(self, img: NdarrayOrTensor, randomize: bool = True) -> NdarrayOrTensor:\n \"\"\"\n Args:\n img: channel first array, must have shape: (num_channels, H[, W, ..., ]),\n randomize: whether to execute `randomize()` function first, default to True.\n \"\"\"\n if randomize:\n self.randomize()\n\n if not self._do_transform:\n return img\n\n return Rotate90(self._rand_k, self.spatial_axes)(img)\n\n\nclass RandRotate(RandomizableTransform):\n \"\"\"\n Randomly rotate the input arrays.\n\n Args:\n range_x: Range of rotation angle in radians in the plane defined by the first and second axes.\n If single number, angle is uniformly sampled from (-range_x, range_x).\n range_y: Range of rotation angle in radians in the plane defined by the first and third axes.\n If single number, angle is uniformly sampled from (-range_y, range_y).\n range_z: Range of rotation angle in radians in the plane defined by the second and third axes.\n If single number, angle is uniformly sampled from (-range_z, range_z).\n prob: Probability of rotation.\n keep_size: If it is False, the output shape is adapted so that the\n input array is contained completely in the output.\n If it is True, the output shape is the same as the input. Default is True.\n mode: {``\"bilinear\"``, ``\"nearest\"``}\n Interpolation mode to calculate output values. Defaults to ``\"bilinear\"``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n padding_mode: {``\"zeros\"``, ``\"border\"``, ``\"reflection\"``}\n Padding mode for outside grid values. Defaults to ``\"border\"``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n align_corners: Defaults to False.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n dtype: data type for resampling computation. Defaults to ``np.float32``.\n If None, use the data type of input data. To be compatible with other modules,\n the output data type is always ``np.float32``.\n \"\"\"\n\n backend = Rotate.backend\n\n def __init__(\n self,\n range_x: Union[Tuple[float, float], float] = 0.0,\n range_y: Union[Tuple[float, float], float] = 0.0,\n range_z: Union[Tuple[float, float], float] = 0.0,\n prob: float = 0.1,\n keep_size: bool = True,\n mode: Union[GridSampleMode, str] = GridSampleMode.BILINEAR,\n padding_mode: Union[GridSamplePadMode, str] = GridSamplePadMode.BORDER,\n align_corners: bool = False,\n dtype: Union[DtypeLike, torch.dtype] = np.float32,\n ) -> None:\n RandomizableTransform.__init__(self, prob)\n self.range_x = ensure_tuple(range_x)\n if len(self.range_x) == 1:\n self.range_x = tuple(sorted([-self.range_x[0], self.range_x[0]]))\n self.range_y = ensure_tuple(range_y)\n if len(self.range_y) == 1:\n self.range_y = tuple(sorted([-self.range_y[0], self.range_y[0]]))\n self.range_z = ensure_tuple(range_z)\n if len(self.range_z) == 1:\n self.range_z = tuple(sorted([-self.range_z[0], self.range_z[0]]))\n\n self.keep_size = keep_size\n self.mode: GridSampleMode = look_up_option(mode, GridSampleMode)\n self.padding_mode: GridSamplePadMode = look_up_option(padding_mode, GridSamplePadMode)\n self.align_corners = align_corners\n self.dtype = dtype\n\n self.x = 0.0\n self.y = 0.0\n self.z = 0.0\n\n def randomize(self, data: Optional[Any] = None) -> None:\n super().randomize(None)\n if not self._do_transform:\n return None\n self.x = self.R.uniform(low=self.range_x[0], high=self.range_x[1])\n self.y = self.R.uniform(low=self.range_y[0], high=self.range_y[1])\n self.z = self.R.uniform(low=self.range_z[0], high=self.range_z[1])\n\n def __call__(\n self,\n img: NdarrayOrTensor,\n mode: Optional[Union[GridSampleMode, str]] = None,\n padding_mode: Optional[Union[GridSamplePadMode, str]] = None,\n align_corners: Optional[bool] = None,\n dtype: Union[DtypeLike, torch.dtype] = None,\n randomize: bool = True,\n get_matrix: bool = False,\n ):\n \"\"\"\n Args:\n img: channel first array, must have shape 2D: (nchannels, H, W), or 3D: (nchannels, H, W, D).\n mode: {``\"bilinear\"``, ``\"nearest\"``}\n Interpolation mode to calculate output values. Defaults to ``self.mode``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n padding_mode: {``\"zeros\"``, ``\"border\"``, ``\"reflection\"``}\n Padding mode for outside grid values. Defaults to ``self.padding_mode``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n align_corners: Defaults to ``self.align_corners``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n dtype: data type for resampling computation. Defaults to ``self.dtype``.\n If None, use the data type of input data. To be compatible with other modules,\n the output data type is always ``np.float32``.\n randomize: whether to execute `randomize()` function first, default to True.\n get_matrix: whether to return the rotated image and rotate matrix together, default to False.\n \"\"\"\n if randomize:\n self.randomize()\n\n if not self._do_transform:\n return img\n\n rotator = Rotate(\n angle=self.x if img.ndim == 3 else (self.x, self.y, self.z),\n keep_size=self.keep_size,\n mode=look_up_option(mode or self.mode, GridSampleMode),\n padding_mode=look_up_option(padding_mode or self.padding_mode, GridSamplePadMode),\n align_corners=self.align_corners if align_corners is None else align_corners,\n dtype=dtype or self.dtype or img.dtype,\n )\n img = rotator(img)\n return (img, rotator.get_rotation_matrix()) if get_matrix else img\n\n\nclass RandFlip(RandomizableTransform):\n \"\"\"\n Randomly flips the image along axes. Preserves shape.\n See numpy.flip for additional details.\n https://docs.scipy.org/doc/numpy/reference/generated/numpy.flip.html\n\n Args:\n prob: Probability of flipping.\n spatial_axis: Spatial axes along which to flip over. Default is None.\n \"\"\"\n\n backend = Flip.backend\n\n def __init__(self, prob: float = 0.1, spatial_axis: Optional[Union[Sequence[int], int]] = None) -> None:\n RandomizableTransform.__init__(self, prob)\n self.flipper = Flip(spatial_axis=spatial_axis)\n\n def __call__(self, img: NdarrayOrTensor, randomize: bool = True) -> NdarrayOrTensor:\n \"\"\"\n Args:\n img: channel first array, must have shape: (num_channels, H[, W, ..., ]),\n randomize: whether to execute `randomize()` function first, default to True.\n \"\"\"\n if randomize:\n self.randomize(None)\n\n if not self._do_transform:\n return img\n\n return self.flipper(img)\n\n\nclass RandAxisFlip(RandomizableTransform):\n \"\"\"\n Randomly select a spatial axis and flip along it.\n See numpy.flip for additional details.\n https://docs.scipy.org/doc/numpy/reference/generated/numpy.flip.html\n\n Args:\n prob: Probability of flipping.\n\n \"\"\"\n\n backend = Flip.backend\n\n def __init__(self, prob: float = 0.1) -> None:\n RandomizableTransform.__init__(self, prob)\n self._axis: Optional[int] = None\n\n def randomize(self, data: NdarrayOrTensor) -> None:\n super().randomize(None)\n if not self._do_transform:\n return None\n self._axis = self.R.randint(data.ndim - 1)\n\n def __call__(self, img: NdarrayOrTensor, randomize: bool = True) -> NdarrayOrTensor:\n \"\"\"\n Args:\n img: channel first array, must have shape: (num_channels, H[, W, ..., ]),\n randomize: whether to execute `randomize()` function first, default to True.\n \"\"\"\n if randomize:\n self.randomize(data=img)\n\n if not self._do_transform:\n return img\n\n return Flip(spatial_axis=self._axis)(img)\n\n\nclass RandZoom(RandomizableTransform):\n \"\"\"\n Randomly zooms input arrays with given probability within given zoom range.\n\n Args:\n prob: Probability of zooming.\n min_zoom: Min zoom factor. Can be float or sequence same size as image.\n If a float, select a random factor from `[min_zoom, max_zoom]` then apply to all spatial dims\n to keep the original spatial shape ratio.\n If a sequence, min_zoom should contain one value for each spatial axis.\n If 2 values provided for 3D data, use the first value for both H & W dims to keep the same zoom ratio.\n max_zoom: Max zoom factor. Can be float or sequence same size as image.\n If a float, select a random factor from `[min_zoom, max_zoom]` then apply to all spatial dims\n to keep the original spatial shape ratio.\n If a sequence, max_zoom should contain one value for each spatial axis.\n If 2 values provided for 3D data, use the first value for both H & W dims to keep the same zoom ratio.\n mode: {``\"nearest\"``, ``\"linear\"``, ``\"bilinear\"``, ``\"bicubic\"``, ``\"trilinear\"``, ``\"area\"``}\n The interpolation mode. Defaults to ``\"area\"``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.interpolate.html\n padding_mode: available modes for numpy array:{``\"constant\"``, ``\"edge\"``, ``\"linear_ramp\"``, ``\"maximum\"``,\n ``\"mean\"``, ``\"median\"``, ``\"minimum\"``, ``\"reflect\"``, ``\"symmetric\"``, ``\"wrap\"``, ``\"empty\"``}\n available modes for PyTorch Tensor: {``\"constant\"``, ``\"reflect\"``, ``\"replicate\"``, ``\"circular\"``}.\n One of the listed string values or a user supplied function. Defaults to ``\"constant\"``.\n The mode to pad data after zooming.\n See also: https://numpy.org/doc/1.18/reference/generated/numpy.pad.html\n https://pytorch.org/docs/stable/generated/torch.nn.functional.pad.html\n align_corners: This only has an effect when mode is\n 'linear', 'bilinear', 'bicubic' or 'trilinear'. Default: None.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.interpolate.html\n keep_size: Should keep original size (pad if needed), default is True.\n kwargs: other arguments for the `np.pad` or `torch.pad` function.\n note that `np.pad` treats channel dimension as the first dimension.\n\n \"\"\"\n\n backend = Zoom.backend\n\n def __init__(\n self,\n prob: float = 0.1,\n min_zoom: Union[Sequence[float], float] = 0.9,\n max_zoom: Union[Sequence[float], float] = 1.1,\n mode: Union[InterpolateMode, str] = InterpolateMode.AREA,\n padding_mode: Union[NumpyPadMode, PytorchPadMode, str] = NumpyPadMode.EDGE,\n align_corners: Optional[bool] = None,\n keep_size: bool = True,\n **kwargs,\n ) -> None:\n RandomizableTransform.__init__(self, prob)\n self.min_zoom = ensure_tuple(min_zoom)\n self.max_zoom = ensure_tuple(max_zoom)\n if len(self.min_zoom) != len(self.max_zoom):\n raise AssertionError(\"min_zoom and max_zoom must have same length.\")\n self.mode: InterpolateMode = look_up_option(mode, InterpolateMode)\n self.padding_mode = padding_mode\n self.align_corners = align_corners\n self.keep_size = keep_size\n self.kwargs = kwargs\n\n self._zoom: Sequence[float] = [1.0]\n\n def randomize(self, img: NdarrayOrTensor) -> None:\n super().randomize(None)\n if not self._do_transform:\n return None\n self._zoom = [self.R.uniform(l, h) for l, h in zip(self.min_zoom, self.max_zoom)]\n if len(self._zoom) == 1:\n # to keep the spatial shape ratio, use same random zoom factor for all dims\n self._zoom = ensure_tuple_rep(self._zoom[0], img.ndim - 1)\n elif len(self._zoom) == 2 and img.ndim > 3:\n # if 2 zoom factors provided for 3D data, use the first factor for H and W dims, second factor for D dim\n self._zoom = ensure_tuple_rep(self._zoom[0], img.ndim - 2) + ensure_tuple(self._zoom[-1])\n\n def __call__(\n self,\n img: NdarrayOrTensor,\n mode: Optional[Union[InterpolateMode, str]] = None,\n padding_mode: Optional[Union[NumpyPadMode, PytorchPadMode, str]] = None,\n align_corners: Optional[bool] = None,\n randomize: bool = True,\n ) -> NdarrayOrTensor:\n \"\"\"\n Args:\n img: channel first array, must have shape 2D: (nchannels, H, W), or 3D: (nchannels, H, W, D).\n mode: {``\"nearest\"``, ``\"linear\"``, ``\"bilinear\"``, ``\"bicubic\"``, ``\"trilinear\"``, ``\"area\"``}\n The interpolation mode. Defaults to ``self.mode``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.interpolate.html\n padding_mode: available modes for numpy array:{``\"constant\"``, ``\"edge\"``, ``\"linear_ramp\"``, ``\"maximum\"``,\n ``\"mean\"``, ``\"median\"``, ``\"minimum\"``, ``\"reflect\"``, ``\"symmetric\"``, ``\"wrap\"``, ``\"empty\"``}\n available modes for PyTorch Tensor: {``\"constant\"``, ``\"reflect\"``, ``\"replicate\"``, ``\"circular\"``}.\n One of the listed string values or a user supplied function. Defaults to ``\"constant\"``.\n The mode to pad data after zooming.\n See also: https://numpy.org/doc/1.18/reference/generated/numpy.pad.html\n https://pytorch.org/docs/stable/generated/torch.nn.functional.pad.html\n align_corners: This only has an effect when mode is\n 'linear', 'bilinear', 'bicubic' or 'trilinear'. Defaults to ``self.align_corners``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.interpolate.html\n randomize: whether to execute `randomize()` function first, default to True.\n\n \"\"\"\n # match the spatial image dim\n if randomize:\n self.randomize(img=img)\n\n if not self._do_transform:\n return img\n\n return Zoom(\n self._zoom,\n keep_size=self.keep_size,\n mode=look_up_option(mode or self.mode, InterpolateMode),\n padding_mode=padding_mode or self.padding_mode,\n align_corners=align_corners or self.align_corners,\n **self.kwargs,\n )(img)\n\n\nclass AffineGrid(Transform):\n \"\"\"\n Affine transforms on the coordinates.\n\n Args:\n rotate_params: a rotation angle in radians, a scalar for 2D image, a tuple of 3 floats for 3D.\n Defaults to no rotation.\n shear_params: shearing factors for affine matrix, take a 3D affine as example::\n\n [\n [1.0, params[0], params[1], 0.0],\n [params[2], 1.0, params[3], 0.0],\n [params[4], params[5], 1.0, 0.0],\n [0.0, 0.0, 0.0, 1.0],\n ]\n\n a tuple of 2 floats for 2D, a tuple of 6 floats for 3D. Defaults to no shearing.\n translate_params: a tuple of 2 floats for 2D, a tuple of 3 floats for 3D. Translation is in\n pixel/voxel relative to the center of the input image. Defaults to no translation.\n scale_params: scale factor for every spatial dims. a tuple of 2 floats for 2D,\n a tuple of 3 floats for 3D. Defaults to `1.0`.\n dtype: data type for the grid computation. Defaults to ``np.float32``.\n If ``None``, use the data type of input data (if `grid` is provided).\n device: device on which the tensor will be allocated, if a new grid is generated.\n affine: If applied, ignore the params (`rotate_params`, etc.) and use the\n supplied matrix. Should be square with each side = num of image spatial\n dimensions + 1.\n\n .. deprecated:: 0.6.0\n ``as_tensor_output`` is deprecated.\n\n \"\"\"\n\n backend = [TransformBackends.TORCH, TransformBackends.NUMPY]\n\n @deprecated_arg(name=\"as_tensor_output\", since=\"0.6\")\n def __init__(\n self,\n rotate_params: Optional[Union[Sequence[float], float]] = None,\n shear_params: Optional[Union[Sequence[float], float]] = None,\n translate_params: Optional[Union[Sequence[float], float]] = None,\n scale_params: Optional[Union[Sequence[float], float]] = None,\n as_tensor_output: bool = True,\n device: Optional[torch.device] = None,\n dtype: DtypeLike = np.float32,\n affine: Optional[NdarrayOrTensor] = None,\n ) -> None:\n self.rotate_params = rotate_params\n self.shear_params = shear_params\n self.translate_params = translate_params\n self.scale_params = scale_params\n self.device = device\n self.dtype = dtype\n self.affine = affine\n\n def __call__(\n self, spatial_size: Optional[Sequence[int]] = None, grid: Optional[NdarrayOrTensor] = None\n ) -> Tuple[NdarrayOrTensor, NdarrayOrTensor]:\n \"\"\"\n The grid can be initialized with a `spatial_size` parameter, or provided directly as `grid`.\n Therefore, either `spatial_size` or `grid` must be provided.\n When initialising from `spatial_size`, the backend \"torch\" will be used.\n\n Args:\n spatial_size: output grid size.\n grid: grid to be transformed. Shape must be (3, H, W) for 2D or (4, H, W, D) for 3D.\n\n Raises:\n ValueError: When ``grid=None`` and ``spatial_size=None``. Incompatible values.\n\n \"\"\"\n if grid is None: # create grid from spatial_size\n if spatial_size is None:\n raise ValueError(\"Incompatible values: grid=None and spatial_size=None.\")\n grid = create_grid(spatial_size, device=self.device, backend=\"torch\", dtype=self.dtype)\n _b = TransformBackends.TORCH if isinstance(grid, torch.Tensor) else TransformBackends.NUMPY\n _device = grid.device if isinstance(grid, torch.Tensor) else self.device\n affine: NdarrayOrTensor\n if self.affine is None:\n spatial_dims = len(grid.shape) - 1\n affine = (\n torch.eye(spatial_dims + 1, device=_device)\n if _b == TransformBackends.TORCH\n else np.eye(spatial_dims + 1)\n )\n if self.rotate_params:\n affine = affine @ create_rotate(spatial_dims, self.rotate_params, device=_device, backend=_b)\n if self.shear_params:\n affine = affine @ create_shear(spatial_dims, self.shear_params, device=_device, backend=_b)\n if self.translate_params:\n affine = affine @ create_translate(spatial_dims, self.translate_params, device=_device, backend=_b)\n if self.scale_params:\n affine = affine @ create_scale(spatial_dims, self.scale_params, device=_device, backend=_b)\n else:\n affine = self.affine\n\n grid, *_ = convert_data_type(grid, torch.Tensor, device=_device, dtype=self.dtype or grid.dtype)\n affine, *_ = convert_to_dst_type(affine, grid)\n\n grid = (affine @ grid.reshape((grid.shape[0], -1))).reshape([-1] + list(grid.shape[1:]))\n return grid, affine\n\n\nclass RandAffineGrid(Randomizable, Transform):\n \"\"\"\n Generate randomised affine grid.\n\n \"\"\"\n\n backend = AffineGrid.backend\n\n @deprecated_arg(name=\"as_tensor_output\", since=\"0.6\")\n def __init__(\n self,\n rotate_range: RandRange = None,\n shear_range: RandRange = None,\n translate_range: RandRange = None,\n scale_range: RandRange = None,\n as_tensor_output: bool = True,\n device: Optional[torch.device] = None,\n ) -> None:\n \"\"\"\n Args:\n rotate_range: angle range in radians. If element `i` is a pair of (min, max) values, then\n `uniform[-rotate_range[i][0], rotate_range[i][1])` will be used to generate the rotation parameter\n for the `i`th spatial dimension. If not, `uniform[-rotate_range[i], rotate_range[i])` will be used.\n This can be altered on a per-dimension basis. E.g., `((0,3), 1, ...)`: for dim0, rotation will be\n in range `[0, 3]`, and for dim1 `[-1, 1]` will be used. Setting a single value will use `[-x, x]`\n for dim0 and nothing for the remaining dimensions.\n shear_range: shear range with format matching `rotate_range`, it defines the range to randomly select\n shearing factors(a tuple of 2 floats for 2D, a tuple of 6 floats for 3D) for affine matrix,\n take a 3D affine as example::\n\n [\n [1.0, params[0], params[1], 0.0],\n [params[2], 1.0, params[3], 0.0],\n [params[4], params[5], 1.0, 0.0],\n [0.0, 0.0, 0.0, 1.0],\n ]\n\n translate_range: translate range with format matching `rotate_range`, it defines the range to randomly\n select voxels to translate for every spatial dims.\n scale_range: scaling range with format matching `rotate_range`. it defines the range to randomly select\n the scale factor to translate for every spatial dims. A value of 1.0 is added to the result.\n This allows 0 to correspond to no change (i.e., a scaling of 1.0).\n device: device to store the output grid data.\n\n See also:\n - :py:meth:`monai.transforms.utils.create_rotate`\n - :py:meth:`monai.transforms.utils.create_shear`\n - :py:meth:`monai.transforms.utils.create_translate`\n - :py:meth:`monai.transforms.utils.create_scale`\n\n .. deprecated:: 0.6.0\n ``as_tensor_output`` is deprecated.\n\n \"\"\"\n self.rotate_range = ensure_tuple(rotate_range)\n self.shear_range = ensure_tuple(shear_range)\n self.translate_range = ensure_tuple(translate_range)\n self.scale_range = ensure_tuple(scale_range)\n\n self.rotate_params: Optional[List[float]] = None\n self.shear_params: Optional[List[float]] = None\n self.translate_params: Optional[List[float]] = None\n self.scale_params: Optional[List[float]] = None\n\n self.device = device\n self.affine: Optional[NdarrayOrTensor] = None\n\n def _get_rand_param(self, param_range, add_scalar: float = 0.0):\n out_param = []\n for f in param_range:\n if issequenceiterable(f):\n if len(f) != 2:\n raise ValueError(\"If giving range as [min,max], should only have two elements per dim.\")\n out_param.append(self.R.uniform(f[0], f[1]) + add_scalar)\n elif f is not None:\n out_param.append(self.R.uniform(-f, f) + add_scalar)\n return out_param\n\n def randomize(self, data: Optional[Any] = None) -> None:\n self.rotate_params = self._get_rand_param(self.rotate_range)\n self.shear_params = self._get_rand_param(self.shear_range)\n self.translate_params = self._get_rand_param(self.translate_range)\n self.scale_params = self._get_rand_param(self.scale_range, 1.0)\n\n def __call__(\n self, spatial_size: Optional[Sequence[int]] = None, grid: Optional[NdarrayOrTensor] = None\n ) -> NdarrayOrTensor:\n \"\"\"\n Args:\n spatial_size: output grid size.\n grid: grid to be transformed. Shape must be (3, H, W) for 2D or (4, H, W, D) for 3D.\n\n Returns:\n a 2D (3xHxW) or 3D (4xHxWxD) grid.\n \"\"\"\n self.randomize()\n affine_grid = AffineGrid(\n rotate_params=self.rotate_params,\n shear_params=self.shear_params,\n translate_params=self.translate_params,\n scale_params=self.scale_params,\n device=self.device,\n )\n _grid: NdarrayOrTensor\n _grid, self.affine = affine_grid(spatial_size, grid)\n return _grid\n\n def get_transformation_matrix(self) -> Optional[NdarrayOrTensor]:\n \"\"\"Get the most recently applied transformation matrix\"\"\"\n return self.affine\n\n\nclass RandDeformGrid(Randomizable, Transform):\n \"\"\"\n Generate random deformation grid.\n \"\"\"\n\n backend = [TransformBackends.TORCH]\n\n def __init__(\n self,\n spacing: Union[Sequence[float], float],\n magnitude_range: Tuple[float, float],\n as_tensor_output: bool = True,\n device: Optional[torch.device] = None,\n ) -> None:\n \"\"\"\n Args:\n spacing: spacing of the grid in 2D or 3D.\n e.g., spacing=(1, 1) indicates pixel-wise deformation in 2D,\n spacing=(1, 1, 1) indicates voxel-wise deformation in 3D,\n spacing=(2, 2) indicates deformation field defined on every other pixel in 2D.\n magnitude_range: the random offsets will be generated from\n `uniform[magnitude[0], magnitude[1])`.\n as_tensor_output: whether to output tensor instead of numpy array.\n defaults to True.\n device: device to store the output grid data.\n \"\"\"\n self.spacing = spacing\n self.magnitude = magnitude_range\n\n self.rand_mag = 1.0\n self.as_tensor_output = as_tensor_output\n self.random_offset: np.ndarray\n self.device = device\n\n def randomize(self, grid_size: Sequence[int]) -> None:\n self.random_offset = self.R.normal(size=([len(grid_size)] + list(grid_size))).astype(np.float32, copy=False)\n self.rand_mag = self.R.uniform(self.magnitude[0], self.magnitude[1])\n\n def __call__(self, spatial_size: Sequence[int]):\n \"\"\"\n Args:\n spatial_size: spatial size of the grid.\n \"\"\"\n self.spacing = fall_back_tuple(self.spacing, (1.0,) * len(spatial_size))\n control_grid = create_control_grid(spatial_size, self.spacing, device=self.device, backend=\"torch\")\n self.randomize(control_grid.shape[1:])\n _offset, *_ = convert_to_dst_type(self.rand_mag * self.random_offset, control_grid)\n control_grid[: len(spatial_size)] += _offset\n if not self.as_tensor_output:\n control_grid, *_ = convert_data_type(control_grid, output_type=np.ndarray, dtype=np.float32)\n return control_grid\n\n\nclass Resample(Transform):\n\n backend = [TransformBackends.TORCH]\n\n @deprecated_arg(name=\"as_tensor_output\", since=\"0.6\")\n def __init__(\n self,\n mode: Union[GridSampleMode, str] = GridSampleMode.BILINEAR,\n padding_mode: Union[GridSamplePadMode, str] = GridSamplePadMode.BORDER,\n as_tensor_output: bool = True,\n norm_coords: bool = True,\n device: Optional[torch.device] = None,\n dtype: DtypeLike = np.float64,\n ) -> None:\n \"\"\"\n computes output image using values from `img`, locations from `grid` using pytorch.\n supports spatially 2D or 3D (num_channels, H, W[, D]).\n\n Args:\n mode: {``\"bilinear\"``, ``\"nearest\"``}\n Interpolation mode to calculate output values. Defaults to ``\"bilinear\"``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n padding_mode: {``\"zeros\"``, ``\"border\"``, ``\"reflection\"``}\n Padding mode for outside grid values. Defaults to ``\"border\"``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n When `USE_COMPILED` is `True`, this argument uses\n ``\"nearest\"``, ``\"bilinear\"``, ``\"bicubic\"`` to indicate 0, 1, 3 order interpolations.\n See also: https://docs.monai.io/en/stable/networks.html#grid-pull\n norm_coords: whether to normalize the coordinates from `[-(size-1)/2, (size-1)/2]` to\n `[0, size - 1]` (for ``monai/csrc`` implementation) or\n `[-1, 1]` (for torch ``grid_sample`` implementation) to be compatible with the underlying\n resampling API.\n device: device on which the tensor will be allocated.\n dtype: data type for resampling computation. Defaults to ``np.float64`` for best precision.\n If ``None``, use the data type of input data. To be compatible with other modules,\n the output data type is always `float32`.\n\n .. deprecated:: 0.6.0\n ``as_tensor_output`` is deprecated.\n\n \"\"\"\n self.mode: GridSampleMode = look_up_option(mode, GridSampleMode)\n self.padding_mode: GridSamplePadMode = look_up_option(padding_mode, GridSamplePadMode)\n self.norm_coords = norm_coords\n self.device = device\n self.dtype = dtype\n\n def __call__(\n self,\n img: NdarrayOrTensor,\n grid: Optional[NdarrayOrTensor] = None,\n mode: Optional[Union[GridSampleMode, str]] = None,\n padding_mode: Optional[Union[GridSamplePadMode, str]] = None,\n dtype: DtypeLike = None,\n ) -> NdarrayOrTensor:\n \"\"\"\n Args:\n img: shape must be (num_channels, H, W[, D]).\n grid: shape must be (3, H, W) for 2D or (4, H, W, D) for 3D.\n if ``norm_coords`` is True, the grid values must be in `[-(size-1)/2, (size-1)/2]`.\n if ``USE_COMPILED=True`` and ``norm_coords=False``, grid values must be in `[0, size-1]`.\n if ``USE_COMPILED=False`` and ``norm_coords=False``, grid values must be in `[-1, 1]`.\n mode: {``\"bilinear\"``, ``\"nearest\"``}\n Interpolation mode to calculate output values. Defaults to ``self.mode``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n When `USE_COMPILED` is `True`, this argument uses\n ``\"nearest\"``, ``\"bilinear\"``, ``\"bicubic\"`` to indicate 0, 1, 3 order interpolations.\n See also: https://docs.monai.io/en/stable/networks.html#grid-pull\n padding_mode: {``\"zeros\"``, ``\"border\"``, ``\"reflection\"``}\n Padding mode for outside grid values. Defaults to ``self.padding_mode``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n dtype: data type for resampling computation. Defaults to ``self.dtype``.\n To be compatible with other modules, the output data type is always `float32`.\n\n See also:\n :py:const:`monai.config.USE_COMPILED`\n \"\"\"\n if grid is None:\n raise ValueError(\"Unknown grid.\")\n _device = img.device if isinstance(img, torch.Tensor) else self.device\n _dtype = dtype or self.dtype or img.dtype\n img_t, *_ = convert_data_type(img, torch.Tensor, device=_device, dtype=_dtype)\n grid_t = convert_to_dst_type(grid, img_t)[0]\n if grid_t is grid: # copy if needed (convert_data_type converts to contiguous)\n grid_t = grid_t.clone(memory_format=torch.contiguous_format)\n sr = min(len(img_t.shape[1:]), 3)\n\n if USE_COMPILED:\n if self.norm_coords:\n for i, dim in enumerate(img_t.shape[1 : 1 + sr]):\n grid_t[i] = (max(dim, 2) / 2.0 - 0.5 + grid_t[i]) / grid_t[-1:]\n grid_t = moveaxis(grid_t[:sr], 0, -1) # type: ignore\n _padding_mode = self.padding_mode if padding_mode is None else padding_mode\n _padding_mode = _padding_mode.value if isinstance(_padding_mode, GridSamplePadMode) else _padding_mode\n bound = 1 if _padding_mode == \"reflection\" else _padding_mode\n _interp_mode = self.mode if mode is None else mode\n _interp_mode = _interp_mode.value if isinstance(_interp_mode, GridSampleMode) else _interp_mode\n if _interp_mode == \"bicubic\":\n interp = 3\n elif _interp_mode == \"bilinear\":\n interp = 1\n else:\n interp = _interp_mode # type: ignore\n out = grid_pull(\n img_t.unsqueeze(0), grid_t.unsqueeze(0), bound=bound, extrapolate=True, interpolation=interp\n )[0]\n else:\n if self.norm_coords:\n for i, dim in enumerate(img_t.shape[1 : 1 + sr]):\n grid_t[i] = 2.0 / (max(2, dim) - 1.0) * grid_t[i] / grid_t[-1:]\n index_ordering: List[int] = list(range(sr - 1, -1, -1))\n grid_t = moveaxis(grid_t[index_ordering], 0, -1) # type: ignore\n out = torch.nn.functional.grid_sample(\n img_t.unsqueeze(0),\n grid_t.unsqueeze(0),\n mode=self.mode.value if mode is None else GridSampleMode(mode).value,\n padding_mode=self.padding_mode.value if padding_mode is None else GridSamplePadMode(padding_mode).value,\n align_corners=True,\n )[0]\n out_val, *_ = convert_to_dst_type(out, dst=img, dtype=np.float32)\n return out_val\n\n\nclass Affine(Transform):\n \"\"\"\n Transform ``img`` given the affine parameters.\n A tutorial is available: https://github.com/Project-MONAI/tutorials/blob/0.6.0/modules/transforms_demo_2d.ipynb.\n\n \"\"\"\n\n backend = list(set(AffineGrid.backend) & set(Resample.backend))\n\n @deprecated_arg(name=\"as_tensor_output\", since=\"0.6\")\n def __init__(\n self,\n rotate_params: Optional[Union[Sequence[float], float]] = None,\n shear_params: Optional[Union[Sequence[float], float]] = None,\n translate_params: Optional[Union[Sequence[float], float]] = None,\n scale_params: Optional[Union[Sequence[float], float]] = None,\n affine: Optional[NdarrayOrTensor] = None,\n spatial_size: Optional[Union[Sequence[int], int]] = None,\n mode: Union[GridSampleMode, str] = GridSampleMode.BILINEAR,\n padding_mode: Union[GridSamplePadMode, str] = GridSamplePadMode.REFLECTION,\n norm_coords: bool = True,\n as_tensor_output: bool = True,\n device: Optional[torch.device] = None,\n dtype: DtypeLike = np.float32,\n image_only: bool = False,\n ) -> None:\n \"\"\"\n The affine transformations are applied in rotate, shear, translate, scale order.\n\n Args:\n rotate_params: a rotation angle in radians, a scalar for 2D image, a tuple of 3 floats for 3D.\n Defaults to no rotation.\n shear_params: shearing factors for affine matrix, take a 3D affine as example::\n\n [\n [1.0, params[0], params[1], 0.0],\n [params[2], 1.0, params[3], 0.0],\n [params[4], params[5], 1.0, 0.0],\n [0.0, 0.0, 0.0, 1.0],\n ]\n\n a tuple of 2 floats for 2D, a tuple of 6 floats for 3D. Defaults to no shearing.\n translate_params: a tuple of 2 floats for 2D, a tuple of 3 floats for 3D. Translation is in\n pixel/voxel relative to the center of the input image. Defaults to no translation.\n scale_params: scale factor for every spatial dims. a tuple of 2 floats for 2D,\n a tuple of 3 floats for 3D. Defaults to `1.0`.\n affine: If applied, ignore the params (`rotate_params`, etc.) and use the\n supplied matrix. Should be square with each side = num of image spatial\n dimensions + 1.\n spatial_size: output image spatial size.\n if `spatial_size` and `self.spatial_size` are not defined, or smaller than 1,\n the transform will use the spatial size of `img`.\n if some components of the `spatial_size` are non-positive values, the transform will use the\n corresponding components of img size. For example, `spatial_size=(32, -1)` will be adapted\n to `(32, 64)` if the second spatial dimension size of img is `64`.\n mode: {``\"bilinear\"``, ``\"nearest\"``}\n Interpolation mode to calculate output values. Defaults to ``\"bilinear\"``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n When `USE_COMPILED` is `True`, this argument uses\n ``\"nearest\"``, ``\"bilinear\"``, ``\"bicubic\"`` to indicate 0, 1, 3 order interpolations.\n See also: https://docs.monai.io/en/stable/networks.html#grid-pull\n padding_mode: {``\"zeros\"``, ``\"border\"``, ``\"reflection\"``}\n Padding mode for outside grid values. Defaults to ``\"reflection\"``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n norm_coords: whether to normalize the coordinates from `[-(size-1)/2, (size-1)/2]` to\n `[0, size - 1]` or `[-1, 1]` to be compatible with the underlying resampling API.\n If the coordinates are generated by ``monai.transforms.utils.create_grid``\n and the ``affine`` doesn't include the normalization, this argument should be set to ``True``.\n If the output `self.affine_grid` is already normalized, this argument should be set to ``False``.\n device: device on which the tensor will be allocated.\n dtype: data type for resampling computation. Defaults to ``np.float32``.\n If ``None``, use the data type of input data. To be compatible with other modules,\n the output data type is always `float32`.\n image_only: if True return only the image volume, otherwise return (image, affine).\n\n .. deprecated:: 0.6.0\n ``as_tensor_output`` is deprecated.\n\n \"\"\"\n self.affine_grid = AffineGrid(\n rotate_params=rotate_params,\n shear_params=shear_params,\n translate_params=translate_params,\n scale_params=scale_params,\n affine=affine,\n dtype=dtype,\n device=device,\n )\n self.image_only = image_only\n self.resampler = Resample(norm_coords=norm_coords, device=device, dtype=dtype)\n self.spatial_size = spatial_size\n self.mode: GridSampleMode = look_up_option(mode, GridSampleMode)\n self.padding_mode: GridSamplePadMode = look_up_option(padding_mode, GridSamplePadMode)\n\n def __call__(\n self,\n img: NdarrayOrTensor,\n spatial_size: Optional[Union[Sequence[int], int]] = None,\n mode: Optional[Union[GridSampleMode, str]] = None,\n padding_mode: Optional[Union[GridSamplePadMode, str]] = None,\n ) -> Union[NdarrayOrTensor, Tuple[NdarrayOrTensor, NdarrayOrTensor]]:\n \"\"\"\n Args:\n img: shape must be (num_channels, H, W[, D]),\n spatial_size: output image spatial size.\n if `spatial_size` and `self.spatial_size` are not defined, or smaller than 1,\n the transform will use the spatial size of `img`.\n if `img` has two spatial dimensions, `spatial_size` should have 2 elements [h, w].\n if `img` has three spatial dimensions, `spatial_size` should have 3 elements [h, w, d].\n mode: {``\"bilinear\"``, ``\"nearest\"``}\n Interpolation mode to calculate output values. Defaults to ``self.mode``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n When `USE_COMPILED` is `True`, this argument uses\n ``\"nearest\"``, ``\"bilinear\"``, ``\"bicubic\"`` to indicate 0, 1, 3 order interpolations.\n See also: https://docs.monai.io/en/stable/networks.html#grid-pull\n padding_mode: {``\"zeros\"``, ``\"border\"``, ``\"reflection\"``}\n Padding mode for outside grid values. Defaults to ``self.padding_mode``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n \"\"\"\n sp_size = fall_back_tuple(spatial_size or self.spatial_size, img.shape[1:])\n grid, affine = self.affine_grid(spatial_size=sp_size)\n ret = self.resampler(img, grid=grid, mode=mode or self.mode, padding_mode=padding_mode or self.padding_mode)\n\n return ret if self.image_only else (ret, affine)\n\n\nclass RandAffine(RandomizableTransform):\n \"\"\"\n Random affine transform.\n A tutorial is available: https://github.com/Project-MONAI/tutorials/blob/0.6.0/modules/transforms_demo_2d.ipynb.\n\n \"\"\"\n\n backend = Affine.backend\n\n @deprecated_arg(name=\"as_tensor_output\", since=\"0.6\")\n def __init__(\n self,\n prob: float = 0.1,\n rotate_range: RandRange = None,\n shear_range: RandRange = None,\n translate_range: RandRange = None,\n scale_range: RandRange = None,\n spatial_size: Optional[Union[Sequence[int], int]] = None,\n mode: Union[GridSampleMode, str] = GridSampleMode.BILINEAR,\n padding_mode: Union[GridSamplePadMode, str] = GridSamplePadMode.REFLECTION,\n cache_grid: bool = False,\n as_tensor_output: bool = True,\n device: Optional[torch.device] = None,\n ) -> None:\n \"\"\"\n Args:\n prob: probability of returning a randomized affine grid.\n defaults to 0.1, with 10% chance returns a randomized grid.\n rotate_range: angle range in radians. If element `i` is a pair of (min, max) values, then\n `uniform[-rotate_range[i][0], rotate_range[i][1])` will be used to generate the rotation parameter\n for the `i`th spatial dimension. If not, `uniform[-rotate_range[i], rotate_range[i])` will be used.\n This can be altered on a per-dimension basis. E.g., `((0,3), 1, ...)`: for dim0, rotation will be\n in range `[0, 3]`, and for dim1 `[-1, 1]` will be used. Setting a single value will use `[-x, x]`\n for dim0 and nothing for the remaining dimensions.\n shear_range: shear range with format matching `rotate_range`, it defines the range to randomly select\n shearing factors(a tuple of 2 floats for 2D, a tuple of 6 floats for 3D) for affine matrix,\n take a 3D affine as example::\n\n [\n [1.0, params[0], params[1], 0.0],\n [params[2], 1.0, params[3], 0.0],\n [params[4], params[5], 1.0, 0.0],\n [0.0, 0.0, 0.0, 1.0],\n ]\n\n translate_range: translate range with format matching `rotate_range`, it defines the range to randomly\n select pixel/voxel to translate for every spatial dims.\n scale_range: scaling range with format matching `rotate_range`. it defines the range to randomly select\n the scale factor to translate for every spatial dims. A value of 1.0 is added to the result.\n This allows 0 to correspond to no change (i.e., a scaling of 1.0).\n spatial_size: output image spatial size.\n if `spatial_size` and `self.spatial_size` are not defined, or smaller than 1,\n the transform will use the spatial size of `img`.\n if some components of the `spatial_size` are non-positive values, the transform will use the\n corresponding components of img size. For example, `spatial_size=(32, -1)` will be adapted\n to `(32, 64)` if the second spatial dimension size of img is `64`.\n mode: {``\"bilinear\"``, ``\"nearest\"``}\n Interpolation mode to calculate output values. Defaults to ``\"bilinear\"``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n padding_mode: {``\"zeros\"``, ``\"border\"``, ``\"reflection\"``}\n Padding mode for outside grid values. Defaults to ``\"reflection\"``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n cache_grid: whether to cache the identity sampling grid.\n If the spatial size is not dynamically defined by input image, enabling this option could\n accelerate the transform.\n device: device on which the tensor will be allocated.\n\n See also:\n - :py:class:`RandAffineGrid` for the random affine parameters configurations.\n - :py:class:`Affine` for the affine transformation parameters configurations.\n\n .. deprecated:: 0.6.0\n ``as_tensor_output`` is deprecated.\n\n \"\"\"\n RandomizableTransform.__init__(self, prob)\n\n self.rand_affine_grid = RandAffineGrid(\n rotate_range=rotate_range,\n shear_range=shear_range,\n translate_range=translate_range,\n scale_range=scale_range,\n device=device,\n )\n self.resampler = Resample(device=device)\n\n self.spatial_size = spatial_size\n self.cache_grid = cache_grid\n self._cached_grid = self._init_identity_cache()\n self.mode: GridSampleMode = GridSampleMode(mode)\n self.padding_mode: GridSamplePadMode = GridSamplePadMode(padding_mode)\n\n def _init_identity_cache(self):\n \"\"\"\n Create cache of the identity grid if cache_grid=True and spatial_size is known.\n \"\"\"\n if self.spatial_size is None:\n if self.cache_grid:\n warnings.warn(\n \"cache_grid=True is not compatible with the dynamic spatial_size, please specify 'spatial_size'.\"\n )\n return None\n _sp_size = ensure_tuple(self.spatial_size)\n _ndim = len(_sp_size)\n if _sp_size != fall_back_tuple(_sp_size, [1] * _ndim) or _sp_size != fall_back_tuple(_sp_size, [2] * _ndim):\n # dynamic shape because it falls back to different outcomes\n if self.cache_grid:\n warnings.warn(\n \"cache_grid=True is not compatible with the dynamic spatial_size \"\n f\"'spatial_size={self.spatial_size}', please specify 'spatial_size'.\"\n )\n return None\n return create_grid(spatial_size=_sp_size, device=self.rand_affine_grid.device, backend=\"torch\")\n\n def get_identity_grid(self, spatial_size: Sequence[int]):\n \"\"\"\n Return a cached or new identity grid depends on the availability.\n\n Args:\n spatial_size: non-dynamic spatial size\n \"\"\"\n ndim = len(spatial_size)\n if spatial_size != fall_back_tuple(spatial_size, [1] * ndim) or spatial_size != fall_back_tuple(\n spatial_size, [2] * ndim\n ):\n raise RuntimeError(f\"spatial_size should not be dynamic, got {spatial_size}.\")\n return (\n create_grid(spatial_size=spatial_size, device=self.rand_affine_grid.device, backend=\"torch\")\n if self._cached_grid is None\n else self._cached_grid\n )\n\n def set_random_state(\n self, seed: Optional[int] = None, state: Optional[np.random.RandomState] = None\n ) -> \"RandAffine\":\n self.rand_affine_grid.set_random_state(seed, state)\n super().set_random_state(seed, state)\n return self\n\n def randomize(self, data: Optional[Any] = None) -> None:\n super().randomize(None)\n if not self._do_transform:\n return None\n self.rand_affine_grid.randomize()\n\n def __call__(\n self,\n img: NdarrayOrTensor,\n spatial_size: Optional[Union[Sequence[int], int]] = None,\n mode: Optional[Union[GridSampleMode, str]] = None,\n padding_mode: Optional[Union[GridSamplePadMode, str]] = None,\n randomize: bool = True,\n ) -> NdarrayOrTensor:\n \"\"\"\n Args:\n img: shape must be (num_channels, H, W[, D]),\n spatial_size: output image spatial size.\n if `spatial_size` and `self.spatial_size` are not defined, or smaller than 1,\n the transform will use the spatial size of `img`.\n if `img` has two spatial dimensions, `spatial_size` should have 2 elements [h, w].\n if `img` has three spatial dimensions, `spatial_size` should have 3 elements [h, w, d].\n mode: {``\"bilinear\"``, ``\"nearest\"``}\n Interpolation mode to calculate output values. Defaults to ``self.mode``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n padding_mode: {``\"zeros\"``, ``\"border\"``, ``\"reflection\"``}\n Padding mode for outside grid values. Defaults to ``self.padding_mode``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n randomize: whether to execute `randomize()` function first, default to True.\n\n \"\"\"\n if randomize:\n self.randomize()\n\n # if not doing transform and spatial size doesn't change, nothing to do\n # except convert to float and device\n sp_size = fall_back_tuple(spatial_size or self.spatial_size, img.shape[1:])\n do_resampling = self._do_transform or (sp_size != ensure_tuple(img.shape[1:]))\n if not do_resampling:\n img, *_ = convert_data_type(img, dtype=torch.float32, device=self.resampler.device)\n grid = self.get_identity_grid(sp_size)\n if self._do_transform:\n grid = self.rand_affine_grid(grid=grid)\n out: NdarrayOrTensor = self.resampler(\n img=img, grid=grid, mode=mode or self.mode, padding_mode=padding_mode or self.padding_mode\n )\n return out\n\n\nclass Rand2DElastic(RandomizableTransform):\n \"\"\"\n Random elastic deformation and affine in 2D.\n A tutorial is available: https://github.com/Project-MONAI/tutorials/blob/0.6.0/modules/transforms_demo_2d.ipynb.\n\n \"\"\"\n\n backend = Resample.backend\n\n @deprecated_arg(name=\"as_tensor_output\", since=\"0.6\")\n def __init__(\n self,\n spacing: Union[Tuple[float, float], float],\n magnitude_range: Tuple[float, float],\n prob: float = 0.1,\n rotate_range: RandRange = None,\n shear_range: RandRange = None,\n translate_range: RandRange = None,\n scale_range: RandRange = None,\n spatial_size: Optional[Union[Tuple[int, int], int]] = None,\n mode: Union[GridSampleMode, str] = GridSampleMode.BILINEAR,\n padding_mode: Union[GridSamplePadMode, str] = GridSamplePadMode.REFLECTION,\n as_tensor_output: bool = False,\n device: Optional[torch.device] = None,\n ) -> None:\n \"\"\"\n Args:\n spacing : distance in between the control points.\n magnitude_range: the random offsets will be generated from ``uniform[magnitude[0], magnitude[1])``.\n prob: probability of returning a randomized elastic transform.\n defaults to 0.1, with 10% chance returns a randomized elastic transform,\n otherwise returns a ``spatial_size`` centered area extracted from the input image.\n rotate_range: angle range in radians. If element `i` is a pair of (min, max) values, then\n `uniform[-rotate_range[i][0], rotate_range[i][1])` will be used to generate the rotation parameter\n for the `i`th spatial dimension. If not, `uniform[-rotate_range[i], rotate_range[i])` will be used.\n This can be altered on a per-dimension basis. E.g., `((0,3), 1, ...)`: for dim0, rotation will be\n in range `[0, 3]`, and for dim1 `[-1, 1]` will be used. Setting a single value will use `[-x, x]`\n for dim0 and nothing for the remaining dimensions.\n shear_range: shear range with format matching `rotate_range`, it defines the range to randomly select\n shearing factors(a tuple of 2 floats for 2D) for affine matrix, take a 2D affine as example::\n\n [\n [1.0, params[0], 0.0],\n [params[1], 1.0, 0.0],\n [0.0, 0.0, 1.0],\n ]\n\n translate_range: translate range with format matching `rotate_range`, it defines the range to randomly\n select pixel to translate for every spatial dims.\n scale_range: scaling range with format matching `rotate_range`. it defines the range to randomly select\n the scale factor to translate for every spatial dims. A value of 1.0 is added to the result.\n This allows 0 to correspond to no change (i.e., a scaling of 1.0).\n spatial_size: specifying output image spatial size [h, w].\n if `spatial_size` and `self.spatial_size` are not defined, or smaller than 1,\n the transform will use the spatial size of `img`.\n if some components of the `spatial_size` are non-positive values, the transform will use the\n corresponding components of img size. For example, `spatial_size=(32, -1)` will be adapted\n to `(32, 64)` if the second spatial dimension size of img is `64`.\n mode: {``\"bilinear\"``, ``\"nearest\"``}\n Interpolation mode to calculate output values. Defaults to ``\"bilinear\"``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n padding_mode: {``\"zeros\"``, ``\"border\"``, ``\"reflection\"``}\n Padding mode for outside grid values. Defaults to ``\"reflection\"``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n device: device on which the tensor will be allocated.\n\n See also:\n - :py:class:`RandAffineGrid` for the random affine parameters configurations.\n - :py:class:`Affine` for the affine transformation parameters configurations.\n\n .. deprecated:: 0.6.0\n ``as_tensor_output`` is deprecated.\n\n \"\"\"\n RandomizableTransform.__init__(self, prob)\n self.deform_grid = RandDeformGrid(\n spacing=spacing, magnitude_range=magnitude_range, as_tensor_output=True, device=device\n )\n self.rand_affine_grid = RandAffineGrid(\n rotate_range=rotate_range,\n shear_range=shear_range,\n translate_range=translate_range,\n scale_range=scale_range,\n device=device,\n )\n self.resampler = Resample(device=device)\n\n self.device = device\n self.spatial_size = spatial_size\n self.mode: GridSampleMode = look_up_option(mode, GridSampleMode)\n self.padding_mode: GridSamplePadMode = look_up_option(padding_mode, GridSamplePadMode)\n\n def set_random_state(\n self, seed: Optional[int] = None, state: Optional[np.random.RandomState] = None\n ) -> \"Rand2DElastic\":\n self.deform_grid.set_random_state(seed, state)\n self.rand_affine_grid.set_random_state(seed, state)\n super().set_random_state(seed, state)\n return self\n\n def randomize(self, spatial_size: Sequence[int]) -> None:\n super().randomize(None)\n if not self._do_transform:\n return None\n self.deform_grid.randomize(spatial_size)\n self.rand_affine_grid.randomize()\n\n def __call__(\n self,\n img: NdarrayOrTensor,\n spatial_size: Optional[Union[Tuple[int, int], int]] = None,\n mode: Optional[Union[GridSampleMode, str]] = None,\n padding_mode: Optional[Union[GridSamplePadMode, str]] = None,\n randomize: bool = True,\n ) -> NdarrayOrTensor:\n \"\"\"\n Args:\n img: shape must be (num_channels, H, W),\n spatial_size: specifying output image spatial size [h, w].\n if `spatial_size` and `self.spatial_size` are not defined, or smaller than 1,\n the transform will use the spatial size of `img`.\n mode: {``\"bilinear\"``, ``\"nearest\"``}\n Interpolation mode to calculate output values. Defaults to ``self.mode``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n padding_mode: {``\"zeros\"``, ``\"border\"``, ``\"reflection\"``}\n Padding mode for outside grid values. Defaults to ``self.padding_mode``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n randomize: whether to execute `randomize()` function first, default to True.\n \"\"\"\n sp_size = fall_back_tuple(spatial_size or self.spatial_size, img.shape[1:])\n if randomize:\n self.randomize(spatial_size=sp_size)\n\n if self._do_transform:\n grid = self.deform_grid(spatial_size=sp_size)\n grid = self.rand_affine_grid(grid=grid)\n grid = torch.nn.functional.interpolate( # type: ignore\n recompute_scale_factor=True,\n input=grid.unsqueeze(0),\n scale_factor=list(ensure_tuple(self.deform_grid.spacing)),\n mode=InterpolateMode.BICUBIC.value,\n align_corners=False,\n )\n grid = CenterSpatialCrop(roi_size=sp_size)(grid[0])\n else:\n _device = img.device if isinstance(img, torch.Tensor) else self.device\n grid = create_grid(spatial_size=sp_size, device=_device, backend=\"torch\")\n out: NdarrayOrTensor = self.resampler(\n img, grid, mode=mode or self.mode, padding_mode=padding_mode or self.padding_mode\n )\n return out\n\n\nclass Rand3DElastic(RandomizableTransform):\n \"\"\"\n Random elastic deformation and affine in 3D.\n A tutorial is available: https://github.com/Project-MONAI/tutorials/blob/0.6.0/modules/transforms_demo_2d.ipynb.\n\n \"\"\"\n\n backend = Resample.backend\n\n @deprecated_arg(name=\"as_tensor_output\", since=\"0.6\")\n def __init__(\n self,\n sigma_range: Tuple[float, float],\n magnitude_range: Tuple[float, float],\n prob: float = 0.1,\n rotate_range: RandRange = None,\n shear_range: RandRange = None,\n translate_range: RandRange = None,\n scale_range: RandRange = None,\n spatial_size: Optional[Union[Tuple[int, int, int], int]] = None,\n mode: Union[GridSampleMode, str] = GridSampleMode.BILINEAR,\n padding_mode: Union[GridSamplePadMode, str] = GridSamplePadMode.REFLECTION,\n as_tensor_output: bool = False,\n device: Optional[torch.device] = None,\n ) -> None:\n \"\"\"\n Args:\n sigma_range: a Gaussian kernel with standard deviation sampled from\n ``uniform[sigma_range[0], sigma_range[1])`` will be used to smooth the random offset grid.\n magnitude_range: the random offsets on the grid will be generated from\n ``uniform[magnitude[0], magnitude[1])``.\n prob: probability of returning a randomized elastic transform.\n defaults to 0.1, with 10% chance returns a randomized elastic transform,\n otherwise returns a ``spatial_size`` centered area extracted from the input image.\n rotate_range: angle range in radians. If element `i` is a pair of (min, max) values, then\n `uniform[-rotate_range[i][0], rotate_range[i][1])` will be used to generate the rotation parameter\n for the `i`th spatial dimension. If not, `uniform[-rotate_range[i], rotate_range[i])` will be used.\n This can be altered on a per-dimension basis. E.g., `((0,3), 1, ...)`: for dim0, rotation will be\n in range `[0, 3]`, and for dim1 `[-1, 1]` will be used. Setting a single value will use `[-x, x]`\n for dim0 and nothing for the remaining dimensions.\n shear_range: shear range with format matching `rotate_range`, it defines the range to randomly select\n shearing factors(a tuple of 6 floats for 3D) for affine matrix, take a 3D affine as example::\n\n [\n [1.0, params[0], params[1], 0.0],\n [params[2], 1.0, params[3], 0.0],\n [params[4], params[5], 1.0, 0.0],\n [0.0, 0.0, 0.0, 1.0],\n ]\n\n translate_range: translate range with format matching `rotate_range`, it defines the range to randomly\n select voxel to translate for every spatial dims.\n scale_range: scaling range with format matching `rotate_range`. it defines the range to randomly select\n the scale factor to translate for every spatial dims. A value of 1.0 is added to the result.\n This allows 0 to correspond to no change (i.e., a scaling of 1.0).\n spatial_size: specifying output image spatial size [h, w, d].\n if `spatial_size` and `self.spatial_size` are not defined, or smaller than 1,\n the transform will use the spatial size of `img`.\n if some components of the `spatial_size` are non-positive values, the transform will use the\n corresponding components of img size. For example, `spatial_size=(32, 32, -1)` will be adapted\n to `(32, 32, 64)` if the third spatial dimension size of img is `64`.\n mode: {``\"bilinear\"``, ``\"nearest\"``}\n Interpolation mode to calculate output values. Defaults to ``\"bilinear\"``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n padding_mode: {``\"zeros\"``, ``\"border\"``, ``\"reflection\"``}\n Padding mode for outside grid values. Defaults to ``\"reflection\"``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n device: device on which the tensor will be allocated.\n\n See also:\n - :py:class:`RandAffineGrid` for the random affine parameters configurations.\n - :py:class:`Affine` for the affine transformation parameters configurations.\n\n .. deprecated:: 0.6.0\n ``as_tensor_output`` is deprecated.\n\n \"\"\"\n RandomizableTransform.__init__(self, prob)\n self.rand_affine_grid = RandAffineGrid(\n rotate_range=rotate_range,\n shear_range=shear_range,\n translate_range=translate_range,\n scale_range=scale_range,\n device=device,\n )\n self.resampler = Resample(device=device)\n\n self.sigma_range = sigma_range\n self.magnitude_range = magnitude_range\n self.spatial_size = spatial_size\n self.mode: GridSampleMode = look_up_option(mode, GridSampleMode)\n self.padding_mode: GridSamplePadMode = look_up_option(padding_mode, GridSamplePadMode)\n self.device = device\n\n self.rand_offset: np.ndarray\n self.magnitude = 1.0\n self.sigma = 1.0\n\n def set_random_state(\n self, seed: Optional[int] = None, state: Optional[np.random.RandomState] = None\n ) -> \"Rand3DElastic\":\n self.rand_affine_grid.set_random_state(seed, state)\n super().set_random_state(seed, state)\n return self\n\n def randomize(self, grid_size: Sequence[int]) -> None:\n super().randomize(None)\n if not self._do_transform:\n return None\n self.rand_offset = self.R.uniform(-1.0, 1.0, [3] + list(grid_size)).astype(np.float32, copy=False)\n self.magnitude = self.R.uniform(self.magnitude_range[0], self.magnitude_range[1])\n self.sigma = self.R.uniform(self.sigma_range[0], self.sigma_range[1])\n self.rand_affine_grid.randomize()\n\n def __call__(\n self,\n img: NdarrayOrTensor,\n spatial_size: Optional[Union[Tuple[int, int, int], int]] = None,\n mode: Optional[Union[GridSampleMode, str]] = None,\n padding_mode: Optional[Union[GridSamplePadMode, str]] = None,\n randomize: bool = True,\n ) -> NdarrayOrTensor:\n \"\"\"\n Args:\n img: shape must be (num_channels, H, W, D),\n spatial_size: specifying spatial 3D output image spatial size [h, w, d].\n if `spatial_size` and `self.spatial_size` are not defined, or smaller than 1,\n the transform will use the spatial size of `img`.\n mode: {``\"bilinear\"``, ``\"nearest\"``}\n Interpolation mode to calculate output values. Defaults to ``self.mode``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n padding_mode: {``\"zeros\"``, ``\"border\"``, ``\"reflection\"``}\n Padding mode for outside grid values. Defaults to ``self.padding_mode``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n randomize: whether to execute `randomize()` function first, default to True.\n \"\"\"\n sp_size = fall_back_tuple(spatial_size or self.spatial_size, img.shape[1:])\n if randomize:\n self.randomize(grid_size=sp_size)\n\n _device = img.device if isinstance(img, torch.Tensor) else self.device\n grid = create_grid(spatial_size=sp_size, device=_device, backend=\"torch\")\n if self._do_transform:\n if self.rand_offset is None:\n raise RuntimeError(\"rand_offset is not initialized.\")\n gaussian = GaussianFilter(3, self.sigma, 3.0).to(device=_device)\n offset = torch.as_tensor(self.rand_offset, device=_device).unsqueeze(0)\n grid[:3] += gaussian(offset)[0] * self.magnitude\n grid = self.rand_affine_grid(grid=grid)\n out: NdarrayOrTensor = self.resampler(\n img, grid, mode=mode or self.mode, padding_mode=padding_mode or self.padding_mode\n )\n return out\n\n\nclass GridDistortion(Transform):\n\n backend = [TransformBackends.TORCH]\n\n def __init__(\n self,\n num_cells: Union[Tuple[int], int],\n distort_steps: Sequence[Sequence[float]],\n mode: Union[GridSampleMode, str] = GridSampleMode.BILINEAR,\n padding_mode: Union[GridSamplePadMode, str] = GridSamplePadMode.BORDER,\n device: Optional[torch.device] = None,\n ) -> None:\n \"\"\"\n Grid distortion transform. Refer to:\n https://github.com/albumentations-team/albumentations/blob/master/albumentations/augmentations/transforms.py\n\n Args:\n num_cells: number of grid cells on each dimension.\n distort_steps: This argument is a list of tuples, where each tuple contains the distort steps of the\n corresponding dimensions (in the order of H, W[, D]). The length of each tuple equals to `num_cells + 1`.\n Each value in the tuple represents the distort step of the related cell.\n mode: {``\"bilinear\"``, ``\"nearest\"``}\n Interpolation mode to calculate output values. Defaults to ``\"bilinear\"``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n padding_mode: {``\"zeros\"``, ``\"border\"``, ``\"reflection\"``}\n Padding mode for outside grid values. Defaults to ``\"border\"``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n device: device on which the tensor will be allocated.\n\n \"\"\"\n self.resampler = Resample(mode=mode, padding_mode=padding_mode, device=device)\n self.num_cells = num_cells\n self.distort_steps = distort_steps\n self.device = device\n\n def __call__(\n self,\n img: NdarrayOrTensor,\n distort_steps: Optional[Sequence[Sequence]] = None,\n mode: Optional[Union[GridSampleMode, str]] = None,\n padding_mode: Optional[Union[GridSamplePadMode, str]] = None,\n ) -> NdarrayOrTensor:\n \"\"\"\n Args:\n img: shape must be (num_channels, H, W[, D]).\n distort_steps: This argument is a list of tuples, where each tuple contains the distort steps of the\n corresponding dimensions (in the order of H, W[, D]). The length of each tuple equals to `num_cells + 1`.\n Each value in the tuple represents the distort step of the related cell.\n mode: {``\"bilinear\"``, ``\"nearest\"``}\n Interpolation mode to calculate output values. Defaults to ``\"bilinear\"``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n padding_mode: {``\"zeros\"``, ``\"border\"``, ``\"reflection\"``}\n Padding mode for outside grid values. Defaults to ``\"border\"``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n\n \"\"\"\n distort_steps = self.distort_steps if distort_steps is None else distort_steps\n if len(img.shape) != len(distort_steps) + 1:\n raise ValueError(\"the spatial size of `img` does not match with the length of `distort_steps`\")\n\n all_ranges = []\n num_cells = ensure_tuple_rep(self.num_cells, len(img.shape) - 1)\n for dim_idx, dim_size in enumerate(img.shape[1:]):\n dim_distort_steps = distort_steps[dim_idx]\n ranges = torch.zeros(dim_size, dtype=torch.float32)\n cell_size = dim_size // num_cells[dim_idx]\n prev = 0\n for idx in range(num_cells[dim_idx] + 1):\n start = int(idx * cell_size)\n end = start + cell_size\n if end > dim_size:\n end = dim_size\n cur = dim_size\n else:\n cur = prev + cell_size * dim_distort_steps[idx]\n ranges[start:end] = torch.linspace(prev, cur, end - start)\n prev = cur\n ranges = ranges - (dim_size - 1.0) / 2.0\n all_ranges.append(ranges)\n\n coords = meshgrid_ij(*all_ranges)\n grid = torch.stack([*coords, torch.ones_like(coords[0])])\n\n return self.resampler(img, grid=grid, mode=mode, padding_mode=padding_mode) # type: ignore\n\n\nclass RandGridDistortion(RandomizableTransform):\n\n backend = [TransformBackends.TORCH]\n\n def __init__(\n self,\n num_cells: Union[Tuple[int], int] = 5,\n prob: float = 0.1,\n distort_limit: Union[Tuple[float, float], float] = (-0.03, 0.03),\n mode: Union[GridSampleMode, str] = GridSampleMode.BILINEAR,\n padding_mode: Union[GridSamplePadMode, str] = GridSamplePadMode.BORDER,\n device: Optional[torch.device] = None,\n ) -> None:\n \"\"\"\n Random grid distortion transform. Refer to:\n https://github.com/albumentations-team/albumentations/blob/master/albumentations/augmentations/transforms.py\n\n Args:\n num_cells: number of grid cells on each dimension.\n prob: probability of returning a randomized grid distortion transform. Defaults to 0.1.\n distort_limit: range to randomly distort.\n If single number, distort_limit is picked from (-distort_limit, distort_limit).\n Defaults to (-0.03, 0.03).\n mode: {``\"bilinear\"``, ``\"nearest\"``}\n Interpolation mode to calculate output values. Defaults to ``\"bilinear\"``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n padding_mode: {``\"zeros\"``, ``\"border\"``, ``\"reflection\"``}\n Padding mode for outside grid values. Defaults to ``\"border\"``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n device: device on which the tensor will be allocated.\n\n \"\"\"\n RandomizableTransform.__init__(self, prob)\n self.num_cells = num_cells\n if isinstance(distort_limit, (int, float)):\n self.distort_limit = (min(-distort_limit, distort_limit), max(-distort_limit, distort_limit))\n else:\n self.distort_limit = (min(distort_limit), max(distort_limit))\n self.distort_steps: Sequence[Sequence[float]] = ((1.0,),)\n self.grid_distortion = GridDistortion(\n num_cells=num_cells, distort_steps=self.distort_steps, mode=mode, padding_mode=padding_mode, device=device\n )\n\n def randomize(self, spatial_shape: Sequence[int]) -> None:\n super().randomize(None)\n if not self._do_transform:\n return\n self.distort_steps = tuple(\n tuple(1.0 + self.R.uniform(low=self.distort_limit[0], high=self.distort_limit[1], size=n_cells + 1))\n for n_cells in ensure_tuple_rep(self.num_cells, len(spatial_shape))\n )\n\n def __call__(\n self,\n img: NdarrayOrTensor,\n mode: Optional[Union[GridSampleMode, str]] = None,\n padding_mode: Optional[Union[GridSamplePadMode, str]] = None,\n randomize: bool = True,\n ) -> NdarrayOrTensor:\n \"\"\"\n Args:\n img: shape must be (num_channels, H, W[, D]).\n mode: {``\"bilinear\"``, ``\"nearest\"``}\n Interpolation mode to calculate output values. Defaults to ``\"bilinear\"``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n padding_mode: {``\"zeros\"``, ``\"border\"``, ``\"reflection\"``}\n Padding mode for outside grid values. Defaults to ``\"border\"``.\n See also: https://pytorch.org/docs/stable/generated/torch.nn.functional.grid_sample.html\n randomize: whether to shuffle the random factors using `randomize()`, default to True.\n \"\"\"\n if randomize:\n self.randomize(img.shape[1:])\n if not self._do_transform:\n return img\n return self.grid_distortion(img, distort_steps=self.distort_steps, mode=mode, padding_mode=padding_mode)\n",
"# Copyright (c) MONAI Consortium\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 collections.abc\nimport inspect\nimport itertools\nimport os\nimport random\nimport shutil\nimport tempfile\nimport types\nimport warnings\nfrom ast import literal_eval\nfrom distutils.util import strtobool\nfrom pathlib import Path\nfrom typing import Any, Callable, Optional, Sequence, Tuple, Union, cast\n\nimport numpy as np\nimport torch\n\nfrom monai.config.type_definitions import NdarrayOrTensor, PathLike\nfrom monai.utils.module import version_leq\n\n__all__ = [\n \"zip_with\",\n \"star_zip_with\",\n \"first\",\n \"issequenceiterable\",\n \"ensure_tuple\",\n \"ensure_tuple_size\",\n \"ensure_tuple_rep\",\n \"fall_back_tuple\",\n \"is_scalar_tensor\",\n \"is_scalar\",\n \"progress_bar\",\n \"get_seed\",\n \"set_determinism\",\n \"list_to_dict\",\n \"MAX_SEED\",\n \"copy_to_device\",\n \"ImageMetaKey\",\n \"is_module_ver_at_least\",\n \"has_option\",\n \"sample_slices\",\n \"save_obj\",\n]\n\n_seed = None\n_flag_deterministic = torch.backends.cudnn.deterministic\n_flag_cudnn_benchmark = torch.backends.cudnn.benchmark\nMAX_SEED = np.iinfo(np.uint32).max + 1 # 2**32, the actual seed should be in [0, MAX_SEED - 1] for uint32\n\n\ndef zip_with(op, *vals, mapfunc=map):\n \"\"\"\n Map `op`, using `mapfunc`, to each tuple derived from zipping the iterables in `vals`.\n \"\"\"\n return mapfunc(op, zip(*vals))\n\n\ndef star_zip_with(op, *vals):\n \"\"\"\n Use starmap as the mapping function in zipWith.\n \"\"\"\n return zip_with(op, *vals, mapfunc=itertools.starmap)\n\n\ndef first(iterable, default=None):\n \"\"\"\n Returns the first item in the given iterable or `default` if empty, meaningful mostly with 'for' expressions.\n \"\"\"\n for i in iterable:\n return i\n return default\n\n\ndef issequenceiterable(obj: Any) -> bool:\n \"\"\"\n Determine if the object is an iterable sequence and is not a string.\n \"\"\"\n if isinstance(obj, torch.Tensor):\n return int(obj.dim()) > 0 # a 0-d tensor is not iterable\n return isinstance(obj, collections.abc.Iterable) and not isinstance(obj, (str, bytes))\n\n\ndef ensure_tuple(vals: Any) -> Tuple[Any, ...]:\n \"\"\"\n Returns a tuple of `vals`.\n \"\"\"\n if not issequenceiterable(vals):\n return (vals,)\n\n return tuple(vals)\n\n\ndef ensure_tuple_size(tup: Any, dim: int, pad_val: Any = 0) -> Tuple[Any, ...]:\n \"\"\"\n Returns a copy of `tup` with `dim` values by either shortened or padded with `pad_val` as necessary.\n \"\"\"\n new_tup = ensure_tuple(tup) + (pad_val,) * dim\n return new_tup[:dim]\n\n\ndef ensure_tuple_rep(tup: Any, dim: int) -> Tuple[Any, ...]:\n \"\"\"\n Returns a copy of `tup` with `dim` values by either shortened or duplicated input.\n\n Raises:\n ValueError: When ``tup`` is a sequence and ``tup`` length is not ``dim``.\n\n Examples::\n\n >>> ensure_tuple_rep(1, 3)\n (1, 1, 1)\n >>> ensure_tuple_rep(None, 3)\n (None, None, None)\n >>> ensure_tuple_rep('test', 3)\n ('test', 'test', 'test')\n >>> ensure_tuple_rep([1, 2, 3], 3)\n (1, 2, 3)\n >>> ensure_tuple_rep(range(3), 3)\n (0, 1, 2)\n >>> ensure_tuple_rep([1, 2], 3)\n ValueError: Sequence must have length 3, got length 2.\n\n \"\"\"\n if isinstance(tup, torch.Tensor):\n tup = tup.detach().cpu().numpy()\n if isinstance(tup, np.ndarray):\n tup = tup.tolist()\n if not issequenceiterable(tup):\n return (tup,) * dim\n if len(tup) == dim:\n return tuple(tup)\n\n raise ValueError(f\"Sequence must have length {dim}, got {len(tup)}.\")\n\n\ndef fall_back_tuple(\n user_provided: Any, default: Union[Sequence, np.ndarray], func: Callable = lambda x: x and x > 0\n) -> Tuple[Any, ...]:\n \"\"\"\n Refine `user_provided` according to the `default`, and returns as a validated tuple.\n\n The validation is done for each element in `user_provided` using `func`.\n If `func(user_provided[idx])` returns False, the corresponding `default[idx]` will be used\n as the fallback.\n\n Typically used when `user_provided` is a tuple of window size provided by the user,\n `default` is defined by data, this function returns an updated `user_provided` with its non-positive\n components replaced by the corresponding components from `default`.\n\n Args:\n user_provided: item to be validated.\n default: a sequence used to provided the fallbacks.\n func: a Callable to validate every components of `user_provided`.\n\n Examples::\n\n >>> fall_back_tuple((1, 2), (32, 32))\n (1, 2)\n >>> fall_back_tuple(None, (32, 32))\n (32, 32)\n >>> fall_back_tuple((-1, 10), (32, 32))\n (32, 10)\n >>> fall_back_tuple((-1, None), (32, 32))\n (32, 32)\n >>> fall_back_tuple((1, None), (32, 32))\n (1, 32)\n >>> fall_back_tuple(0, (32, 32))\n (32, 32)\n >>> fall_back_tuple(range(3), (32, 64, 48))\n (32, 1, 2)\n >>> fall_back_tuple([0], (32, 32))\n ValueError: Sequence must have length 2, got length 1.\n\n \"\"\"\n ndim = len(default)\n user = ensure_tuple_rep(user_provided, ndim)\n return tuple( # use the default values if user provided is not valid\n user_c if func(user_c) else default_c for default_c, user_c in zip(default, user)\n )\n\n\ndef is_scalar_tensor(val: Any) -> bool:\n return isinstance(val, torch.Tensor) and val.ndim == 0\n\n\ndef is_scalar(val: Any) -> bool:\n if isinstance(val, torch.Tensor) and val.ndim == 0:\n return True\n return bool(np.isscalar(val))\n\n\ndef progress_bar(index: int, count: int, desc: Optional[str] = None, bar_len: int = 30, newline: bool = False) -> None:\n \"\"\"print a progress bar to track some time consuming task.\n\n Args:\n index: current status in progress.\n count: total steps of the progress.\n desc: description of the progress bar, if not None, show before the progress bar.\n bar_len: the total length of the bar on screen, default is 30 char.\n newline: whether to print in a new line for every index.\n \"\"\"\n end = \"\\r\" if not newline else \"\\r\\n\"\n filled_len = int(bar_len * index // count)\n bar = f\"{desc} \" if desc is not None else \"\"\n bar += \"[\" + \"=\" * filled_len + \" \" * (bar_len - filled_len) + \"]\"\n print(f\"{index}/{count} {bar}\", end=end)\n if index == count:\n print(\"\")\n\n\ndef get_seed() -> Optional[int]:\n return _seed\n\n\ndef set_determinism(\n seed: Optional[int] = np.iinfo(np.uint32).max,\n use_deterministic_algorithms: Optional[bool] = None,\n additional_settings: Optional[Union[Sequence[Callable[[int], Any]], Callable[[int], Any]]] = None,\n) -> None:\n \"\"\"\n Set random seed for modules to enable or disable deterministic training.\n\n Args:\n seed: the random seed to use, default is np.iinfo(np.int32).max.\n It is recommended to set a large seed, i.e. a number that has a good balance\n of 0 and 1 bits. Avoid having many 0 bits in the seed.\n if set to None, will disable deterministic training.\n use_deterministic_algorithms: Set whether PyTorch operations must use \"deterministic\" algorithms.\n additional_settings: additional settings that need to set random seed.\n\n Note:\n\n This function will not affect the randomizable objects in :py:class:`monai.transforms.Randomizable`, which\n have independent random states. For those objects, the ``set_random_state()`` method should be used to\n ensure the deterministic behavior (alternatively, :py:class:`monai.data.DataLoader` by default sets the seeds\n according to the global random state, please see also: :py:class:`monai.data.utils.worker_init_fn` and\n :py:class:`monai.data.utils.set_rnd`).\n \"\"\"\n if seed is None:\n # cast to 32 bit seed for CUDA\n seed_ = torch.default_generator.seed() % (np.iinfo(np.int32).max + 1)\n torch.manual_seed(seed_)\n else:\n seed = int(seed) % MAX_SEED\n torch.manual_seed(seed)\n\n global _seed\n _seed = seed\n random.seed(seed)\n np.random.seed(seed)\n\n if additional_settings is not None:\n additional_settings = ensure_tuple(additional_settings)\n for func in additional_settings:\n func(seed)\n\n if torch.backends.flags_frozen():\n warnings.warn(\"PyTorch global flag support of backends is disabled, enable it to set global `cudnn` flags.\")\n torch.backends.__allow_nonbracketed_mutation_flag = True\n\n if seed is not None:\n torch.backends.cudnn.deterministic = True\n torch.backends.cudnn.benchmark = False\n else: # restore the original flags\n torch.backends.cudnn.deterministic = _flag_deterministic\n torch.backends.cudnn.benchmark = _flag_cudnn_benchmark\n if use_deterministic_algorithms is not None:\n if hasattr(torch, \"use_deterministic_algorithms\"): # `use_deterministic_algorithms` is new in torch 1.8.0\n torch.use_deterministic_algorithms(use_deterministic_algorithms)\n elif hasattr(torch, \"set_deterministic\"): # `set_deterministic` is new in torch 1.7.0\n torch.set_deterministic(use_deterministic_algorithms) # type: ignore\n else:\n warnings.warn(\"use_deterministic_algorithms=True, but PyTorch version is too old to set the mode.\")\n\n\ndef list_to_dict(items):\n \"\"\"\n To convert a list of \"key=value\" pairs into a dictionary.\n For examples: items: `[\"a=1\", \"b=2\", \"c=3\"]`, return: {\"a\": \"1\", \"b\": \"2\", \"c\": \"3\"}.\n If no \"=\" in the pair, use None as the value, for example: [\"a\"], return: {\"a\": None}.\n Note that it will remove the blanks around keys and values.\n\n \"\"\"\n\n def _parse_var(s):\n items = s.split(\"=\", maxsplit=1)\n key = items[0].strip(\" \\n\\r\\t'\")\n value = items[1].strip(\" \\n\\r\\t'\") if len(items) > 1 else None\n return key, value\n\n d = {}\n if items:\n for item in items:\n key, value = _parse_var(item)\n\n try:\n if key in d:\n raise KeyError(f\"encounter duplicated key {key}.\")\n d[key] = literal_eval(value)\n except ValueError:\n try:\n d[key] = bool(strtobool(str(value)))\n except ValueError:\n d[key] = value\n return d\n\n\ndef copy_to_device(\n obj: Any, device: Optional[Union[str, torch.device]], non_blocking: bool = True, verbose: bool = False\n) -> Any:\n \"\"\"\n Copy object or tuple/list/dictionary of objects to ``device``.\n\n Args:\n obj: object or tuple/list/dictionary of objects to move to ``device``.\n device: move ``obj`` to this device. Can be a string (e.g., ``cpu``, ``cuda``,\n ``cuda:0``, etc.) or of type ``torch.device``.\n non_blocking: when `True`, moves data to device asynchronously if\n possible, e.g., moving CPU Tensors with pinned memory to CUDA devices.\n verbose: when `True`, will print a warning for any elements of incompatible type\n not copied to ``device``.\n Returns:\n Same as input, copied to ``device`` where possible. Original input will be\n unchanged.\n \"\"\"\n\n if hasattr(obj, \"to\"):\n return obj.to(device, non_blocking=non_blocking)\n if isinstance(obj, tuple):\n return tuple(copy_to_device(o, device, non_blocking) for o in obj)\n if isinstance(obj, list):\n return [copy_to_device(o, device, non_blocking) for o in obj]\n if isinstance(obj, dict):\n return {k: copy_to_device(o, device, non_blocking) for k, o in obj.items()}\n if verbose:\n fn_name = cast(types.FrameType, inspect.currentframe()).f_code.co_name\n warnings.warn(f\"{fn_name} called with incompatible type: \" + f\"{type(obj)}. Data will be returned unchanged.\")\n\n return obj\n\n\nclass ImageMetaKey:\n \"\"\"\n Common key names in the meta data header of images\n \"\"\"\n\n FILENAME_OR_OBJ = \"filename_or_obj\"\n PATCH_INDEX = \"patch_index\"\n\n\ndef has_option(obj, keywords: Union[str, Sequence[str]]) -> bool:\n \"\"\"\n Return a boolean indicating whether the given callable `obj` has the `keywords` in its signature.\n \"\"\"\n if not callable(obj):\n return False\n sig = inspect.signature(obj)\n return all(key in sig.parameters for key in ensure_tuple(keywords))\n\n\ndef is_module_ver_at_least(module, version):\n \"\"\"Determine if a module's version is at least equal to the given value.\n\n Args:\n module: imported module's name, e.g., `np` or `torch`.\n version: required version, given as a tuple, e.g., `(1, 8, 0)`.\n Returns:\n `True` if module is the given version or newer.\n \"\"\"\n test_ver = \".\".join(map(str, version))\n return module.__version__ != test_ver and version_leq(test_ver, module.__version__)\n\n\ndef sample_slices(data: NdarrayOrTensor, dim: int = 1, as_indices: bool = True, *slicevals: int) -> NdarrayOrTensor:\n \"\"\"sample several slices of input numpy array or Tensor on specified `dim`.\n\n Args:\n data: input data to sample slices, can be numpy array or PyTorch Tensor.\n dim: expected dimension index to sample slices, default to `1`.\n as_indices: if `True`, `slicevals` arg will be treated as the expected indices of slice, like: `1, 3, 5`\n means `data[..., [1, 3, 5], ...]`, if `False`, `slicevals` arg will be treated as args for `slice` func,\n like: `1, None` means `data[..., [1:], ...]`, `1, 5` means `data[..., [1: 5], ...]`.\n slicevals: indices of slices or start and end indices of expected slices, depends on `as_indices` flag.\n\n \"\"\"\n slices = [slice(None)] * len(data.shape)\n slices[dim] = slicevals if as_indices else slice(*slicevals) # type: ignore\n\n return data[tuple(slices)]\n\n\ndef save_obj(\n obj, path: PathLike, create_dir: bool = True, atomic: bool = True, func: Optional[Callable] = None, **kwargs\n):\n \"\"\"\n Save an object to file with specified path.\n Support to serialize to a temporary file first, then move to final destination,\n so that files are guaranteed to not be damaged if exception occurs.\n\n Args:\n obj: input object data to save.\n path: target file path to save the input object.\n create_dir: whether to create dictionary of the path if not existng, default to `True`.\n atomic: if `True`, state is serialized to a temporary file first, then move to final destination.\n so that files are guaranteed to not be damaged if exception occurs. default to `True`.\n func: the function to save file, if None, default to `torch.save`.\n kwargs: other args for the save `func` except for the checkpoint and filename.\n default `func` is `torch.save()`, details of other args:\n https://pytorch.org/docs/stable/generated/torch.save.html.\n\n \"\"\"\n path = Path(path)\n path_dir = path.parent\n if not path_dir.exists():\n if create_dir:\n path_dir.mkdir(parents=True)\n else:\n raise ValueError(f\"the directory of specified path is not existing: {path_dir}.\")\n if path.exists():\n # remove the existing file\n os.remove(path)\n\n if func is None:\n func = torch.save\n\n if not atomic:\n func(obj=obj, f=path, **kwargs)\n return\n try:\n # writing to a temporary directory and then using a nearly atomic rename operation\n with tempfile.TemporaryDirectory() as tempdir:\n temp_path: Path = Path(tempdir) / path.name\n func(obj=obj, f=temp_path, **kwargs)\n if temp_path.is_file():\n shutil.move(str(temp_path), path)\n except PermissionError: # project-monai/monai issue #3613\n pass\n"
] | [
[
"torch.linspace",
"numpy.linalg.solve",
"numpy.allclose",
"numpy.meshgrid",
"torch.zeros",
"numpy.asarray",
"torch.solve",
"numpy.eye",
"torch.eye",
"numpy.append",
"torch.linalg.solve",
"numpy.argsort",
"torch.flip",
"numpy.array",
"numpy.flip",
"torch.ones_like",
"torch.as_tensor"
],
[
"numpy.random.seed",
"torch.manual_seed",
"torch.use_deterministic_algorithms",
"torch.default_generator.seed",
"numpy.iinfo",
"numpy.isscalar",
"torch.set_deterministic",
"torch.backends.flags_frozen"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
seitalab/compass | [
"b08b0b711875e8e049ff07793ffe1446a6c3f144"
] | [
"compass/embedding.py"
] | [
"from sklearn.metrics.pairwise import cosine_similarity\nfrom sklearn.manifold import TSNE\nfrom sklearn.cluster import AgglomerativeClustering, KMeans\nfrom sklearn.preprocessing import MinMaxScaler\nimport matplotlib.pyplot as plt\nimport matplotlib\nimport seaborn as sns\nimport pandas\nimport matplotlib.cm as cm\nimport umap\nimport tqdm\nimport scanpy as sc\nimport matplotlib.gridspec as gridspec\nimport networkx as nx\n\nimport numpy\nimport operator\nimport random\nimport pickle\nimport collections\nimport sys\nimport os\n\nclass GeneEmbedding(object):\n\n def __init__(self, embedding_file, context):\n self.vector = []\n self.context = context\n self.embedding_file = embedding_file\n self.embeddings = self.read_embedding(self.embedding_file)\n self.vector = []\n self.genes = []\n for gene in tqdm.tqdm(self.context.expressed_genes):\n if gene in self.embeddings:\n self.vector.append(self.embeddings[gene])\n self.genes.append(gene)\n\n def read_embedding(self, filename):\n embedding = dict()\n lines = open(filename,\"r\").read().splitlines()[1:]\n for line in lines:\n vector = line.split()\n gene = vector.pop(0)\n embedding[gene] = [float(x) for x in vector]\n return embedding\n\n def compute_similarities(self, gene, subset=None):\n print(\"hit\")\n if gene not in self.embeddings:\n return None\n embedding = self.embeddings[gene]\n distances = dict()\n if subset:\n targets = set(list(self.embeddings.keys())).intersection(set(subset))\n else:\n targets = list(self.embeddings.keys())\n for target in targets:\n if target not in self.embeddings:\n continue\n v = self.embeddings[target]\n distance = float(cosine_similarity(numpy.array(embedding).reshape(1, -1),numpy.array(v).reshape(1, -1))[0])\n distances[target] = distance\n sorted_distances = list(reversed(sorted(distances.items(), key=operator.itemgetter(1))))\n genes = [x[0] for x in sorted_distances]\n distance = [x[1] for x in sorted_distances]\n df = pandas.DataFrame.from_dict({\"Gene\":genes, \"Similarity\":distance})\n return df\n\n def cluster(self, n=12):\n kmeans = KMeans(n_clusters=n)\n kmeans.fit(self.vector)\n clusters = kmeans.labels_\n clusters = zip(self.context.expressed_genes, clusters)\n _clusters = []\n for gene, cluster in clusters:\n _clusters.append(\"G\"+str(cluster))\n return _clusters\n\n def clusters(self, clusters):\n average_vector = dict()\n gene_to_cluster = collections.defaultdict(list)\n matrix = collections.defaultdict(list)\n total_average_vector = []\n for gene, cluster in zip(self.context.expressed_genes, clusters):\n if gene in self.embeddings:\n matrix[cluster].append(self.embeddings[gene])\n gene_to_cluster[cluster].append(gene)\n total_average_vector.append(self.embeddings[gene])\n self.total_average_vector = list(numpy.average(total_average_vector, axis=0))\n for cluster, vectors in matrix.items():\n xvec = list(numpy.average(vectors, axis=0))\n average_vector[cluster] = numpy.subtract(xvec,self.total_average_vector)\n return average_vector, gene_to_cluster\n\n def generate_vector(self, genes):\n vector = []\n for gene, vec in zip(self.genes, self.vector):\n if gene in genes:\n vector.append(vec)\n return list(numpy.median(vector, axis=0))\n\n def cluster_definitions(self, clusters):\n average_vector, gene_to_cluster = self.clusters(clusters)\n similarities = collections.defaultdict(dict)\n for cluster, vector in average_vector.items():\n distances = dict()\n for target in gene_to_cluster[cluster]:\n v = self.embeddings[target]\n distance = float(cosine_similarity(numpy.array(vector).reshape(1, -1),numpy.array(v).reshape(1, -1))[0])\n distances[target] = distance\n sorted_distances = list(reversed(sorted(distances.items(), key=operator.itemgetter(1))))\n similarities[cluster] = [x[0] for x in sorted_distances if x[0]]\n return similarities\n\n def cluster_definitions_as_df(self, similarities, top_n=20):\n clusters = []\n symbols = []\n for key, genes in similarities.items():\n clusters.append(key)\n symbols.append(\", \".join(genes[:top_n]))\n df = pandas.DataFrame.from_dict({\"Cluster Name\":clusters, \"Top Genes\":symbols})\n return df\n\n def plot(self, clusters, png=None, method=\"TSNE\", labels=[], pcs=None, remove=[]):\n plt.figure(figsize = (8, 8))\n ax = plt.subplot(1,1,1)\n pcs = self.plot_reduction(clusters, ax, labels=labels, method=method, pcs=pcs, remove=remove)\n if png:\n plt.savefig(png)\n plt.close()\n else:\n plt.show()\n return pcs\n\n def plot_reduction(self, clusters, ax, method=\"TSNE\", labels=[], pcs=None, remove=[]):\n if type(pcs) != numpy.ndarray:\n if method == \"TSNE\":\n print(\"Running t-SNE\")\n pca = TSNE(n_components=2, n_jobs=-1, metric=\"cosine\")\n pcs = pca.fit_transform(self.vector)\n pcs = numpy.transpose(pcs)\n print(\"Finished.\")\n else:\n print(\"Running UMAP\")\n trans = umap.UMAP(random_state=42,metric='cosine').fit(self.vector)\n x = trans.embedding_[:, 0]\n y = trans.embedding_[:, 1]\n pcs = [x,y]\n print(\"Finished.\")\n if len(remove) != 0:\n _pcsx = []\n _pcsy = []\n _clusters = []\n \n for x, y, c in zip(pcs[0],pcs[1],clusters):\n if c not in remove:\n _pcsx.append(x)\n _pcsy.append(y)\n _clusters.append(c)\n pcs = []\n pcs.append(_pcsx)\n pcs.append(_pcsy)\n clusters = _clusters\n data = {\"x\":pcs[0],\"y\":pcs[1], \"Cluster\":clusters}\n df = pandas.DataFrame.from_dict(data)\n sns.scatterplot(data=df,x=\"x\", y=\"y\",hue=\"Cluster\", ax=ax)\n plt.xlabel(\"{}-1\".format(method))\n plt.ylabel(\"{}-2\".format(method))\n ax.set_xticks([])\n ax.set_yticks([])\n if len(labels):\n for x, y, gene in zip(pcs[0], pcs[1], self.context.expressed_genes):\n if gene in labels:\n ax.text(x+.02, y, str(gene), fontsize=8)\n return pcs\n\n def subtract_vector(self, vector):\n for gene, vec in self.embeddings.items():\n vec = numpy.subtract(vec-vector)\n self.embeddings[gene] = vec\n\n @staticmethod\n def relabel_cluster(similarities, clusters, old_label, new_label):\n genes = similarities[old_label]\n del similarities[old_label]\n similarities[new_label] = genes\n _clusters = []\n for cluster in clusters:\n if cluster == old_label:\n _clusters.append(new_label)\n else:\n _clusters.append(cluster)\n return similarities, _clusters\n\n def plot_similarity_matrix(self, markers, marker_labels=None, png=None):\n cmap = matplotlib.cm.tab20\n if marker_labels:\n marker_colors = {}\n ctypes = []\n for value in marker_labels.values():\n ctypes.append(value)\n ctypes = list(set(ctypes))\n for key, value in marker_labels.items():\n marker_colors[key] = cmap(ctypes.index(value))\n colors = pandas.DataFrame(markers)[0].map(marker_colors)\n similarity_matrix = []\n print(\"Running\")\n markers = set(list(self.embeddings.keys())).intersection(set(markers))\n markers = list(markers)\n for marker in markers:\n print(marker)\n row = []\n res = self.compute_similarities(marker, subset=markers)\n resdict = dict(zip(res[\"Gene\"],res[\"Similarity\"]))\n for gene in markers:\n row.append(resdict[gene])\n similarity_matrix.append(row)\n plt.figure(figsize = (12, 10))\n matrix = numpy.array(similarity_matrix)\n df = pandas.DataFrame(matrix,index=markers,columns=markers)\n sns.clustermap(df,figsize=(12,8), dendrogram_ratio=0.1)\n plt.tight_layout()\n if png:\n plt.savefig(\"marker_similarity.png\")\n else:\n plt.show()\n \n def plot_similarity_network(self, markers, marker_labels=None, png=None):\n cmap = matplotlib.cm.tab20\n G = nx.petersen_graph()\n node_color = []\n node_order = []\n node_size = []\n edge_order = []\n edge_color = []\n edge_labels = dict()\n for marker in markers:\n node_order.append(marker)\n if marker_labels:\n ctypes = []\n for value in marker_labels.values():\n ctypes.append(value)\n ctypes = list(set(ctypes))\n node_color.append(ctypes.index(marker_labels[marker]))\n node_size.append(400)\n G.add_node(marker)\n for marker in markers:\n res = self.compute_similarities(marker)\n resdict = dict(zip(res[\"Gene\"],res[\"Similarity\"]))\n i = 0\n for gene, similarity in resdict.items():\n if i > 9: break\n if gene != marker:\n if gene not in G.nodes():\n node_size.append(0)\n G.add_node(gene)\n node_order.append(gene)\n node_color.append(len(set(marker_labels.values())))\n print(marker, gene)\n G.add_edge(marker, gene, weight=similarity)\n edge_color.append(similarity)\n edge_order.append((marker,gene))\n edge_labels[(marker,gene)] = str(round(similarity,2))\n i += 1\n # print(node_color)\n # c = max(nx.connected_components(G), key=len)\n # G = G.subgraph(c).copy()\n for i in range(10):\n G.remove_node(i)\n print(G.nodes())\n print(G.edges())\n fig = plt.figure(figsize=(8,8))\n ax = plt.subplot(1,1,1)\n #pos = nx.nx_agraph.graphviz_layout(G, prog=\"neato\",args=\"-Goverlap=scale\")\n pos = nx.nx_agraph.graphviz_layout(G, prog=\"neato\",args=\"-Goverlap=scale -Elen=5 -Eweight=0.2\")\n #pos = nx.spring_layout(G)\n nx.draw(G,pos,ax=ax, cmap=cmap,nodelist=node_order, node_size=node_size,edgelist=edge_order, node_color=node_color, edge_color=edge_color, edge_vmin=0, edge_vmax=1.0, edge_cmap=plt.cm.Greys, with_labels=True, width=1,font_size=7)\n nx.draw_networkx_edge_labels(G,pos,edge_labels=edge_labels, font_size=6)\n plt.axis('off')\n plt.tight_layout()\n if png:\n plt.savefig(png)\n else:\n plt.show()\n\nclass CellEmbedding(object):\n\n def __init__(self, context, embed):\n\n cell_to_gene = list(context.cell_to_gene.items())\n self.context = context\n self.embed = embed\n self.expression = context.expression\n self.data = collections.defaultdict(list)\n self.weights = collections.defaultdict(list)\n\n for cell, genes in tqdm.tqdm(cell_to_gene):\n if len(genes) < 2: continue\n if cell in self.expression:\n cell_weights = self.expression[cell]\n for gene in set(genes).intersection(set(embed.embeddings.keys())):\n if gene in cell_weights:\n weight = self.expression[cell][gene]\n if weight > 0:\n self.data[cell].append(embed.embeddings[gene])\n self.weights[cell].append(weight)\n self.matrix = []\n dataset_vector = []\n for cell, vectors in self.data.items():\n weights = self.weights[cell]\n xvec = list(numpy.average(vectors, axis=0, weights=weights))\n self.matrix.append(xvec)\n dataset_vector += vectors\n\n self.dataset_vector = numpy.average(dataset_vector, axis=0)\n _matrix = []\n for vec in self.matrix:\n _matrix.append(numpy.subtract(vec, self.dataset_vector))\n self.matrix = _matrix\n\n def batch_correct(self, column=None, clusters=None):\n if not column or not clusters:\n raise ValueError(\"Must supply batch column and clusters!\")\n column_labels = dict(zip(self.context.cells,self.context.metadata[column]))\n labels = []\n for key in self.data.keys():\n labels.append(column_labels[key])\n local_correction = collections.defaultdict(lambda : collections.defaultdict(list))\n correction_vectors = collections.defaultdict(dict)\n for cluster, batch, vec in zip(clusters, labels, self.matrix):\n local_correction[cluster][batch].append(vec)\n for cluster, batches in local_correction.items():\n cluster_vec = []\n batch_keys = list(batches.keys())\n base_batch = batch_keys.pop(0)\n max_distance = 1.0\n cluster_vec = numpy.average(batches[base_batch], axis=0)\n for batch in batch_keys:\n bvec = list(numpy.average(batches[batch], axis=0))\n distance = float(cosine_similarity(numpy.array(bvec).reshape(1, -1),numpy.array(cluster_vec).reshape(1, -1))[0])\n if max_distance > distance:\n max_distance = distance\n offset = numpy.subtract(cluster_vec,bvec)\n bvec = numpy.add(bvec,offset)\n distance = float(cosine_similarity(numpy.array(bvec).reshape(1, -1),numpy.array(cluster_vec).reshape(1, -1))[0])\n correction_vectors[cluster][batch] = offset\n\n self.matrix = []\n self.sample_vector = collections.defaultdict(list)\n i = 0\n self.cell_order = []\n for cell, vectors in self.data.items():\n cluster = clusters[i]\n xvec = list(numpy.average(vectors, axis=0))\n batch = column_labels[cell]\n if cluster in correction_vectors and batch in correction_vectors[cluster]:\n offset = correction_vectors[cluster][batch]\n xvec = numpy.add(xvec,offset)\n self.matrix.append(xvec)\n self.cell_order.append(cell)\n i += 1\n\n def cluster(self, k=12):\n kmeans = KMeans(n_clusters=k)\n kmeans.fit(self.matrix)\n clusters = kmeans.labels_\n _clusters = []\n for cluster in clusters:\n _clusters.append(\"C\"+str(cluster))\n self.clusters = _clusters\n return _clusters\n\n def subtract_vector(self, vector):\n corrected_matrix = []\n for cell_vector in self.matrix:\n corrected_matrix.append(numpy.subtract(cell_vector, vector))\n self.matrix = corrected_matrix\n\n def compute_gene_similarities(self):\n gene_similarities = dict()\n vectors = collections.defaultdict(list)\n for vec, label in zip(self.matrix, self.clusters):\n vectors[label].append(vec)\n for label, vecs in vectors.items():\n distances = dict()\n cell_vector = list(numpy.mean(vecs, axis=0))\n for gene, vector in self.embed.embeddings.items():\n distance = float(cosine_similarity(numpy.array(cell_vector).reshape(1, -1),numpy.array(vector).reshape(1, -1))[0])\n distances[gene] = distance\n sorted_distances = list(reversed(sorted(distances.items(), key=operator.itemgetter(1))))\n gene_similarities[label] = [x[0] for x in sorted_distances]\n print(label, sorted_distances[:10])\n return gene_similarities\n\n def group_cell_vectors(self, barcode_to_label):\n label_vector = dict()\n labels = []\n for cell, vectors in self.data.items():\n vector = list(numpy.median(vectors, axis=0))\n labels.append(barcode_to_label[cell])\n label_vector[barcode_to_label[cell]] = vector\n for cell, vectors in self.data.items():\n _vectors = []\n for vector in vectors:\n _vectors.append(numpy.subtract(vector, label_vector[barcode_to_label[cell]]))\n vectors = _vectors\n vector = list(numpy.median(vectors, axis=0))\n label_vector[barcode_to_label[cell]] = vector\n return label_vector, labels\n\n def compute_cell_similarities(self, barcode_to_label):\n vectors = dict()\n cell_similarities = dict()\n vectors, labels = self.group_cell_vectors(barcode_to_label)\n for label, vector in vectors.items():\n distances = dict()\n for label2, vector2 in vectors.items():\n xdist = []\n distance = float(cosine_similarity(numpy.array(vector).reshape(1, -1),numpy.array(vector2).reshape(1, -1))[0])\n xdist.append(distance)\n distances[label2] = distance\n cell_similarities[label] = distances\n return cell_similarities\n\n def plot_reduction(self, ax, pcs=None, method=\"TSNE\", clusters=None, labels=None):\n if type(pcs) != numpy.ndarray:\n if method == \"TSNE\":\n print(\"Running t-SNE\")\n pca = TSNE(n_components=2, n_jobs=-1, metric=\"cosine\")\n pcs = pca.fit_transform(self.matrix)\n pcs = numpy.transpose(pcs)\n print(\"Finished.\")\n else:\n print(\"Running UMAP\")\n trans = umap.UMAP(random_state=42,metric='cosine').fit(self.matrix)\n x = trans.embedding_[:, 0]\n y = trans.embedding_[:, 1]\n pcs = [x,y]\n print(\"Finished.\")\n data = {\"x\":pcs[0],\"y\":pcs[1],\"Cluster\": clusters}\n df = pandas.DataFrame.from_dict(data)\n sns.scatterplot(data=df,x=\"x\", y=\"y\", hue='Cluster', ax=ax,linewidth=0.1,s=13,alpha=1.0)\n return pcs\n\n def plot(self, png=None, pcs=None, method=\"TSNE\", column=None):\n if column:\n column_labels = dict(zip(self.context.cells,self.context.metadata[column]))\n labels = []\n for key in self.data.keys():\n labels.append(column_labels[key])\n else:\n labels = self.clusters\n plt.figure(figsize = (8, 8))\n ax1 = plt.subplot(1,1,1)\n pcs = self.plot_reduction(ax1, pcs=pcs, clusters=labels, method=method)\n plt.xlabel(\"{}-1\".format(method))\n plt.ylabel(\"{}-2\".format(method))\n ax1.set_xticks([])\n ax1.set_yticks([])\n if png:\n plt.savefig(png)\n plt.close()\n else:\n plt.show()\n return pcs\n\n def plot_distance(self, vector, pcs=None):\n plt.figure(figsize = (8,8))\n ax = plt.subplot(1,1, 1)\n if type(pcs) != numpy.ndarray:\n pca = TSNE(n_components=2)\n pcs = pca.fit_transform(self.matrix)\n pcs = numpy.transpose(pcs)\n distances = []\n dataset_distance = float(cosine_similarity(numpy.array(vector).reshape(1, -1),numpy.array(self.dataset_vector).reshape(1, -1))[0])\n for cell_vector in self.matrix:\n distance = float(cosine_similarity(numpy.array(cell_vector).reshape(1, -1),numpy.array(vector).reshape(1, -1))[0])\n distances.append(distance-dataset_distance)\n data = {\"x\":pcs[0],\"y\":pcs[1],\"Distance\": distances}\n df = pandas.DataFrame.from_dict(data)\n sns.scatterplot(data=df,x=\"x\", y=\"y\", hue='Distance', ax=ax,linewidth=0.00,s=7,alpha=0.7)\n return pcs\n\n def plot_gene_tsne(self, title, ax, genes, pcs=None):\n expression = [0 for _ in range(len(list(self.data.keys())))]\n for gene in genes:\n for i, cell in enumerate(self.data.keys()):\n if gene in self.expression[cell]:\n expression[i] += self.expression[cell][gene]\n if type(pcs) != numpy.ndarray:\n pca = TSNE(n_components=2)\n pcs = pca.fit_transform(self.matrix)\n pcs = numpy.transpose(pcs)\n data = {\"x\":pcs[0],\"y\":pcs[1],\"Gene Expression\": expression}\n df = pandas.DataFrame.from_dict(data)\n sns.scatterplot(data=df,x=\"x\", y=\"y\", hue='Gene Expression', ax=ax,linewidth=0.00,s=7,alpha=0.7)\n ax.set_title(title,fontsize=16)\n return pcs\n\n def plot_gene_expression(self, genes, pcs=None, png=None):\n plt.figure(figsize = (8,8))\n ax = plt.subplot(1,1, 1)\n pcs = self.plot_gene_tsne(\",\".join(genes[:10]), ax, genes, pcs=pcs)\n ax.set_xticks([])\n ax.set_yticks([])\n if not png:\n plt.show()\n else:\n plt.savefig(png)\n plt.close()\n return pcs\n \n def plot_similarity_matrix(self, vectors, column):\n similarity_matrix = []\n plt.figure(figsize = (12, 10))\n barcode_to_label = dict(zip(cembed.context.metadata.index, cembed.context.metadata[column]))\n ctypes = cembed.group_cell_vectors()\n matrix = []\n clusters = list(vectors.keys())\n celltypes = list(cytpes.keys())\n for cluster, genes in vectors.items():\n vector = embed.generate_vector(genes)\n row = []\n for cell in ctypes.keys():\n distance = float(cosine_similarity(numpy.array(ctypes[cell]).reshape(1, -1),numpy.array(vector).reshape(1, -1))[0])\n row.append()\n matrix.append(row)\n matrix = numpy.array(matrix)\n df = pandas.DataFrame(matrix,index=celltypes,columns=celltypes)\n sns.clustermap(df,figsize=(17,8))\n plt.tight_layout()\n plt.savefig(os.path.join(output_path,\"celltype_similarities_{}.png\".format(sample)))"
] | [
[
"matplotlib.pyplot.tight_layout",
"sklearn.cluster.KMeans",
"numpy.median",
"numpy.subtract",
"numpy.average",
"pandas.DataFrame",
"matplotlib.pyplot.savefig",
"numpy.transpose",
"sklearn.manifold.TSNE",
"matplotlib.pyplot.subplot",
"numpy.mean",
"matplotlib.pyplot.axis",
"matplotlib.pyplot.close",
"pandas.DataFrame.from_dict",
"numpy.add",
"numpy.array",
"matplotlib.pyplot.show",
"matplotlib.pyplot.figure"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"0.23",
"0.21",
"2.0",
"1.4",
"1.3",
"0.19",
"1.1",
"1.5",
"0.24",
"0.20",
"1.0",
"0.25",
"1.2"
],
"scipy": [],
"tensorflow": []
}
] |
azawalich/flair | [
"f0101ab25381aefa586ecb688d4f412d5fab5de3"
] | [
"flair/trainers/language_model_trainer.py"
] | [
"\nimport time\nimport datetime\nimport random\nimport sys\nimport logging\nfrom pathlib import Path\nfrom typing import Union\nfrom torch import cuda\nfrom torch.utils.data import Dataset, DataLoader\nfrom torch.optim.sgd import SGD\ntry:\n from apex import amp\nexcept ImportError:\n amp = None\nimport flair\nfrom flair.data import Dictionary\nfrom flair.models import LanguageModel\nfrom flair.optim import *\nfrom flair.training_utils import add_file_handler\nlog = logging.getLogger('flair')\n\n\nclass TextDataset(Dataset):\n\n def __init__(self, path, dictionary, expand_vocab=False, forward=True, split_on_char=True, random_case_flip=True, shuffle_lines=True):\n assert path.exists()\n self.files = None\n self.path = path\n self.dictionary = dictionary\n self.split_on_char = split_on_char\n self.forward = forward\n self.random_case_flip = random_case_flip\n self.expand_vocab = expand_vocab\n self.shuffle_lines = shuffle_lines\n if path.is_dir():\n self.files = sorted([f for f in path.iterdir() if f.exists()])\n else:\n self.files = [path]\n\n def __len__(self):\n return len(self.files)\n\n def __getitem__(self, index=0):\n return self.charsplit(self.files[index], self.expand_vocab, self.forward, self.split_on_char, self.random_case_flip)\n\n def charsplit(self, path, expand_vocab=False, forward=True, split_on_char=True, random_case_flip=True):\n 'Tokenizes a text file on character basis.'\n assert path.exists()\n lines = open(path, 'r', encoding='utf-8').readlines()\n log.info(\n ''.join(['read text file with ', '{}'.format(len(lines)), ' lines']))\n if self.shuffle_lines:\n random.shuffle(lines)\n log.info('shuffled')\n tokens = 0\n for line in lines:\n if split_on_char:\n chars = list(line)\n else:\n chars = line.split()\n tokens += len(chars)\n if expand_vocab:\n for char in chars:\n self.dictionary.add_item(char)\n ids = torch.zeros(tokens, dtype=torch.long)\n if forward:\n token = 0\n for line in lines:\n if random_case_flip:\n line = self.random_casechange(line)\n if split_on_char:\n chars = list(line)\n else:\n chars = line.split()\n for char in chars:\n if (token >= tokens):\n break\n ids[token] = self.dictionary.get_idx_for_item(char)\n token += 1\n else:\n token = (tokens - 1)\n for line in lines:\n if random_case_flip:\n line = self.random_casechange(line)\n if split_on_char:\n chars = list(line)\n else:\n chars = line.split()\n for char in chars:\n if (token >= tokens):\n break\n ids[token] = self.dictionary.get_idx_for_item(char)\n token -= 1\n return ids\n\n @staticmethod\n def random_casechange(line):\n no = random.randint(0, 99)\n if (no is 0):\n line = line.lower()\n if (no is 1):\n line = line.upper()\n return line\n\n def tokenize(self, path):\n 'Tokenizes a text file.'\n assert path.exists()\n with open(path, 'r') as f:\n tokens = 0\n for line in f:\n words = (line.split() + ['<eos>'])\n tokens += len(words)\n for word in words:\n self.dictionary.add_word(word)\n with open(path, 'r') as f:\n ids = torch.zeros(tokens, dtype=torch.long, device=flair.device)\n token = 0\n for line in f:\n words = (line.split() + ['<eos>'])\n for word in words:\n ids[token] = self.dictionary.word2idx[word]\n token += 1\n return ids\n\n\nclass TextCorpus(object):\n\n def __init__(self, path, dictionary, forward=True, character_level=True, random_case_flip=True, shuffle_lines=True):\n self.dictionary = dictionary\n self.forward = forward\n self.split_on_char = character_level\n self.random_case_flip = random_case_flip\n self.shuffle_lines = shuffle_lines\n if (type(path) == str):\n path = Path(path)\n self.train = TextDataset((path / 'train'), dictionary, False, self.forward,\n self.split_on_char, self.random_case_flip, shuffle_lines=self.shuffle_lines)\n self.valid = TextDataset((path / 'valid.txt'), dictionary, False, self.forward,\n self.split_on_char, self.random_case_flip, shuffle_lines=False)[0]\n self.test = TextDataset((path / 'test.txt'), dictionary, False, self.forward,\n self.split_on_char, self.random_case_flip, shuffle_lines=False)[0]\n\n\nclass LanguageModelTrainer():\n\n def __init__(self, model, corpus, optimizer=SGD, test_mode=False, epoch=0, split=0, loss=10000, optimizer_state=None):\n self.model = model\n self.optimizer = optimizer\n self.corpus = corpus\n self.test_mode = test_mode\n self.loss_function = torch.nn.CrossEntropyLoss()\n self.log_interval = 100\n self.epoch = epoch\n self.split = split\n self.loss = loss\n self.optimizer_state = optimizer_state\n\n def train(self, base_path, sequence_length, learning_rate=20, mini_batch_size=100, anneal_factor=0.25, patience=10, clip=0.25, max_epochs=1000, checkpoint=False, grow_to_sequence_length=0, num_workers=2, use_amp=False, amp_opt_level='O1', **kwargs):\n if use_amp:\n if (sys.version_info < (3, 0)):\n raise RuntimeError(\n 'Apex currently only supports Python 3. Aborting.')\n if (amp is None):\n raise RuntimeError(\n 'Failed to import apex. Please install apex from https://www.github.com/nvidia/apex to enable mixed-precision training.')\n if (type(base_path) is str):\n base_path = Path(base_path)\n add_file_handler(log, (base_path / 'training.log'))\n number_of_splits = len(self.corpus.train)\n val_data = self._batchify(self.corpus.valid, mini_batch_size)\n base_path.mkdir(parents=True, exist_ok=True)\n loss_txt = (base_path / 'loss.txt')\n savefile = (base_path / 'best-lm.pt')\n try:\n epoch = self.epoch\n best_val_loss = self.loss\n optimizer = self.optimizer(\n self.model.parameters(), lr=learning_rate, **kwargs)\n if (self.optimizer_state is not None):\n optimizer.load_state_dict(self.optimizer_state)\n if isinstance(optimizer, (AdamW, SGDW)):\n scheduler = ReduceLRWDOnPlateau(\n optimizer, verbose=True, factor=anneal_factor, patience=patience)\n else:\n scheduler = ReduceLROnPlateau(\n optimizer, verbose=True, factor=anneal_factor, patience=patience)\n if use_amp:\n (self.model, optimizer) = amp.initialize(\n self.model, optimizer, opt_level=amp_opt_level)\n training_generator = DataLoader(\n self.corpus.train, shuffle=False, num_workers=num_workers)\n for epoch in range(self.epoch, max_epochs):\n epoch_start_time = time.time()\n if (epoch > 0):\n training_generator = DataLoader(\n self.corpus.train, shuffle=True, num_workers=num_workers)\n self.model.save_checkpoint(\n (base_path / ''.join(['epoch_', '{}'.format(epoch), '.pt'])), optimizer, epoch, 0, best_val_loss)\n for (curr_split, train_slice) in enumerate(training_generator, self.split):\n if (sequence_length < grow_to_sequence_length):\n sequence_length += 1\n log.info(\n ''.join(['Sequence length is ', '{}'.format(sequence_length)]))\n split_start_time = time.time()\n curr_split += 1\n train_data = self._batchify(\n train_slice.flatten(), mini_batch_size)\n log.info((('Split %d' % curr_split) +\n '\\t - ({:%H:%M:%S})'.format(datetime.datetime.now())))\n for group in optimizer.param_groups:\n learning_rate = group['lr']\n self.model.train()\n hidden = self.model.init_hidden(mini_batch_size)\n ntokens = len(self.corpus.dictionary)\n total_loss = 0\n start_time = time.time()\n for (batch, i) in enumerate(range(0, (train_data.size(0) - 1), sequence_length)):\n (data, targets) = self._get_batch(\n train_data, i, sequence_length)\n if ((not data.is_cuda) and cuda.is_available()):\n log.info(\n ('Batch %d is not on CUDA, training will be very slow' % batch))\n raise Exception('data isnt on cuda')\n self.model.zero_grad()\n optimizer.zero_grad()\n (output, rnn_output, hidden) = self.model.forward(\n data, hidden)\n loss = self.loss_function(\n output.view((- 1), ntokens), targets)\n if use_amp:\n with amp.scale_loss(loss, optimizer) as scaled_loss:\n scaled_loss.backward()\n else:\n loss.backward()\n torch.nn.utils.clip_grad_norm_(\n self.model.parameters(), clip)\n optimizer.step()\n total_loss += loss.data\n hidden = self._repackage_hidden(hidden)\n del loss, output, rnn_output\n if (((batch % self.log_interval) == 0) and (batch > 0)):\n cur_loss = (total_loss.item() / self.log_interval)\n elapsed = (time.time() - start_time)\n log.info('| split {:3d} /{:3d} | {:5d}/{:5d} batches | ms/batch {:5.2f} | loss {:5.2f} | ppl {:8.2f}'.format(\n curr_split, number_of_splits, batch, (len(train_data) // sequence_length), ((elapsed * 1000) / self.log_interval), cur_loss, math.exp(cur_loss)))\n total_loss = 0\n start_time = time.time()\n log.info(('%d seconds for train split %d' %\n ((time.time() - split_start_time), curr_split)))\n self.model.eval()\n val_loss = self.evaluate(\n val_data, mini_batch_size, sequence_length)\n scheduler.step(val_loss)\n log.info('best loss so far {:5.2f}'.format(best_val_loss))\n log.info(self.model.generate_text())\n if checkpoint:\n self.model.save_checkpoint(\n (base_path / 'checkpoint.pt'), optimizer, epoch, curr_split, best_val_loss)\n if (val_loss < best_val_loss):\n self.model.best_score = best_val_loss\n self.model.save(savefile)\n best_val_loss = val_loss\n log.info(('-' * 89))\n summary = '| end of split {:3d} /{:3d} | epoch {:3d} | time: {:5.2f}s | valid loss {:5.2f} | valid ppl {:8.2f} | learning rate {:3.4f}'.format(\n curr_split, number_of_splits, (epoch + 1), (time.time() - split_start_time), val_loss, math.exp(val_loss), learning_rate)\n with open(loss_txt, 'a') as myfile:\n myfile.write(('%s\\n' % summary))\n log.info(summary)\n log.info(('-' * 89))\n log.info(('Epoch time: %.2f' %\n (time.time() - epoch_start_time)))\n except KeyboardInterrupt:\n log.info(('-' * 89))\n log.info('Exiting from training early')\n test_data = self._batchify(self.corpus.test, mini_batch_size)\n test_loss = self.evaluate(test_data, mini_batch_size, sequence_length)\n summary = 'TEST: valid loss {:5.2f} | valid ppl {:8.2f}'.format(\n test_loss, math.exp(test_loss))\n with open(loss_txt, 'a') as myfile:\n myfile.write(('%s\\n' % summary))\n log.info(summary)\n log.info(('-' * 89))\n\n def evaluate(self, data_source, eval_batch_size, sequence_length):\n self.model.eval()\n with torch.no_grad():\n total_loss = 0\n ntokens = len(self.corpus.dictionary)\n hidden = self.model.init_hidden(eval_batch_size)\n for i in range(0, (data_source.size(0) - 1), sequence_length):\n (data, targets) = self._get_batch(\n data_source, i, sequence_length)\n (prediction, rnn_output, hidden) = self.model.forward(data, hidden)\n output_flat = prediction.view((- 1), ntokens)\n total_loss += (len(data) *\n self.loss_function(output_flat, targets).data)\n hidden = self._repackage_hidden(hidden)\n return (total_loss.item() / len(data_source))\n\n @staticmethod\n def _batchify(data, batch_size):\n nbatch = (data.size(0) // batch_size)\n data = data.narrow(0, 0, (nbatch * batch_size))\n data = data.view(batch_size, (- 1)).t().contiguous()\n return data\n\n @staticmethod\n def _get_batch(source, i, sequence_length):\n seq_len = min(sequence_length, ((len(source) - 1) - i))\n data = source[i:(i + seq_len)].clone().detach()\n target = source[(i + 1):((i + 1) + seq_len)\n ].view((- 1)).clone().detach()\n data = data.to(flair.device)\n target = target.to(flair.device)\n return (data, target)\n\n @staticmethod\n def _repackage_hidden(h):\n 'Wraps hidden states in new tensors, to detach them from their history.'\n return tuple((v.clone().detach() for v in h))\n\n @staticmethod\n def load_from_checkpoint(checkpoint_file, corpus, optimizer=SGD):\n checkpoint = LanguageModel.load_checkpoint(checkpoint_file)\n return LanguageModelTrainer(checkpoint['model'], corpus, optimizer, epoch=checkpoint['epoch'], split=checkpoint['split'], loss=checkpoint['loss'], optimizer_state=checkpoint['optimizer_state_dict'])\n"
] | [
[
"torch.utils.data.DataLoader",
"torch.cuda.is_available"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
mecanimatico/codigo_edp | [
"42080a4eb0f604873f9743ff0d0b8afde0735181"
] | [
"17abriledp.py"
] | [
"# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Fri Apr 17 09:57:12 2020\n\n@author: Heber\n\"\"\"\nimport numpy as np\nimport pandas as pd\nimport os\nimport matplotlib.pyplot as plt\n#%% valor exacto d ela derivada\nup = np.cos(1.0)\n\nh = 0.1\nup_aprox = (np.sin(1+h)-np.sin(1))/h\nerror = up - up_aprox\n\nprint (\"Valor aproximado: \",up_aprox)\nprint (\"Valor del error: \",error)\n#%%-----------------------------\n# muestra \n\nlist = [0.1, 0.01, 0.001, 0.0001, 0.00001]\n\naprox_values = []\nerrores_values = []\n\n\n# aproximacion a la segunda derivada \n\nerrores_values2 = []\naprox_values2 = []\nfor h in list:\n aux = (np.sin(1+h) - np.sin(1))/h\n aprox_values.append(aux)\n errores_values.append(up - aux)\n # print(h, up_aprox,error)\n # formula de segundo orden\n aux_2 = (np.sin(1+h)-np.sin(1-h))/(2*h)\n aprox_values2.append(aux_2)\n errores_values2.append(up - aux_2)\n\nplt.loglog(list,errores_values,'o-',list,errores_values2,'o-')\nplt.grid(True)\n#%%---------------------\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\n\nlist = [0.1, 0.01, 0.001, 0.0001]\nvalor_exacto = 6*np.exp(1.0)\nvalor_aprox = []\nvalor_error = []\nfor h in list:\n aux = (np.exp((1+h)**2)-2*np.exp(1.0) + np.exp((1-h)**2))/h**2\n valor_aprox.append(aux)\n aux2 = abs(valor_exacto - aux)\n valor_error.append(aux2) \nplt.grid(True) \nplt.loglog(list,valor_error,'o-')\n\n#list,valor_aprox, 'o-'\n\n\n"
] | [
[
"matplotlib.pyplot.loglog",
"numpy.cos",
"numpy.sin",
"matplotlib.pyplot.grid",
"numpy.exp"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
zfrenchee/pandas | [
"d28f9326de26882a9b4dc0bee9dec5c598747190",
"d28f9326de26882a9b4dc0bee9dec5c598747190",
"d28f9326de26882a9b4dc0bee9dec5c598747190"
] | [
"pandas/tests/indexes/test_category.py",
"pandas/tests/scalar/test_period.py",
"pandas/tests/generic/test_panel.py"
] | [
"# -*- coding: utf-8 -*-\n\nimport pytest\n\nimport pandas.util.testing as tm\nfrom pandas.core.indexes.api import Index, CategoricalIndex\nfrom pandas.core.dtypes.dtypes import CategoricalDtype\nfrom .common import Base\n\nfrom pandas.compat import range, PY3\n\nimport numpy as np\n\nfrom pandas import Categorical, IntervalIndex, compat\nfrom pandas.util.testing import assert_almost_equal\nimport pandas.core.config as cf\nimport pandas as pd\n\nif PY3:\n unicode = lambda x: x\n\n\nclass TestCategoricalIndex(Base):\n _holder = CategoricalIndex\n\n def setup_method(self, method):\n self.indices = dict(catIndex=tm.makeCategoricalIndex(100))\n self.setup_indices()\n\n def create_index(self, categories=None, ordered=False):\n if categories is None:\n categories = list('cab')\n return CategoricalIndex(\n list('aabbca'), categories=categories, ordered=ordered)\n\n def test_construction(self):\n\n ci = self.create_index(categories=list('abcd'))\n categories = ci.categories\n\n result = Index(ci)\n tm.assert_index_equal(result, ci, exact=True)\n assert not result.ordered\n\n result = Index(ci.values)\n tm.assert_index_equal(result, ci, exact=True)\n assert not result.ordered\n\n # empty\n result = CategoricalIndex(categories=categories)\n tm.assert_index_equal(result.categories, Index(categories))\n tm.assert_numpy_array_equal(result.codes, np.array([], dtype='int8'))\n assert not result.ordered\n\n # passing categories\n result = CategoricalIndex(list('aabbca'), categories=categories)\n tm.assert_index_equal(result.categories, Index(categories))\n tm.assert_numpy_array_equal(result.codes,\n np.array([0, 0, 1,\n 1, 2, 0], dtype='int8'))\n\n c = pd.Categorical(list('aabbca'))\n result = CategoricalIndex(c)\n tm.assert_index_equal(result.categories, Index(list('abc')))\n tm.assert_numpy_array_equal(result.codes,\n np.array([0, 0, 1,\n 1, 2, 0], dtype='int8'))\n assert not result.ordered\n\n result = CategoricalIndex(c, categories=categories)\n tm.assert_index_equal(result.categories, Index(categories))\n tm.assert_numpy_array_equal(result.codes,\n np.array([0, 0, 1,\n 1, 2, 0], dtype='int8'))\n assert not result.ordered\n\n ci = CategoricalIndex(c, categories=list('abcd'))\n result = CategoricalIndex(ci)\n tm.assert_index_equal(result.categories, Index(categories))\n tm.assert_numpy_array_equal(result.codes,\n np.array([0, 0, 1,\n 1, 2, 0], dtype='int8'))\n assert not result.ordered\n\n result = CategoricalIndex(ci, categories=list('ab'))\n tm.assert_index_equal(result.categories, Index(list('ab')))\n tm.assert_numpy_array_equal(result.codes,\n np.array([0, 0, 1,\n 1, -1, 0], dtype='int8'))\n assert not result.ordered\n\n result = CategoricalIndex(ci, categories=list('ab'), ordered=True)\n tm.assert_index_equal(result.categories, Index(list('ab')))\n tm.assert_numpy_array_equal(result.codes,\n np.array([0, 0, 1,\n 1, -1, 0], dtype='int8'))\n assert result.ordered\n\n result = pd.CategoricalIndex(ci, categories=list('ab'), ordered=True)\n expected = pd.CategoricalIndex(ci, categories=list('ab'), ordered=True,\n dtype='category')\n tm.assert_index_equal(result, expected, exact=True)\n\n # turn me to an Index\n result = Index(np.array(ci))\n assert isinstance(result, Index)\n assert not isinstance(result, CategoricalIndex)\n\n def test_construction_with_dtype(self):\n\n # specify dtype\n ci = self.create_index(categories=list('abc'))\n\n result = Index(np.array(ci), dtype='category')\n tm.assert_index_equal(result, ci, exact=True)\n\n result = Index(np.array(ci).tolist(), dtype='category')\n tm.assert_index_equal(result, ci, exact=True)\n\n # these are generally only equal when the categories are reordered\n ci = self.create_index()\n\n result = Index(\n np.array(ci), dtype='category').reorder_categories(ci.categories)\n tm.assert_index_equal(result, ci, exact=True)\n\n # make sure indexes are handled\n expected = CategoricalIndex([0, 1, 2], categories=[0, 1, 2],\n ordered=True)\n idx = Index(range(3))\n result = CategoricalIndex(idx, categories=idx, ordered=True)\n tm.assert_index_equal(result, expected, exact=True)\n\n def test_construction_with_categorical_dtype(self):\n # construction with CategoricalDtype\n # GH18109\n data, cats, ordered = 'a a b b'.split(), 'c b a'.split(), True\n dtype = CategoricalDtype(categories=cats, ordered=ordered)\n\n result = pd.CategoricalIndex(data, dtype=dtype)\n expected = pd.CategoricalIndex(data, categories=cats,\n ordered=ordered)\n tm.assert_index_equal(result, expected, exact=True)\n\n # error to combine categories or ordered and dtype keywords args\n with pytest.raises(ValueError, match=\"Cannot specify both `dtype` and \"\n \"`categories` or `ordered`.\"):\n pd.CategoricalIndex(data, categories=cats, dtype=dtype)\n with pytest.raises(ValueError, match=\"Cannot specify both `dtype` and \"\n \"`categories` or `ordered`.\"):\n pd.CategoricalIndex(data, ordered=ordered, dtype=dtype)\n\n def test_create_categorical(self):\n # https://github.com/pandas-dev/pandas/pull/17513\n # The public CI constructor doesn't hit this code path with\n # instances of CategoricalIndex, but we still want to test the code\n ci = CategoricalIndex(['a', 'b', 'c'])\n # First ci is self, second ci is data.\n result = CategoricalIndex._create_categorical(ci, ci)\n expected = Categorical(['a', 'b', 'c'])\n tm.assert_categorical_equal(result, expected)\n\n def test_disallow_set_ops(self):\n\n # GH 10039\n # set ops (+/-) raise TypeError\n idx = pd.Index(pd.Categorical(['a', 'b']))\n\n pytest.raises(TypeError, lambda: idx - idx)\n pytest.raises(TypeError, lambda: idx + idx)\n pytest.raises(TypeError, lambda: idx - ['a', 'b'])\n pytest.raises(TypeError, lambda: idx + ['a', 'b'])\n pytest.raises(TypeError, lambda: ['a', 'b'] - idx)\n pytest.raises(TypeError, lambda: ['a', 'b'] + idx)\n\n def test_method_delegation(self):\n\n ci = CategoricalIndex(list('aabbca'), categories=list('cabdef'))\n result = ci.set_categories(list('cab'))\n tm.assert_index_equal(result, CategoricalIndex(\n list('aabbca'), categories=list('cab')))\n\n ci = CategoricalIndex(list('aabbca'), categories=list('cab'))\n result = ci.rename_categories(list('efg'))\n tm.assert_index_equal(result, CategoricalIndex(\n list('ffggef'), categories=list('efg')))\n\n # GH18862 (let rename_categories take callables)\n result = ci.rename_categories(lambda x: x.upper())\n tm.assert_index_equal(result, CategoricalIndex(\n list('AABBCA'), categories=list('CAB')))\n\n ci = CategoricalIndex(list('aabbca'), categories=list('cab'))\n result = ci.add_categories(['d'])\n tm.assert_index_equal(result, CategoricalIndex(\n list('aabbca'), categories=list('cabd')))\n\n ci = CategoricalIndex(list('aabbca'), categories=list('cab'))\n result = ci.remove_categories(['c'])\n tm.assert_index_equal(result, CategoricalIndex(\n list('aabb') + [np.nan] + ['a'], categories=list('ab')))\n\n ci = CategoricalIndex(list('aabbca'), categories=list('cabdef'))\n result = ci.as_unordered()\n tm.assert_index_equal(result, ci)\n\n ci = CategoricalIndex(list('aabbca'), categories=list('cabdef'))\n result = ci.as_ordered()\n tm.assert_index_equal(result, CategoricalIndex(\n list('aabbca'), categories=list('cabdef'), ordered=True))\n\n # invalid\n pytest.raises(ValueError, lambda: ci.set_categories(\n list('cab'), inplace=True))\n\n def test_contains(self):\n\n ci = self.create_index(categories=list('cabdef'))\n\n assert 'a' in ci\n assert 'z' not in ci\n assert 'e' not in ci\n assert np.nan not in ci\n\n # assert codes NOT in index\n assert 0 not in ci\n assert 1 not in ci\n\n ci = CategoricalIndex(\n list('aabbca') + [np.nan], categories=list('cabdef'))\n assert np.nan in ci\n\n def test_min_max(self):\n\n ci = self.create_index(ordered=False)\n pytest.raises(TypeError, lambda: ci.min())\n pytest.raises(TypeError, lambda: ci.max())\n\n ci = self.create_index(ordered=True)\n\n assert ci.min() == 'c'\n assert ci.max() == 'b'\n\n def test_map(self):\n ci = pd.CategoricalIndex(list('ABABC'), categories=list('CBA'),\n ordered=True)\n result = ci.map(lambda x: x.lower())\n exp = pd.CategoricalIndex(list('ababc'), categories=list('cba'),\n ordered=True)\n tm.assert_index_equal(result, exp)\n\n ci = pd.CategoricalIndex(list('ABABC'), categories=list('BAC'),\n ordered=False, name='XXX')\n result = ci.map(lambda x: x.lower())\n exp = pd.CategoricalIndex(list('ababc'), categories=list('bac'),\n ordered=False, name='XXX')\n tm.assert_index_equal(result, exp)\n\n # GH 12766: Return an index not an array\n tm.assert_index_equal(ci.map(lambda x: 1),\n Index(np.array([1] * 5, dtype=np.int64),\n name='XXX'))\n\n # change categories dtype\n ci = pd.CategoricalIndex(list('ABABC'), categories=list('BAC'),\n ordered=False)\n\n def f(x):\n return {'A': 10, 'B': 20, 'C': 30}.get(x)\n\n result = ci.map(f)\n exp = pd.CategoricalIndex([10, 20, 10, 20, 30],\n categories=[20, 10, 30],\n ordered=False)\n tm.assert_index_equal(result, exp)\n\n result = ci.map(pd.Series([10, 20, 30], index=['A', 'B', 'C']))\n tm.assert_index_equal(result, exp)\n\n result = ci.map({'A': 10, 'B': 20, 'C': 30})\n tm.assert_index_equal(result, exp)\n\n def test_map_with_categorical_series(self):\n # GH 12756\n a = pd.Index([1, 2, 3, 4])\n b = pd.Series([\"even\", \"odd\", \"even\", \"odd\"],\n dtype=\"category\")\n c = pd.Series([\"even\", \"odd\", \"even\", \"odd\"])\n\n exp = CategoricalIndex([\"odd\", \"even\", \"odd\", np.nan])\n tm.assert_index_equal(a.map(b), exp)\n exp = pd.Index([\"odd\", \"even\", \"odd\", np.nan])\n tm.assert_index_equal(a.map(c), exp)\n\n @pytest.mark.parametrize('klass', [list, tuple, np.array, pd.Series])\n def test_where(self, klass):\n i = self.create_index()\n cond = [True] * len(i)\n expected = i\n result = i.where(klass(cond))\n tm.assert_index_equal(result, expected)\n\n cond = [False] + [True] * (len(i) - 1)\n expected = CategoricalIndex([np.nan] + i[1:].tolist(),\n categories=i.categories)\n result = i.where(klass(cond))\n tm.assert_index_equal(result, expected)\n\n def test_append(self):\n\n ci = self.create_index()\n categories = ci.categories\n\n # append cats with the same categories\n result = ci[:3].append(ci[3:])\n tm.assert_index_equal(result, ci, exact=True)\n\n foos = [ci[:1], ci[1:3], ci[3:]]\n result = foos[0].append(foos[1:])\n tm.assert_index_equal(result, ci, exact=True)\n\n # empty\n result = ci.append([])\n tm.assert_index_equal(result, ci, exact=True)\n\n # appending with different categories or reoreded is not ok\n pytest.raises(\n TypeError,\n lambda: ci.append(ci.values.set_categories(list('abcd'))))\n pytest.raises(\n TypeError,\n lambda: ci.append(ci.values.reorder_categories(list('abc'))))\n\n # with objects\n result = ci.append(Index(['c', 'a']))\n expected = CategoricalIndex(list('aabbcaca'), categories=categories)\n tm.assert_index_equal(result, expected, exact=True)\n\n # invalid objects\n pytest.raises(TypeError, lambda: ci.append(Index(['a', 'd'])))\n\n # GH14298 - if base object is not categorical -> coerce to object\n result = Index(['c', 'a']).append(ci)\n expected = Index(list('caaabbca'))\n tm.assert_index_equal(result, expected, exact=True)\n\n def test_insert(self):\n\n ci = self.create_index()\n categories = ci.categories\n\n # test 0th element\n result = ci.insert(0, 'a')\n expected = CategoricalIndex(list('aaabbca'), categories=categories)\n tm.assert_index_equal(result, expected, exact=True)\n\n # test Nth element that follows Python list behavior\n result = ci.insert(-1, 'a')\n expected = CategoricalIndex(list('aabbcaa'), categories=categories)\n tm.assert_index_equal(result, expected, exact=True)\n\n # test empty\n result = CategoricalIndex(categories=categories).insert(0, 'a')\n expected = CategoricalIndex(['a'], categories=categories)\n tm.assert_index_equal(result, expected, exact=True)\n\n # invalid\n pytest.raises(TypeError, lambda: ci.insert(0, 'd'))\n\n # GH 18295 (test missing)\n expected = CategoricalIndex(['a', np.nan, 'a', 'b', 'c', 'b'])\n for na in (np.nan, pd.NaT, None):\n result = CategoricalIndex(list('aabcb')).insert(1, na)\n tm.assert_index_equal(result, expected)\n\n def test_delete(self):\n\n ci = self.create_index()\n categories = ci.categories\n\n result = ci.delete(0)\n expected = CategoricalIndex(list('abbca'), categories=categories)\n tm.assert_index_equal(result, expected, exact=True)\n\n result = ci.delete(-1)\n expected = CategoricalIndex(list('aabbc'), categories=categories)\n tm.assert_index_equal(result, expected, exact=True)\n\n with pytest.raises((IndexError, ValueError)):\n # Either depending on NumPy version\n ci.delete(10)\n\n def test_astype(self):\n\n ci = self.create_index()\n result = ci.astype(object)\n tm.assert_index_equal(result, Index(np.array(ci)))\n\n # this IS equal, but not the same class\n assert result.equals(ci)\n assert isinstance(result, Index)\n assert not isinstance(result, CategoricalIndex)\n\n # interval\n ii = IntervalIndex.from_arrays(left=[-0.001, 2.0],\n right=[2, 4],\n closed='right')\n\n ci = CategoricalIndex(Categorical.from_codes(\n [0, 1, -1], categories=ii, ordered=True))\n\n result = ci.astype('interval')\n expected = ii.take([0, 1, -1])\n tm.assert_index_equal(result, expected)\n\n result = IntervalIndex.from_intervals(result.values)\n tm.assert_index_equal(result, expected)\n\n @pytest.mark.parametrize('name', [None, 'foo'])\n @pytest.mark.parametrize('dtype_ordered', [True, False])\n @pytest.mark.parametrize('index_ordered', [True, False])\n def test_astype_category(self, name, dtype_ordered, index_ordered):\n # GH 18630\n index = self.create_index(ordered=index_ordered)\n if name:\n index = index.rename(name)\n\n # standard categories\n dtype = CategoricalDtype(ordered=dtype_ordered)\n result = index.astype(dtype)\n expected = CategoricalIndex(index.tolist(),\n name=name,\n categories=index.categories,\n ordered=dtype_ordered)\n tm.assert_index_equal(result, expected)\n\n # non-standard categories\n dtype = CategoricalDtype(index.unique().tolist()[:-1], dtype_ordered)\n result = index.astype(dtype)\n expected = CategoricalIndex(index.tolist(), name=name, dtype=dtype)\n tm.assert_index_equal(result, expected)\n\n if dtype_ordered is False:\n # dtype='category' can't specify ordered, so only test once\n result = index.astype('category')\n expected = index\n tm.assert_index_equal(result, expected)\n\n def test_reindex_base(self):\n # Determined by cat ordering.\n idx = CategoricalIndex(list(\"cab\"), categories=list(\"cab\"))\n expected = np.arange(len(idx), dtype=np.intp)\n\n actual = idx.get_indexer(idx)\n tm.assert_numpy_array_equal(expected, actual)\n\n with tm.assert_raises_regex(ValueError, \"Invalid fill method\"):\n idx.get_indexer(idx, method=\"invalid\")\n\n def test_reindexing(self):\n np.random.seed(123456789)\n\n ci = self.create_index()\n oidx = Index(np.array(ci))\n\n for n in [1, 2, 5, len(ci)]:\n finder = oidx[np.random.randint(0, len(ci), size=n)]\n expected = oidx.get_indexer_non_unique(finder)[0]\n\n actual = ci.get_indexer(finder)\n tm.assert_numpy_array_equal(expected, actual)\n\n # see gh-17323\n #\n # Even when indexer is equal to the\n # members in the index, we should\n # respect duplicates instead of taking\n # the fast-track path.\n for finder in [list(\"aabbca\"), list(\"aababca\")]:\n expected = oidx.get_indexer_non_unique(finder)[0]\n\n actual = ci.get_indexer(finder)\n tm.assert_numpy_array_equal(expected, actual)\n\n def test_reindex_dtype(self):\n c = CategoricalIndex(['a', 'b', 'c', 'a'])\n res, indexer = c.reindex(['a', 'c'])\n tm.assert_index_equal(res, Index(['a', 'a', 'c']), exact=True)\n tm.assert_numpy_array_equal(indexer,\n np.array([0, 3, 2], dtype=np.intp))\n\n c = CategoricalIndex(['a', 'b', 'c', 'a'])\n res, indexer = c.reindex(Categorical(['a', 'c']))\n\n exp = CategoricalIndex(['a', 'a', 'c'], categories=['a', 'c'])\n tm.assert_index_equal(res, exp, exact=True)\n tm.assert_numpy_array_equal(indexer,\n np.array([0, 3, 2], dtype=np.intp))\n\n c = CategoricalIndex(['a', 'b', 'c', 'a'],\n categories=['a', 'b', 'c', 'd'])\n res, indexer = c.reindex(['a', 'c'])\n exp = Index(['a', 'a', 'c'], dtype='object')\n tm.assert_index_equal(res, exp, exact=True)\n tm.assert_numpy_array_equal(indexer,\n np.array([0, 3, 2], dtype=np.intp))\n\n c = CategoricalIndex(['a', 'b', 'c', 'a'],\n categories=['a', 'b', 'c', 'd'])\n res, indexer = c.reindex(Categorical(['a', 'c']))\n exp = CategoricalIndex(['a', 'a', 'c'], categories=['a', 'c'])\n tm.assert_index_equal(res, exp, exact=True)\n tm.assert_numpy_array_equal(indexer,\n np.array([0, 3, 2], dtype=np.intp))\n\n def test_reindex_empty_index(self):\n # See GH16770\n c = CategoricalIndex([])\n res, indexer = c.reindex(['a', 'b'])\n tm.assert_index_equal(res, Index(['a', 'b']), exact=True)\n tm.assert_numpy_array_equal(indexer,\n np.array([-1, -1], dtype=np.intp))\n\n def test_is_monotonic(self):\n c = CategoricalIndex([1, 2, 3])\n assert c.is_monotonic_increasing\n assert not c.is_monotonic_decreasing\n\n c = CategoricalIndex([1, 2, 3], ordered=True)\n assert c.is_monotonic_increasing\n assert not c.is_monotonic_decreasing\n\n c = CategoricalIndex([1, 2, 3], categories=[3, 2, 1])\n assert not c.is_monotonic_increasing\n assert c.is_monotonic_decreasing\n\n c = CategoricalIndex([1, 3, 2], categories=[3, 2, 1])\n assert not c.is_monotonic_increasing\n assert not c.is_monotonic_decreasing\n\n c = CategoricalIndex([1, 2, 3], categories=[3, 2, 1], ordered=True)\n assert not c.is_monotonic_increasing\n assert c.is_monotonic_decreasing\n\n # non lexsorted categories\n categories = [9, 0, 1, 2, 3]\n\n c = CategoricalIndex([9, 0], categories=categories)\n assert c.is_monotonic_increasing\n assert not c.is_monotonic_decreasing\n\n c = CategoricalIndex([0, 1], categories=categories)\n assert c.is_monotonic_increasing\n assert not c.is_monotonic_decreasing\n\n def test_duplicates(self):\n\n idx = CategoricalIndex([0, 0, 0], name='foo')\n assert not idx.is_unique\n assert idx.has_duplicates\n\n expected = CategoricalIndex([0], name='foo')\n tm.assert_index_equal(idx.drop_duplicates(), expected)\n tm.assert_index_equal(idx.unique(), expected)\n\n def test_get_indexer(self):\n\n idx1 = CategoricalIndex(list('aabcde'), categories=list('edabc'))\n idx2 = CategoricalIndex(list('abf'))\n\n for indexer in [idx2, list('abf'), Index(list('abf'))]:\n r1 = idx1.get_indexer(idx2)\n assert_almost_equal(r1, np.array([0, 1, 2, -1], dtype=np.intp))\n\n pytest.raises(NotImplementedError,\n lambda: idx2.get_indexer(idx1, method='pad'))\n pytest.raises(NotImplementedError,\n lambda: idx2.get_indexer(idx1, method='backfill'))\n pytest.raises(NotImplementedError,\n lambda: idx2.get_indexer(idx1, method='nearest'))\n\n def test_get_loc(self):\n # GH 12531\n cidx1 = CategoricalIndex(list('abcde'), categories=list('edabc'))\n idx1 = Index(list('abcde'))\n assert cidx1.get_loc('a') == idx1.get_loc('a')\n assert cidx1.get_loc('e') == idx1.get_loc('e')\n\n for i in [cidx1, idx1]:\n with pytest.raises(KeyError):\n i.get_loc('NOT-EXIST')\n\n # non-unique\n cidx2 = CategoricalIndex(list('aacded'), categories=list('edabc'))\n idx2 = Index(list('aacded'))\n\n # results in bool array\n res = cidx2.get_loc('d')\n tm.assert_numpy_array_equal(res, idx2.get_loc('d'))\n tm.assert_numpy_array_equal(res, np.array([False, False, False,\n True, False, True]))\n # unique element results in scalar\n res = cidx2.get_loc('e')\n assert res == idx2.get_loc('e')\n assert res == 4\n\n for i in [cidx2, idx2]:\n with pytest.raises(KeyError):\n i.get_loc('NOT-EXIST')\n\n # non-unique, slicable\n cidx3 = CategoricalIndex(list('aabbb'), categories=list('abc'))\n idx3 = Index(list('aabbb'))\n\n # results in slice\n res = cidx3.get_loc('a')\n assert res == idx3.get_loc('a')\n assert res == slice(0, 2, None)\n\n res = cidx3.get_loc('b')\n assert res == idx3.get_loc('b')\n assert res == slice(2, 5, None)\n\n for i in [cidx3, idx3]:\n with pytest.raises(KeyError):\n i.get_loc('c')\n\n def test_repr_roundtrip(self):\n\n ci = CategoricalIndex(['a', 'b'], categories=['a', 'b'], ordered=True)\n str(ci)\n tm.assert_index_equal(eval(repr(ci)), ci, exact=True)\n\n # formatting\n if PY3:\n str(ci)\n else:\n compat.text_type(ci)\n\n # long format\n # this is not reprable\n ci = CategoricalIndex(np.random.randint(0, 5, size=100))\n if PY3:\n str(ci)\n else:\n compat.text_type(ci)\n\n def test_isin(self):\n\n ci = CategoricalIndex(\n list('aabca') + [np.nan], categories=['c', 'a', 'b'])\n tm.assert_numpy_array_equal(\n ci.isin(['c']),\n np.array([False, False, False, True, False, False]))\n tm.assert_numpy_array_equal(\n ci.isin(['c', 'a', 'b']), np.array([True] * 5 + [False]))\n tm.assert_numpy_array_equal(\n ci.isin(['c', 'a', 'b', np.nan]), np.array([True] * 6))\n\n # mismatched categorical -> coerced to ndarray so doesn't matter\n result = ci.isin(ci.set_categories(list('abcdefghi')))\n expected = np.array([True] * 6)\n tm.assert_numpy_array_equal(result, expected)\n\n result = ci.isin(ci.set_categories(list('defghi')))\n expected = np.array([False] * 5 + [True])\n tm.assert_numpy_array_equal(result, expected)\n\n def test_identical(self):\n\n ci1 = CategoricalIndex(['a', 'b'], categories=['a', 'b'], ordered=True)\n ci2 = CategoricalIndex(['a', 'b'], categories=['a', 'b', 'c'],\n ordered=True)\n assert ci1.identical(ci1)\n assert ci1.identical(ci1.copy())\n assert not ci1.identical(ci2)\n\n def test_ensure_copied_data(self):\n # gh-12309: Check the \"copy\" argument of each\n # Index.__new__ is honored.\n #\n # Must be tested separately from other indexes because\n # self.value is not an ndarray.\n _base = lambda ar: ar if ar.base is None else ar.base\n\n for index in self.indices.values():\n result = CategoricalIndex(index.values, copy=True)\n tm.assert_index_equal(index, result)\n assert _base(index.values) is not _base(result.values)\n\n result = CategoricalIndex(index.values, copy=False)\n assert _base(index.values) is _base(result.values)\n\n def test_equals_categorical(self):\n ci1 = CategoricalIndex(['a', 'b'], categories=['a', 'b'], ordered=True)\n ci2 = CategoricalIndex(['a', 'b'], categories=['a', 'b', 'c'],\n ordered=True)\n\n assert ci1.equals(ci1)\n assert not ci1.equals(ci2)\n assert ci1.equals(ci1.astype(object))\n assert ci1.astype(object).equals(ci1)\n\n assert (ci1 == ci1).all()\n assert not (ci1 != ci1).all()\n assert not (ci1 > ci1).all()\n assert not (ci1 < ci1).all()\n assert (ci1 <= ci1).all()\n assert (ci1 >= ci1).all()\n\n assert not (ci1 == 1).all()\n assert (ci1 == Index(['a', 'b'])).all()\n assert (ci1 == ci1.values).all()\n\n # invalid comparisons\n with tm.assert_raises_regex(ValueError, \"Lengths must match\"):\n ci1 == Index(['a', 'b', 'c'])\n pytest.raises(TypeError, lambda: ci1 == ci2)\n pytest.raises(\n TypeError, lambda: ci1 == Categorical(ci1.values, ordered=False))\n pytest.raises(\n TypeError,\n lambda: ci1 == Categorical(ci1.values, categories=list('abc')))\n\n # tests\n # make sure that we are testing for category inclusion properly\n ci = CategoricalIndex(list('aabca'), categories=['c', 'a', 'b'])\n assert not ci.equals(list('aabca'))\n # Same categories, but different order\n # Unordered\n assert ci.equals(CategoricalIndex(list('aabca')))\n # Ordered\n assert not ci.equals(CategoricalIndex(list('aabca'), ordered=True))\n assert ci.equals(ci.copy())\n\n ci = CategoricalIndex(list('aabca') + [np.nan],\n categories=['c', 'a', 'b'])\n assert not ci.equals(list('aabca'))\n assert not ci.equals(CategoricalIndex(list('aabca')))\n assert ci.equals(ci.copy())\n\n ci = CategoricalIndex(list('aabca') + [np.nan],\n categories=['c', 'a', 'b'])\n assert not ci.equals(list('aabca') + [np.nan])\n assert ci.equals(CategoricalIndex(list('aabca') + [np.nan]))\n assert not ci.equals(CategoricalIndex(list('aabca') + [np.nan],\n ordered=True))\n assert ci.equals(ci.copy())\n\n def test_string_categorical_index_repr(self):\n # short\n idx = pd.CategoricalIndex(['a', 'bb', 'ccc'])\n if PY3:\n expected = u\"\"\"CategoricalIndex(['a', 'bb', 'ccc'], categories=['a', 'bb', 'ccc'], ordered=False, dtype='category')\"\"\" # noqa\n assert repr(idx) == expected\n else:\n expected = u\"\"\"CategoricalIndex([u'a', u'bb', u'ccc'], categories=[u'a', u'bb', u'ccc'], ordered=False, dtype='category')\"\"\" # noqa\n assert unicode(idx) == expected\n\n # multiple lines\n idx = pd.CategoricalIndex(['a', 'bb', 'ccc'] * 10)\n if PY3:\n expected = u\"\"\"CategoricalIndex(['a', 'bb', 'ccc', 'a', 'bb', 'ccc', 'a', 'bb', 'ccc', 'a',\n 'bb', 'ccc', 'a', 'bb', 'ccc', 'a', 'bb', 'ccc', 'a', 'bb',\n 'ccc', 'a', 'bb', 'ccc', 'a', 'bb', 'ccc', 'a', 'bb', 'ccc'],\n categories=['a', 'bb', 'ccc'], ordered=False, dtype='category')\"\"\" # noqa\n\n assert repr(idx) == expected\n else:\n expected = u\"\"\"CategoricalIndex([u'a', u'bb', u'ccc', u'a', u'bb', u'ccc', u'a', u'bb',\n u'ccc', u'a', u'bb', u'ccc', u'a', u'bb', u'ccc', u'a',\n u'bb', u'ccc', u'a', u'bb', u'ccc', u'a', u'bb', u'ccc',\n u'a', u'bb', u'ccc', u'a', u'bb', u'ccc'],\n categories=[u'a', u'bb', u'ccc'], ordered=False, dtype='category')\"\"\" # noqa\n\n assert unicode(idx) == expected\n\n # truncated\n idx = pd.CategoricalIndex(['a', 'bb', 'ccc'] * 100)\n if PY3:\n expected = u\"\"\"CategoricalIndex(['a', 'bb', 'ccc', 'a', 'bb', 'ccc', 'a', 'bb', 'ccc', 'a',\n ...\n 'ccc', 'a', 'bb', 'ccc', 'a', 'bb', 'ccc', 'a', 'bb', 'ccc'],\n categories=['a', 'bb', 'ccc'], ordered=False, dtype='category', length=300)\"\"\" # noqa\n\n assert repr(idx) == expected\n else:\n expected = u\"\"\"CategoricalIndex([u'a', u'bb', u'ccc', u'a', u'bb', u'ccc', u'a', u'bb',\n u'ccc', u'a',\n ...\n u'ccc', u'a', u'bb', u'ccc', u'a', u'bb', u'ccc', u'a',\n u'bb', u'ccc'],\n categories=[u'a', u'bb', u'ccc'], ordered=False, dtype='category', length=300)\"\"\" # noqa\n\n assert unicode(idx) == expected\n\n # larger categories\n idx = pd.CategoricalIndex(list('abcdefghijklmmo'))\n if PY3:\n expected = u\"\"\"CategoricalIndex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',\n 'm', 'm', 'o'],\n categories=['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', ...], ordered=False, dtype='category')\"\"\" # noqa\n\n assert repr(idx) == expected\n else:\n expected = u\"\"\"CategoricalIndex([u'a', u'b', u'c', u'd', u'e', u'f', u'g', u'h', u'i', u'j',\n u'k', u'l', u'm', u'm', u'o'],\n categories=[u'a', u'b', u'c', u'd', u'e', u'f', u'g', u'h', ...], ordered=False, dtype='category')\"\"\" # noqa\n\n assert unicode(idx) == expected\n\n # short\n idx = pd.CategoricalIndex([u'あ', u'いい', u'ううう'])\n if PY3:\n expected = u\"\"\"CategoricalIndex(['あ', 'いい', 'ううう'], categories=['あ', 'いい', 'ううう'], ordered=False, dtype='category')\"\"\" # noqa\n assert repr(idx) == expected\n else:\n expected = u\"\"\"CategoricalIndex([u'あ', u'いい', u'ううう'], categories=[u'あ', u'いい', u'ううう'], ordered=False, dtype='category')\"\"\" # noqa\n assert unicode(idx) == expected\n\n # multiple lines\n idx = pd.CategoricalIndex([u'あ', u'いい', u'ううう'] * 10)\n if PY3:\n expected = u\"\"\"CategoricalIndex(['あ', 'いい', 'ううう', 'あ', 'いい', 'ううう', 'あ', 'いい', 'ううう', 'あ',\n 'いい', 'ううう', 'あ', 'いい', 'ううう', 'あ', 'いい', 'ううう', 'あ', 'いい',\n 'ううう', 'あ', 'いい', 'ううう', 'あ', 'いい', 'ううう', 'あ', 'いい', 'ううう'],\n categories=['あ', 'いい', 'ううう'], ordered=False, dtype='category')\"\"\" # noqa\n\n assert repr(idx) == expected\n else:\n expected = u\"\"\"CategoricalIndex([u'あ', u'いい', u'ううう', u'あ', u'いい', u'ううう', u'あ', u'いい',\n u'ううう', u'あ', u'いい', u'ううう', u'あ', u'いい', u'ううう', u'あ',\n u'いい', u'ううう', u'あ', u'いい', u'ううう', u'あ', u'いい', u'ううう',\n u'あ', u'いい', u'ううう', u'あ', u'いい', u'ううう'],\n categories=[u'あ', u'いい', u'ううう'], ordered=False, dtype='category')\"\"\" # noqa\n\n assert unicode(idx) == expected\n\n # truncated\n idx = pd.CategoricalIndex([u'あ', u'いい', u'ううう'] * 100)\n if PY3:\n expected = u\"\"\"CategoricalIndex(['あ', 'いい', 'ううう', 'あ', 'いい', 'ううう', 'あ', 'いい', 'ううう', 'あ',\n ...\n 'ううう', 'あ', 'いい', 'ううう', 'あ', 'いい', 'ううう', 'あ', 'いい', 'ううう'],\n categories=['あ', 'いい', 'ううう'], ordered=False, dtype='category', length=300)\"\"\" # noqa\n\n assert repr(idx) == expected\n else:\n expected = u\"\"\"CategoricalIndex([u'あ', u'いい', u'ううう', u'あ', u'いい', u'ううう', u'あ', u'いい',\n u'ううう', u'あ',\n ...\n u'ううう', u'あ', u'いい', u'ううう', u'あ', u'いい', u'ううう', u'あ',\n u'いい', u'ううう'],\n categories=[u'あ', u'いい', u'ううう'], ordered=False, dtype='category', length=300)\"\"\" # noqa\n\n assert unicode(idx) == expected\n\n # larger categories\n idx = pd.CategoricalIndex(list(u'あいうえおかきくけこさしすせそ'))\n if PY3:\n expected = u\"\"\"CategoricalIndex(['あ', 'い', 'う', 'え', 'お', 'か', 'き', 'く', 'け', 'こ', 'さ', 'し',\n 'す', 'せ', 'そ'],\n categories=['あ', 'い', 'う', 'え', 'お', 'か', 'き', 'く', ...], ordered=False, dtype='category')\"\"\" # noqa\n\n assert repr(idx) == expected\n else:\n expected = u\"\"\"CategoricalIndex([u'あ', u'い', u'う', u'え', u'お', u'か', u'き', u'く', u'け', u'こ',\n u'さ', u'し', u'す', u'せ', u'そ'],\n categories=[u'あ', u'い', u'う', u'え', u'お', u'か', u'き', u'く', ...], ordered=False, dtype='category')\"\"\" # noqa\n\n assert unicode(idx) == expected\n\n # Emable Unicode option -----------------------------------------\n with cf.option_context('display.unicode.east_asian_width', True):\n\n # short\n idx = pd.CategoricalIndex([u'あ', u'いい', u'ううう'])\n if PY3:\n expected = u\"\"\"CategoricalIndex(['あ', 'いい', 'ううう'], categories=['あ', 'いい', 'ううう'], ordered=False, dtype='category')\"\"\" # noqa\n assert repr(idx) == expected\n else:\n expected = u\"\"\"CategoricalIndex([u'あ', u'いい', u'ううう'], categories=[u'あ', u'いい', u'ううう'], ordered=False, dtype='category')\"\"\" # noqa\n assert unicode(idx) == expected\n\n # multiple lines\n idx = pd.CategoricalIndex([u'あ', u'いい', u'ううう'] * 10)\n if PY3:\n expected = u\"\"\"CategoricalIndex(['あ', 'いい', 'ううう', 'あ', 'いい', 'ううう', 'あ', 'いい',\n 'ううう', 'あ', 'いい', 'ううう', 'あ', 'いい', 'ううう',\n 'あ', 'いい', 'ううう', 'あ', 'いい', 'ううう', 'あ', 'いい',\n 'ううう', 'あ', 'いい', 'ううう', 'あ', 'いい', 'ううう'],\n categories=['あ', 'いい', 'ううう'], ordered=False, dtype='category')\"\"\" # noqa\n\n assert repr(idx) == expected\n else:\n expected = u\"\"\"CategoricalIndex([u'あ', u'いい', u'ううう', u'あ', u'いい', u'ううう', u'あ',\n u'いい', u'ううう', u'あ', u'いい', u'ううう', u'あ',\n u'いい', u'ううう', u'あ', u'いい', u'ううう', u'あ',\n u'いい', u'ううう', u'あ', u'いい', u'ううう', u'あ',\n u'いい', u'ううう', u'あ', u'いい', u'ううう'],\n categories=[u'あ', u'いい', u'ううう'], ordered=False, dtype='category')\"\"\" # noqa\n\n assert unicode(idx) == expected\n\n # truncated\n idx = pd.CategoricalIndex([u'あ', u'いい', u'ううう'] * 100)\n if PY3:\n expected = u\"\"\"CategoricalIndex(['あ', 'いい', 'ううう', 'あ', 'いい', 'ううう', 'あ', 'いい',\n 'ううう', 'あ',\n ...\n 'ううう', 'あ', 'いい', 'ううう', 'あ', 'いい', 'ううう',\n 'あ', 'いい', 'ううう'],\n categories=['あ', 'いい', 'ううう'], ordered=False, dtype='category', length=300)\"\"\" # noqa\n\n assert repr(idx) == expected\n else:\n expected = u\"\"\"CategoricalIndex([u'あ', u'いい', u'ううう', u'あ', u'いい', u'ううう', u'あ',\n u'いい', u'ううう', u'あ',\n ...\n u'ううう', u'あ', u'いい', u'ううう', u'あ', u'いい',\n u'ううう', u'あ', u'いい', u'ううう'],\n categories=[u'あ', u'いい', u'ううう'], ordered=False, dtype='category', length=300)\"\"\" # noqa\n\n assert unicode(idx) == expected\n\n # larger categories\n idx = pd.CategoricalIndex(list(u'あいうえおかきくけこさしすせそ'))\n if PY3:\n expected = u\"\"\"CategoricalIndex(['あ', 'い', 'う', 'え', 'お', 'か', 'き', 'く', 'け', 'こ',\n 'さ', 'し', 'す', 'せ', 'そ'],\n categories=['あ', 'い', 'う', 'え', 'お', 'か', 'き', 'く', ...], ordered=False, dtype='category')\"\"\" # noqa\n\n assert repr(idx) == expected\n else:\n expected = u\"\"\"CategoricalIndex([u'あ', u'い', u'う', u'え', u'お', u'か', u'き', u'く',\n u'け', u'こ', u'さ', u'し', u'す', u'せ', u'そ'],\n categories=[u'あ', u'い', u'う', u'え', u'お', u'か', u'き', u'く', ...], ordered=False, dtype='category')\"\"\" # noqa\n\n assert unicode(idx) == expected\n\n def test_fillna_categorical(self):\n # GH 11343\n idx = CategoricalIndex([1.0, np.nan, 3.0, 1.0], name='x')\n # fill by value in categories\n exp = CategoricalIndex([1.0, 1.0, 3.0, 1.0], name='x')\n tm.assert_index_equal(idx.fillna(1.0), exp)\n\n # fill by value not in categories raises ValueError\n with tm.assert_raises_regex(ValueError,\n 'fill value must be in categories'):\n idx.fillna(2.0)\n\n def test_take_fill_value(self):\n # GH 12631\n\n # numeric category\n idx = pd.CategoricalIndex([1, 2, 3], name='xxx')\n result = idx.take(np.array([1, 0, -1]))\n expected = pd.CategoricalIndex([2, 1, 3], name='xxx')\n tm.assert_index_equal(result, expected)\n tm.assert_categorical_equal(result.values, expected.values)\n\n # fill_value\n result = idx.take(np.array([1, 0, -1]), fill_value=True)\n expected = pd.CategoricalIndex([2, 1, np.nan], categories=[1, 2, 3],\n name='xxx')\n tm.assert_index_equal(result, expected)\n tm.assert_categorical_equal(result.values, expected.values)\n\n # allow_fill=False\n result = idx.take(np.array([1, 0, -1]), allow_fill=False,\n fill_value=True)\n expected = pd.CategoricalIndex([2, 1, 3], name='xxx')\n tm.assert_index_equal(result, expected)\n tm.assert_categorical_equal(result.values, expected.values)\n\n # object category\n idx = pd.CategoricalIndex(list('CBA'), categories=list('ABC'),\n ordered=True, name='xxx')\n result = idx.take(np.array([1, 0, -1]))\n expected = pd.CategoricalIndex(list('BCA'), categories=list('ABC'),\n ordered=True, name='xxx')\n tm.assert_index_equal(result, expected)\n tm.assert_categorical_equal(result.values, expected.values)\n\n # fill_value\n result = idx.take(np.array([1, 0, -1]), fill_value=True)\n expected = pd.CategoricalIndex(['B', 'C', np.nan],\n categories=list('ABC'), ordered=True,\n name='xxx')\n tm.assert_index_equal(result, expected)\n tm.assert_categorical_equal(result.values, expected.values)\n\n # allow_fill=False\n result = idx.take(np.array([1, 0, -1]), allow_fill=False,\n fill_value=True)\n expected = pd.CategoricalIndex(list('BCA'), categories=list('ABC'),\n ordered=True, name='xxx')\n tm.assert_index_equal(result, expected)\n tm.assert_categorical_equal(result.values, expected.values)\n\n msg = ('When allow_fill=True and fill_value is not None, '\n 'all indices must be >= -1')\n with tm.assert_raises_regex(ValueError, msg):\n idx.take(np.array([1, 0, -2]), fill_value=True)\n with tm.assert_raises_regex(ValueError, msg):\n idx.take(np.array([1, 0, -5]), fill_value=True)\n\n with pytest.raises(IndexError):\n idx.take(np.array([1, -5]))\n\n def test_take_fill_value_datetime(self):\n\n # datetime category\n idx = pd.DatetimeIndex(['2011-01-01', '2011-02-01', '2011-03-01'],\n name='xxx')\n idx = pd.CategoricalIndex(idx)\n result = idx.take(np.array([1, 0, -1]))\n expected = pd.DatetimeIndex(['2011-02-01', '2011-01-01', '2011-03-01'],\n name='xxx')\n expected = pd.CategoricalIndex(expected)\n tm.assert_index_equal(result, expected)\n\n # fill_value\n result = idx.take(np.array([1, 0, -1]), fill_value=True)\n expected = pd.DatetimeIndex(['2011-02-01', '2011-01-01', 'NaT'],\n name='xxx')\n exp_cats = pd.DatetimeIndex(['2011-01-01', '2011-02-01', '2011-03-01'])\n expected = pd.CategoricalIndex(expected, categories=exp_cats)\n tm.assert_index_equal(result, expected)\n\n # allow_fill=False\n result = idx.take(np.array([1, 0, -1]), allow_fill=False,\n fill_value=True)\n expected = pd.DatetimeIndex(['2011-02-01', '2011-01-01', '2011-03-01'],\n name='xxx')\n expected = pd.CategoricalIndex(expected)\n tm.assert_index_equal(result, expected)\n\n msg = ('When allow_fill=True and fill_value is not None, '\n 'all indices must be >= -1')\n with tm.assert_raises_regex(ValueError, msg):\n idx.take(np.array([1, 0, -2]), fill_value=True)\n with tm.assert_raises_regex(ValueError, msg):\n idx.take(np.array([1, 0, -5]), fill_value=True)\n\n with pytest.raises(IndexError):\n idx.take(np.array([1, -5]))\n\n def test_take_invalid_kwargs(self):\n idx = pd.CategoricalIndex([1, 2, 3], name='foo')\n indices = [1, 0, -1]\n\n msg = r\"take\\(\\) got an unexpected keyword argument 'foo'\"\n tm.assert_raises_regex(TypeError, msg, idx.take,\n indices, foo=2)\n\n msg = \"the 'out' parameter is not supported\"\n tm.assert_raises_regex(ValueError, msg, idx.take,\n indices, out=indices)\n\n msg = \"the 'mode' parameter is not supported\"\n tm.assert_raises_regex(ValueError, msg, idx.take,\n indices, mode='clip')\n",
"import pytest\n\nimport pytz\nimport numpy as np\nfrom datetime import datetime, date, timedelta\n\nimport pandas as pd\nimport pandas.util.testing as tm\nimport pandas.core.indexes.period as period\nfrom pandas.compat import text_type, iteritems\nfrom pandas.compat.numpy import np_datetime64_compat\n\nfrom pandas._libs import tslib\nfrom pandas._libs.tslibs import period as libperiod\nfrom pandas._libs.tslibs.ccalendar import DAYS, MONTHS\nfrom pandas._libs.tslibs.parsing import DateParseError\nfrom pandas import Period, Timestamp, offsets\n\n\nclass TestPeriodProperties(object):\n \"Test properties such as year, month, weekday, etc....\"\n\n def test_is_leap_year(self):\n # GH 13727\n for freq in ['A', 'M', 'D', 'H']:\n p = Period('2000-01-01 00:00:00', freq=freq)\n assert p.is_leap_year\n assert isinstance(p.is_leap_year, bool)\n\n p = Period('1999-01-01 00:00:00', freq=freq)\n assert not p.is_leap_year\n\n p = Period('2004-01-01 00:00:00', freq=freq)\n assert p.is_leap_year\n\n p = Period('2100-01-01 00:00:00', freq=freq)\n assert not p.is_leap_year\n\n def test_quarterly_negative_ordinals(self):\n p = Period(ordinal=-1, freq='Q-DEC')\n assert p.year == 1969\n assert p.quarter == 4\n assert isinstance(p, Period)\n\n p = Period(ordinal=-2, freq='Q-DEC')\n assert p.year == 1969\n assert p.quarter == 3\n assert isinstance(p, Period)\n\n p = Period(ordinal=-2, freq='M')\n assert p.year == 1969\n assert p.month == 11\n assert isinstance(p, Period)\n\n def test_period_cons_quarterly(self):\n # bugs in scikits.timeseries\n for month in MONTHS:\n freq = 'Q-%s' % month\n exp = Period('1989Q3', freq=freq)\n assert '1989Q3' in str(exp)\n stamp = exp.to_timestamp('D', how='end')\n p = Period(stamp, freq=freq)\n assert p == exp\n\n stamp = exp.to_timestamp('3D', how='end')\n p = Period(stamp, freq=freq)\n assert p == exp\n\n def test_period_cons_annual(self):\n # bugs in scikits.timeseries\n for month in MONTHS:\n freq = 'A-%s' % month\n exp = Period('1989', freq=freq)\n stamp = exp.to_timestamp('D', how='end') + timedelta(days=30)\n p = Period(stamp, freq=freq)\n assert p == exp + 1\n assert isinstance(p, Period)\n\n def test_period_cons_weekly(self):\n for num in range(10, 17):\n daystr = '2011-02-%d' % num\n for day in DAYS:\n freq = 'W-%s' % day\n\n result = Period(daystr, freq=freq)\n expected = Period(daystr, freq='D').asfreq(freq)\n assert result == expected\n assert isinstance(result, Period)\n\n def test_period_from_ordinal(self):\n p = pd.Period('2011-01', freq='M')\n res = pd.Period._from_ordinal(p.ordinal, freq='M')\n assert p == res\n assert isinstance(res, Period)\n\n def test_period_cons_nat(self):\n p = Period('NaT', freq='M')\n assert p is pd.NaT\n\n p = Period('nat', freq='W-SUN')\n assert p is pd.NaT\n\n p = Period(tslib.iNaT, freq='D')\n assert p is pd.NaT\n\n p = Period(tslib.iNaT, freq='3D')\n assert p is pd.NaT\n\n p = Period(tslib.iNaT, freq='1D1H')\n assert p is pd.NaT\n\n p = Period('NaT')\n assert p is pd.NaT\n\n p = Period(tslib.iNaT)\n assert p is pd.NaT\n\n def test_period_cons_mult(self):\n p1 = Period('2011-01', freq='3M')\n p2 = Period('2011-01', freq='M')\n assert p1.ordinal == p2.ordinal\n\n assert p1.freq == offsets.MonthEnd(3)\n assert p1.freqstr == '3M'\n\n assert p2.freq == offsets.MonthEnd()\n assert p2.freqstr == 'M'\n\n result = p1 + 1\n assert result.ordinal == (p2 + 3).ordinal\n assert result.freq == p1.freq\n assert result.freqstr == '3M'\n\n result = p1 - 1\n assert result.ordinal == (p2 - 3).ordinal\n assert result.freq == p1.freq\n assert result.freqstr == '3M'\n\n msg = ('Frequency must be positive, because it'\n ' represents span: -3M')\n with tm.assert_raises_regex(ValueError, msg):\n Period('2011-01', freq='-3M')\n\n msg = ('Frequency must be positive, because it' ' represents span: 0M')\n with tm.assert_raises_regex(ValueError, msg):\n Period('2011-01', freq='0M')\n\n def test_period_cons_combined(self):\n p = [(Period('2011-01', freq='1D1H'),\n Period('2011-01', freq='1H1D'),\n Period('2011-01', freq='H')),\n (Period(ordinal=1, freq='1D1H'),\n Period(ordinal=1, freq='1H1D'),\n Period(ordinal=1, freq='H'))]\n\n for p1, p2, p3 in p:\n assert p1.ordinal == p3.ordinal\n assert p2.ordinal == p3.ordinal\n\n assert p1.freq == offsets.Hour(25)\n assert p1.freqstr == '25H'\n\n assert p2.freq == offsets.Hour(25)\n assert p2.freqstr == '25H'\n\n assert p3.freq == offsets.Hour()\n assert p3.freqstr == 'H'\n\n result = p1 + 1\n assert result.ordinal == (p3 + 25).ordinal\n assert result.freq == p1.freq\n assert result.freqstr == '25H'\n\n result = p2 + 1\n assert result.ordinal == (p3 + 25).ordinal\n assert result.freq == p2.freq\n assert result.freqstr == '25H'\n\n result = p1 - 1\n assert result.ordinal == (p3 - 25).ordinal\n assert result.freq == p1.freq\n assert result.freqstr == '25H'\n\n result = p2 - 1\n assert result.ordinal == (p3 - 25).ordinal\n assert result.freq == p2.freq\n assert result.freqstr == '25H'\n\n msg = ('Frequency must be positive, because it'\n ' represents span: -25H')\n with tm.assert_raises_regex(ValueError, msg):\n Period('2011-01', freq='-1D1H')\n with tm.assert_raises_regex(ValueError, msg):\n Period('2011-01', freq='-1H1D')\n with tm.assert_raises_regex(ValueError, msg):\n Period(ordinal=1, freq='-1D1H')\n with tm.assert_raises_regex(ValueError, msg):\n Period(ordinal=1, freq='-1H1D')\n\n msg = ('Frequency must be positive, because it'\n ' represents span: 0D')\n with tm.assert_raises_regex(ValueError, msg):\n Period('2011-01', freq='0D0H')\n with tm.assert_raises_regex(ValueError, msg):\n Period(ordinal=1, freq='0D0H')\n\n # You can only combine together day and intraday offsets\n msg = ('Invalid frequency: 1W1D')\n with tm.assert_raises_regex(ValueError, msg):\n Period('2011-01', freq='1W1D')\n msg = ('Invalid frequency: 1D1W')\n with tm.assert_raises_regex(ValueError, msg):\n Period('2011-01', freq='1D1W')\n\n def test_timestamp_tz_arg(self):\n for case in ['Europe/Brussels', 'Asia/Tokyo', 'US/Pacific']:\n p = Period('1/1/2005', freq='M').to_timestamp(tz=case)\n exp = Timestamp('1/1/2005', tz='UTC').tz_convert(case)\n exp_zone = pytz.timezone(case).normalize(p)\n\n assert p == exp\n assert p.tz == exp_zone.tzinfo\n assert p.tz == exp.tz\n\n p = Period('1/1/2005', freq='3H').to_timestamp(tz=case)\n exp = Timestamp('1/1/2005', tz='UTC').tz_convert(case)\n exp_zone = pytz.timezone(case).normalize(p)\n\n assert p == exp\n assert p.tz == exp_zone.tzinfo\n assert p.tz == exp.tz\n\n p = Period('1/1/2005', freq='A').to_timestamp(freq='A', tz=case)\n exp = Timestamp('31/12/2005', tz='UTC').tz_convert(case)\n exp_zone = pytz.timezone(case).normalize(p)\n\n assert p == exp\n assert p.tz == exp_zone.tzinfo\n assert p.tz == exp.tz\n\n p = Period('1/1/2005', freq='A').to_timestamp(freq='3H', tz=case)\n exp = Timestamp('1/1/2005', tz='UTC').tz_convert(case)\n exp_zone = pytz.timezone(case).normalize(p)\n\n assert p == exp\n assert p.tz == exp_zone.tzinfo\n assert p.tz == exp.tz\n\n def test_timestamp_tz_arg_dateutil(self):\n from pandas._libs.tslibs.timezones import dateutil_gettz\n from pandas._libs.tslibs.timezones import maybe_get_tz\n for case in ['dateutil/Europe/Brussels', 'dateutil/Asia/Tokyo',\n 'dateutil/US/Pacific']:\n p = Period('1/1/2005', freq='M').to_timestamp(\n tz=maybe_get_tz(case))\n exp = Timestamp('1/1/2005', tz='UTC').tz_convert(case)\n assert p == exp\n assert p.tz == dateutil_gettz(case.split('/', 1)[1])\n assert p.tz == exp.tz\n\n p = Period('1/1/2005',\n freq='M').to_timestamp(freq='3H', tz=maybe_get_tz(case))\n exp = Timestamp('1/1/2005', tz='UTC').tz_convert(case)\n assert p == exp\n assert p.tz == dateutil_gettz(case.split('/', 1)[1])\n assert p.tz == exp.tz\n\n def test_timestamp_tz_arg_dateutil_from_string(self):\n from pandas._libs.tslibs.timezones import dateutil_gettz\n p = Period('1/1/2005',\n freq='M').to_timestamp(tz='dateutil/Europe/Brussels')\n assert p.tz == dateutil_gettz('Europe/Brussels')\n\n def test_timestamp_mult(self):\n p = pd.Period('2011-01', freq='M')\n assert p.to_timestamp(how='S') == pd.Timestamp('2011-01-01')\n assert p.to_timestamp(how='E') == pd.Timestamp('2011-01-31')\n\n p = pd.Period('2011-01', freq='3M')\n assert p.to_timestamp(how='S') == pd.Timestamp('2011-01-01')\n assert p.to_timestamp(how='E') == pd.Timestamp('2011-03-31')\n\n def test_construction(self):\n i1 = Period('1/1/2005', freq='M')\n i2 = Period('Jan 2005')\n\n assert i1 == i2\n\n i1 = Period('2005', freq='A')\n i2 = Period('2005')\n i3 = Period('2005', freq='a')\n\n assert i1 == i2\n assert i1 == i3\n\n i4 = Period('2005', freq='M')\n i5 = Period('2005', freq='m')\n\n pytest.raises(ValueError, i1.__ne__, i4)\n assert i4 == i5\n\n i1 = Period.now('Q')\n i2 = Period(datetime.now(), freq='Q')\n i3 = Period.now('q')\n\n assert i1 == i2\n assert i1 == i3\n\n i1 = Period('1982', freq='min')\n i2 = Period('1982', freq='MIN')\n assert i1 == i2\n i2 = Period('1982', freq=('Min', 1))\n assert i1 == i2\n\n i1 = Period(year=2005, month=3, day=1, freq='D')\n i2 = Period('3/1/2005', freq='D')\n assert i1 == i2\n\n i3 = Period(year=2005, month=3, day=1, freq='d')\n assert i1 == i3\n\n i1 = Period('2007-01-01 09:00:00.001')\n expected = Period(datetime(2007, 1, 1, 9, 0, 0, 1000), freq='L')\n assert i1 == expected\n\n expected = Period(np_datetime64_compat(\n '2007-01-01 09:00:00.001Z'), freq='L')\n assert i1 == expected\n\n i1 = Period('2007-01-01 09:00:00.00101')\n expected = Period(datetime(2007, 1, 1, 9, 0, 0, 1010), freq='U')\n assert i1 == expected\n\n expected = Period(np_datetime64_compat('2007-01-01 09:00:00.00101Z'),\n freq='U')\n assert i1 == expected\n\n pytest.raises(ValueError, Period, ordinal=200701)\n\n pytest.raises(ValueError, Period, '2007-1-1', freq='X')\n\n def test_construction_bday(self):\n\n # Biz day construction, roll forward if non-weekday\n i1 = Period('3/10/12', freq='B')\n i2 = Period('3/10/12', freq='D')\n assert i1 == i2.asfreq('B')\n i2 = Period('3/11/12', freq='D')\n assert i1 == i2.asfreq('B')\n i2 = Period('3/12/12', freq='D')\n assert i1 == i2.asfreq('B')\n\n i3 = Period('3/10/12', freq='b')\n assert i1 == i3\n\n i1 = Period(year=2012, month=3, day=10, freq='B')\n i2 = Period('3/12/12', freq='B')\n assert i1 == i2\n\n def test_construction_quarter(self):\n\n i1 = Period(year=2005, quarter=1, freq='Q')\n i2 = Period('1/1/2005', freq='Q')\n assert i1 == i2\n\n i1 = Period(year=2005, quarter=3, freq='Q')\n i2 = Period('9/1/2005', freq='Q')\n assert i1 == i2\n\n i1 = Period('2005Q1')\n i2 = Period(year=2005, quarter=1, freq='Q')\n i3 = Period('2005q1')\n assert i1 == i2\n assert i1 == i3\n\n i1 = Period('05Q1')\n assert i1 == i2\n lower = Period('05q1')\n assert i1 == lower\n\n i1 = Period('1Q2005')\n assert i1 == i2\n lower = Period('1q2005')\n assert i1 == lower\n\n i1 = Period('1Q05')\n assert i1 == i2\n lower = Period('1q05')\n assert i1 == lower\n\n i1 = Period('4Q1984')\n assert i1.year == 1984\n lower = Period('4q1984')\n assert i1 == lower\n\n def test_construction_month(self):\n\n expected = Period('2007-01', freq='M')\n i1 = Period('200701', freq='M')\n assert i1 == expected\n\n i1 = Period('200701', freq='M')\n assert i1 == expected\n\n i1 = Period(200701, freq='M')\n assert i1 == expected\n\n i1 = Period(ordinal=200701, freq='M')\n assert i1.year == 18695\n\n i1 = Period(datetime(2007, 1, 1), freq='M')\n i2 = Period('200701', freq='M')\n assert i1 == i2\n\n i1 = Period(date(2007, 1, 1), freq='M')\n i2 = Period(datetime(2007, 1, 1), freq='M')\n i3 = Period(np.datetime64('2007-01-01'), freq='M')\n i4 = Period(np_datetime64_compat('2007-01-01 00:00:00Z'), freq='M')\n i5 = Period(np_datetime64_compat('2007-01-01 00:00:00.000Z'), freq='M')\n assert i1 == i2\n assert i1 == i3\n assert i1 == i4\n assert i1 == i5\n\n def test_period_constructor_offsets(self):\n assert (Period('1/1/2005', freq=offsets.MonthEnd()) ==\n Period('1/1/2005', freq='M'))\n assert (Period('2005', freq=offsets.YearEnd()) ==\n Period('2005', freq='A'))\n assert (Period('2005', freq=offsets.MonthEnd()) ==\n Period('2005', freq='M'))\n assert (Period('3/10/12', freq=offsets.BusinessDay()) ==\n Period('3/10/12', freq='B'))\n assert (Period('3/10/12', freq=offsets.Day()) ==\n Period('3/10/12', freq='D'))\n\n assert (Period(year=2005, quarter=1,\n freq=offsets.QuarterEnd(startingMonth=12)) ==\n Period(year=2005, quarter=1, freq='Q'))\n assert (Period(year=2005, quarter=2,\n freq=offsets.QuarterEnd(startingMonth=12)) ==\n Period(year=2005, quarter=2, freq='Q'))\n\n assert (Period(year=2005, month=3, day=1, freq=offsets.Day()) ==\n Period(year=2005, month=3, day=1, freq='D'))\n assert (Period(year=2012, month=3, day=10, freq=offsets.BDay()) ==\n Period(year=2012, month=3, day=10, freq='B'))\n\n expected = Period('2005-03-01', freq='3D')\n assert (Period(year=2005, month=3, day=1,\n freq=offsets.Day(3)) == expected)\n assert Period(year=2005, month=3, day=1, freq='3D') == expected\n\n assert (Period(year=2012, month=3, day=10,\n freq=offsets.BDay(3)) ==\n Period(year=2012, month=3, day=10, freq='3B'))\n\n assert (Period(200701, freq=offsets.MonthEnd()) ==\n Period(200701, freq='M'))\n\n i1 = Period(ordinal=200701, freq=offsets.MonthEnd())\n i2 = Period(ordinal=200701, freq='M')\n assert i1 == i2\n assert i1.year == 18695\n assert i2.year == 18695\n\n i1 = Period(datetime(2007, 1, 1), freq='M')\n i2 = Period('200701', freq='M')\n assert i1 == i2\n\n i1 = Period(date(2007, 1, 1), freq='M')\n i2 = Period(datetime(2007, 1, 1), freq='M')\n i3 = Period(np.datetime64('2007-01-01'), freq='M')\n i4 = Period(np_datetime64_compat('2007-01-01 00:00:00Z'), freq='M')\n i5 = Period(np_datetime64_compat('2007-01-01 00:00:00.000Z'), freq='M')\n assert i1 == i2\n assert i1 == i3\n assert i1 == i4\n assert i1 == i5\n\n i1 = Period('2007-01-01 09:00:00.001')\n expected = Period(datetime(2007, 1, 1, 9, 0, 0, 1000), freq='L')\n assert i1 == expected\n\n expected = Period(np_datetime64_compat(\n '2007-01-01 09:00:00.001Z'), freq='L')\n assert i1 == expected\n\n i1 = Period('2007-01-01 09:00:00.00101')\n expected = Period(datetime(2007, 1, 1, 9, 0, 0, 1010), freq='U')\n assert i1 == expected\n\n expected = Period(np_datetime64_compat('2007-01-01 09:00:00.00101Z'),\n freq='U')\n assert i1 == expected\n\n pytest.raises(ValueError, Period, ordinal=200701)\n\n pytest.raises(ValueError, Period, '2007-1-1', freq='X')\n\n def test_freq_str(self):\n i1 = Period('1982', freq='Min')\n assert i1.freq == offsets.Minute()\n assert i1.freqstr == 'T'\n\n def test_period_deprecated_freq(self):\n cases = {\"M\": [\"MTH\", \"MONTH\", \"MONTHLY\", \"Mth\", \"month\", \"monthly\"],\n \"B\": [\"BUS\", \"BUSINESS\", \"BUSINESSLY\", \"WEEKDAY\", \"bus\"],\n \"D\": [\"DAY\", \"DLY\", \"DAILY\", \"Day\", \"Dly\", \"Daily\"],\n \"H\": [\"HR\", \"HOUR\", \"HRLY\", \"HOURLY\", \"hr\", \"Hour\", \"HRly\"],\n \"T\": [\"minute\", \"MINUTE\", \"MINUTELY\", \"minutely\"],\n \"S\": [\"sec\", \"SEC\", \"SECOND\", \"SECONDLY\", \"second\"],\n \"L\": [\"MILLISECOND\", \"MILLISECONDLY\", \"millisecond\"],\n \"U\": [\"MICROSECOND\", \"MICROSECONDLY\", \"microsecond\"],\n \"N\": [\"NANOSECOND\", \"NANOSECONDLY\", \"nanosecond\"]}\n\n msg = pd.tseries.frequencies._INVALID_FREQ_ERROR\n for exp, freqs in iteritems(cases):\n for freq in freqs:\n with tm.assert_raises_regex(ValueError, msg):\n Period('2016-03-01 09:00', freq=freq)\n with tm.assert_raises_regex(ValueError, msg):\n Period(ordinal=1, freq=freq)\n\n # check supported freq-aliases still works\n p1 = Period('2016-03-01 09:00', freq=exp)\n p2 = Period(ordinal=1, freq=exp)\n assert isinstance(p1, Period)\n assert isinstance(p2, Period)\n\n def test_hash(self):\n assert (hash(Period('2011-01', freq='M')) ==\n hash(Period('2011-01', freq='M')))\n\n assert (hash(Period('2011-01-01', freq='D')) !=\n hash(Period('2011-01', freq='M')))\n\n assert (hash(Period('2011-01', freq='3M')) !=\n hash(Period('2011-01', freq='2M')))\n\n assert (hash(Period('2011-01', freq='M')) !=\n hash(Period('2011-02', freq='M')))\n\n def test_repr(self):\n p = Period('Jan-2000')\n assert '2000-01' in repr(p)\n\n p = Period('2000-12-15')\n assert '2000-12-15' in repr(p)\n\n def test_repr_nat(self):\n p = Period('nat', freq='M')\n assert repr(tslib.NaT) in repr(p)\n\n def test_millisecond_repr(self):\n p = Period('2000-01-01 12:15:02.123')\n\n assert repr(p) == \"Period('2000-01-01 12:15:02.123', 'L')\"\n\n def test_microsecond_repr(self):\n p = Period('2000-01-01 12:15:02.123567')\n\n assert repr(p) == \"Period('2000-01-01 12:15:02.123567', 'U')\"\n\n def test_strftime(self):\n p = Period('2000-1-1 12:34:12', freq='S')\n res = p.strftime('%Y-%m-%d %H:%M:%S')\n assert res == '2000-01-01 12:34:12'\n assert isinstance(res, text_type) # GH3363\n\n def test_sub_delta(self):\n left, right = Period('2011', freq='A'), Period('2007', freq='A')\n result = left - right\n assert result == 4\n\n with pytest.raises(period.IncompatibleFrequency):\n left - Period('2007-01', freq='M')\n\n def test_to_timestamp(self):\n p = Period('1982', freq='A')\n start_ts = p.to_timestamp(how='S')\n aliases = ['s', 'StarT', 'BEGIn']\n for a in aliases:\n assert start_ts == p.to_timestamp('D', how=a)\n # freq with mult should not affect to the result\n assert start_ts == p.to_timestamp('3D', how=a)\n\n end_ts = p.to_timestamp(how='E')\n aliases = ['e', 'end', 'FINIsH']\n for a in aliases:\n assert end_ts == p.to_timestamp('D', how=a)\n assert end_ts == p.to_timestamp('3D', how=a)\n\n from_lst = ['A', 'Q', 'M', 'W', 'B', 'D', 'H', 'Min', 'S']\n\n def _ex(p):\n return Timestamp((p + 1).start_time.value - 1)\n\n for i, fcode in enumerate(from_lst):\n p = Period('1982', freq=fcode)\n result = p.to_timestamp().to_period(fcode)\n assert result == p\n\n assert p.start_time == p.to_timestamp(how='S')\n\n assert p.end_time == _ex(p)\n\n # Frequency other than daily\n\n p = Period('1985', freq='A')\n\n result = p.to_timestamp('H', how='end')\n expected = datetime(1985, 12, 31, 23)\n assert result == expected\n result = p.to_timestamp('3H', how='end')\n assert result == expected\n\n result = p.to_timestamp('T', how='end')\n expected = datetime(1985, 12, 31, 23, 59)\n assert result == expected\n result = p.to_timestamp('2T', how='end')\n assert result == expected\n\n result = p.to_timestamp(how='end')\n expected = datetime(1985, 12, 31)\n assert result == expected\n\n expected = datetime(1985, 1, 1)\n result = p.to_timestamp('H', how='start')\n assert result == expected\n result = p.to_timestamp('T', how='start')\n assert result == expected\n result = p.to_timestamp('S', how='start')\n assert result == expected\n result = p.to_timestamp('3H', how='start')\n assert result == expected\n result = p.to_timestamp('5S', how='start')\n assert result == expected\n\n def test_start_time(self):\n freq_lst = ['A', 'Q', 'M', 'D', 'H', 'T', 'S']\n xp = datetime(2012, 1, 1)\n for f in freq_lst:\n p = Period('2012', freq=f)\n assert p.start_time == xp\n assert Period('2012', freq='B').start_time == datetime(2012, 1, 2)\n assert Period('2012', freq='W').start_time == datetime(2011, 12, 26)\n\n def test_end_time(self):\n p = Period('2012', freq='A')\n\n def _ex(*args):\n return Timestamp(Timestamp(datetime(*args)).value - 1)\n\n xp = _ex(2013, 1, 1)\n assert xp == p.end_time\n\n p = Period('2012', freq='Q')\n xp = _ex(2012, 4, 1)\n assert xp == p.end_time\n\n p = Period('2012', freq='M')\n xp = _ex(2012, 2, 1)\n assert xp == p.end_time\n\n p = Period('2012', freq='D')\n xp = _ex(2012, 1, 2)\n assert xp == p.end_time\n\n p = Period('2012', freq='H')\n xp = _ex(2012, 1, 1, 1)\n assert xp == p.end_time\n\n p = Period('2012', freq='B')\n xp = _ex(2012, 1, 3)\n assert xp == p.end_time\n\n p = Period('2012', freq='W')\n xp = _ex(2012, 1, 2)\n assert xp == p.end_time\n\n # Test for GH 11738\n p = Period('2012', freq='15D')\n xp = _ex(2012, 1, 16)\n assert xp == p.end_time\n\n p = Period('2012', freq='1D1H')\n xp = _ex(2012, 1, 2, 1)\n assert xp == p.end_time\n\n p = Period('2012', freq='1H1D')\n xp = _ex(2012, 1, 2, 1)\n assert xp == p.end_time\n\n def test_anchor_week_end_time(self):\n def _ex(*args):\n return Timestamp(Timestamp(datetime(*args)).value - 1)\n\n p = Period('2013-1-1', 'W-SAT')\n xp = _ex(2013, 1, 6)\n assert p.end_time == xp\n\n def test_properties_annually(self):\n # Test properties on Periods with annually frequency.\n a_date = Period(freq='A', year=2007)\n assert a_date.year == 2007\n\n def test_properties_quarterly(self):\n # Test properties on Periods with daily frequency.\n qedec_date = Period(freq=\"Q-DEC\", year=2007, quarter=1)\n qejan_date = Period(freq=\"Q-JAN\", year=2007, quarter=1)\n qejun_date = Period(freq=\"Q-JUN\", year=2007, quarter=1)\n #\n for x in range(3):\n for qd in (qedec_date, qejan_date, qejun_date):\n assert (qd + x).qyear == 2007\n assert (qd + x).quarter == x + 1\n\n def test_properties_monthly(self):\n # Test properties on Periods with daily frequency.\n m_date = Period(freq='M', year=2007, month=1)\n for x in range(11):\n m_ival_x = m_date + x\n assert m_ival_x.year == 2007\n if 1 <= x + 1 <= 3:\n assert m_ival_x.quarter == 1\n elif 4 <= x + 1 <= 6:\n assert m_ival_x.quarter == 2\n elif 7 <= x + 1 <= 9:\n assert m_ival_x.quarter == 3\n elif 10 <= x + 1 <= 12:\n assert m_ival_x.quarter == 4\n assert m_ival_x.month == x + 1\n\n def test_properties_weekly(self):\n # Test properties on Periods with daily frequency.\n w_date = Period(freq='W', year=2007, month=1, day=7)\n #\n assert w_date.year == 2007\n assert w_date.quarter == 1\n assert w_date.month == 1\n assert w_date.week == 1\n assert (w_date - 1).week == 52\n assert w_date.days_in_month == 31\n assert Period(freq='W', year=2012,\n month=2, day=1).days_in_month == 29\n\n def test_properties_weekly_legacy(self):\n # Test properties on Periods with daily frequency.\n w_date = Period(freq='W', year=2007, month=1, day=7)\n assert w_date.year == 2007\n assert w_date.quarter == 1\n assert w_date.month == 1\n assert w_date.week == 1\n assert (w_date - 1).week == 52\n assert w_date.days_in_month == 31\n\n exp = Period(freq='W', year=2012, month=2, day=1)\n assert exp.days_in_month == 29\n\n msg = pd.tseries.frequencies._INVALID_FREQ_ERROR\n with tm.assert_raises_regex(ValueError, msg):\n Period(freq='WK', year=2007, month=1, day=7)\n\n def test_properties_daily(self):\n # Test properties on Periods with daily frequency.\n b_date = Period(freq='B', year=2007, month=1, day=1)\n #\n assert b_date.year == 2007\n assert b_date.quarter == 1\n assert b_date.month == 1\n assert b_date.day == 1\n assert b_date.weekday == 0\n assert b_date.dayofyear == 1\n assert b_date.days_in_month == 31\n assert Period(freq='B', year=2012,\n month=2, day=1).days_in_month == 29\n\n d_date = Period(freq='D', year=2007, month=1, day=1)\n\n assert d_date.year == 2007\n assert d_date.quarter == 1\n assert d_date.month == 1\n assert d_date.day == 1\n assert d_date.weekday == 0\n assert d_date.dayofyear == 1\n assert d_date.days_in_month == 31\n assert Period(freq='D', year=2012, month=2,\n day=1).days_in_month == 29\n\n def test_properties_hourly(self):\n # Test properties on Periods with hourly frequency.\n h_date1 = Period(freq='H', year=2007, month=1, day=1, hour=0)\n h_date2 = Period(freq='2H', year=2007, month=1, day=1, hour=0)\n\n for h_date in [h_date1, h_date2]:\n assert h_date.year == 2007\n assert h_date.quarter == 1\n assert h_date.month == 1\n assert h_date.day == 1\n assert h_date.weekday == 0\n assert h_date.dayofyear == 1\n assert h_date.hour == 0\n assert h_date.days_in_month == 31\n assert Period(freq='H', year=2012, month=2, day=1,\n hour=0).days_in_month == 29\n\n def test_properties_minutely(self):\n # Test properties on Periods with minutely frequency.\n t_date = Period(freq='Min', year=2007, month=1, day=1, hour=0,\n minute=0)\n #\n assert t_date.quarter == 1\n assert t_date.month == 1\n assert t_date.day == 1\n assert t_date.weekday == 0\n assert t_date.dayofyear == 1\n assert t_date.hour == 0\n assert t_date.minute == 0\n assert t_date.days_in_month == 31\n assert Period(freq='D', year=2012, month=2, day=1, hour=0,\n minute=0).days_in_month == 29\n\n def test_properties_secondly(self):\n # Test properties on Periods with secondly frequency.\n s_date = Period(freq='Min', year=2007, month=1, day=1, hour=0,\n minute=0, second=0)\n #\n assert s_date.year == 2007\n assert s_date.quarter == 1\n assert s_date.month == 1\n assert s_date.day == 1\n assert s_date.weekday == 0\n assert s_date.dayofyear == 1\n assert s_date.hour == 0\n assert s_date.minute == 0\n assert s_date.second == 0\n assert s_date.days_in_month == 31\n assert Period(freq='Min', year=2012, month=2, day=1, hour=0,\n minute=0, second=0).days_in_month == 29\n\n def test_pnow(self):\n\n # deprecation, xref #13790\n with tm.assert_produces_warning(FutureWarning,\n check_stacklevel=False):\n period.pnow('D')\n\n def test_constructor_corner(self):\n expected = Period('2007-01', freq='2M')\n assert Period(year=2007, month=1, freq='2M') == expected\n\n pytest.raises(ValueError, Period, datetime.now())\n pytest.raises(ValueError, Period, datetime.now().date())\n pytest.raises(ValueError, Period, 1.6, freq='D')\n pytest.raises(ValueError, Period, ordinal=1.6, freq='D')\n pytest.raises(ValueError, Period, ordinal=2, value=1, freq='D')\n assert Period(None) is pd.NaT\n pytest.raises(ValueError, Period, month=1)\n\n p = Period('2007-01-01', freq='D')\n\n result = Period(p, freq='A')\n exp = Period('2007', freq='A')\n assert result == exp\n\n def test_constructor_infer_freq(self):\n p = Period('2007-01-01')\n assert p.freq == 'D'\n\n p = Period('2007-01-01 07')\n assert p.freq == 'H'\n\n p = Period('2007-01-01 07:10')\n assert p.freq == 'T'\n\n p = Period('2007-01-01 07:10:15')\n assert p.freq == 'S'\n\n p = Period('2007-01-01 07:10:15.123')\n assert p.freq == 'L'\n\n p = Period('2007-01-01 07:10:15.123000')\n assert p.freq == 'L'\n\n p = Period('2007-01-01 07:10:15.123400')\n assert p.freq == 'U'\n\n def test_badinput(self):\n pytest.raises(ValueError, Period, '-2000', 'A')\n pytest.raises(DateParseError, Period, '0', 'A')\n pytest.raises(DateParseError, Period, '1/1/-2000', 'A')\n\n def test_multiples(self):\n result1 = Period('1989', freq='2A')\n result2 = Period('1989', freq='A')\n assert result1.ordinal == result2.ordinal\n assert result1.freqstr == '2A-DEC'\n assert result2.freqstr == 'A-DEC'\n assert result1.freq == offsets.YearEnd(2)\n assert result2.freq == offsets.YearEnd()\n\n assert (result1 + 1).ordinal == result1.ordinal + 2\n assert (1 + result1).ordinal == result1.ordinal + 2\n assert (result1 - 1).ordinal == result2.ordinal - 2\n assert (-1 + result1).ordinal == result2.ordinal - 2\n\n def test_round_trip(self):\n\n p = Period('2000Q1')\n new_p = tm.round_trip_pickle(p)\n assert new_p == p\n\n\nclass TestPeriodField(object):\n\n def test_get_period_field_raises_on_out_of_range(self):\n pytest.raises(ValueError, libperiod.get_period_field, -1, 0, 0)\n\n def test_get_period_field_array_raises_on_out_of_range(self):\n pytest.raises(ValueError, libperiod.get_period_field_arr, -1,\n np.empty(1), 0)\n\n\nclass TestComparisons(object):\n\n def setup_method(self, method):\n self.january1 = Period('2000-01', 'M')\n self.january2 = Period('2000-01', 'M')\n self.february = Period('2000-02', 'M')\n self.march = Period('2000-03', 'M')\n self.day = Period('2012-01-01', 'D')\n\n def test_equal(self):\n assert self.january1 == self.january2\n\n def test_equal_Raises_Value(self):\n with pytest.raises(period.IncompatibleFrequency):\n self.january1 == self.day\n\n def test_notEqual(self):\n assert self.january1 != 1\n assert self.january1 != self.february\n\n def test_greater(self):\n assert self.february > self.january1\n\n def test_greater_Raises_Value(self):\n with pytest.raises(period.IncompatibleFrequency):\n self.january1 > self.day\n\n def test_greater_Raises_Type(self):\n with pytest.raises(TypeError):\n self.january1 > 1\n\n def test_greaterEqual(self):\n assert self.january1 >= self.january2\n\n def test_greaterEqual_Raises_Value(self):\n with pytest.raises(period.IncompatibleFrequency):\n self.january1 >= self.day\n\n with pytest.raises(TypeError):\n print(self.january1 >= 1)\n\n def test_smallerEqual(self):\n assert self.january1 <= self.january2\n\n def test_smallerEqual_Raises_Value(self):\n with pytest.raises(period.IncompatibleFrequency):\n self.january1 <= self.day\n\n def test_smallerEqual_Raises_Type(self):\n with pytest.raises(TypeError):\n self.january1 <= 1\n\n def test_smaller(self):\n assert self.january1 < self.february\n\n def test_smaller_Raises_Value(self):\n with pytest.raises(period.IncompatibleFrequency):\n self.january1 < self.day\n\n def test_smaller_Raises_Type(self):\n with pytest.raises(TypeError):\n self.january1 < 1\n\n def test_sort(self):\n periods = [self.march, self.january1, self.february]\n correctPeriods = [self.january1, self.february, self.march]\n assert sorted(periods) == correctPeriods\n\n def test_period_nat_comp(self):\n p_nat = Period('NaT', freq='D')\n p = Period('2011-01-01', freq='D')\n\n nat = pd.Timestamp('NaT')\n t = pd.Timestamp('2011-01-01')\n # confirm Period('NaT') work identical with Timestamp('NaT')\n for left, right in [(p_nat, p), (p, p_nat), (p_nat, p_nat), (nat, t),\n (t, nat), (nat, nat)]:\n assert not left < right\n assert not left > right\n assert not left == right\n assert left != right\n assert not left <= right\n assert not left >= right\n\n\nclass TestMethods(object):\n\n def test_add(self):\n dt1 = Period(freq='D', year=2008, month=1, day=1)\n dt2 = Period(freq='D', year=2008, month=1, day=2)\n assert dt1 + 1 == dt2\n assert 1 + dt1 == dt2\n\n def test_add_pdnat(self):\n p = pd.Period('2011-01', freq='M')\n assert p + pd.NaT is pd.NaT\n assert pd.NaT + p is pd.NaT\n\n p = pd.Period('NaT', freq='M')\n assert p + pd.NaT is pd.NaT\n assert pd.NaT + p is pd.NaT\n\n def test_add_raises(self):\n # GH 4731\n dt1 = Period(freq='D', year=2008, month=1, day=1)\n dt2 = Period(freq='D', year=2008, month=1, day=2)\n msg = r\"unsupported operand type\\(s\\)\"\n with tm.assert_raises_regex(TypeError, msg):\n dt1 + \"str\"\n\n msg = r\"unsupported operand type\\(s\\)\"\n with tm.assert_raises_regex(TypeError, msg):\n \"str\" + dt1\n\n with tm.assert_raises_regex(TypeError, msg):\n dt1 + dt2\n\n boxes = [lambda x: x, lambda x: pd.Series([x]), lambda x: pd.Index([x])]\n\n @pytest.mark.parametrize('lbox', boxes)\n @pytest.mark.parametrize('rbox', boxes)\n def test_add_timestamp_raises(self, rbox, lbox):\n # GH # 17983\n ts = pd.Timestamp('2017')\n per = pd.Period('2017', freq='M')\n\n # We may get a different message depending on which class raises\n # the error.\n msg = (r\"cannot add|unsupported operand|\"\n r\"can only operate on a|incompatible type|\"\n r\"ufunc add cannot use operands\")\n with tm.assert_raises_regex(TypeError, msg):\n lbox(ts) + rbox(per)\n\n with tm.assert_raises_regex(TypeError, msg):\n lbox(per) + rbox(ts)\n\n with tm.assert_raises_regex(TypeError, msg):\n lbox(per) + rbox(per)\n\n def test_sub(self):\n dt1 = Period('2011-01-01', freq='D')\n dt2 = Period('2011-01-15', freq='D')\n\n assert dt1 - dt2 == -14\n assert dt2 - dt1 == 14\n\n msg = r\"Input has different freq=M from Period\\(freq=D\\)\"\n with tm.assert_raises_regex(period.IncompatibleFrequency, msg):\n dt1 - pd.Period('2011-02', freq='M')\n\n def test_add_offset(self):\n # freq is DateOffset\n for freq in ['A', '2A', '3A']:\n p = Period('2011', freq=freq)\n exp = Period('2013', freq=freq)\n assert p + offsets.YearEnd(2) == exp\n assert offsets.YearEnd(2) + p == exp\n\n for o in [offsets.YearBegin(2), offsets.MonthBegin(1),\n offsets.Minute(), np.timedelta64(365, 'D'),\n timedelta(365)]:\n with pytest.raises(period.IncompatibleFrequency):\n p + o\n\n if isinstance(o, np.timedelta64):\n with pytest.raises(TypeError):\n o + p\n else:\n with pytest.raises(period.IncompatibleFrequency):\n o + p\n\n for freq in ['M', '2M', '3M']:\n p = Period('2011-03', freq=freq)\n exp = Period('2011-05', freq=freq)\n assert p + offsets.MonthEnd(2) == exp\n assert offsets.MonthEnd(2) + p == exp\n\n exp = Period('2012-03', freq=freq)\n assert p + offsets.MonthEnd(12) == exp\n assert offsets.MonthEnd(12) + p == exp\n\n for o in [offsets.YearBegin(2), offsets.MonthBegin(1),\n offsets.Minute(), np.timedelta64(365, 'D'),\n timedelta(365)]:\n with pytest.raises(period.IncompatibleFrequency):\n p + o\n\n if isinstance(o, np.timedelta64):\n with pytest.raises(TypeError):\n o + p\n else:\n with pytest.raises(period.IncompatibleFrequency):\n o + p\n\n # freq is Tick\n for freq in ['D', '2D', '3D']:\n p = Period('2011-04-01', freq=freq)\n\n exp = Period('2011-04-06', freq=freq)\n assert p + offsets.Day(5) == exp\n assert offsets.Day(5) + p == exp\n\n exp = Period('2011-04-02', freq=freq)\n assert p + offsets.Hour(24) == exp\n assert offsets.Hour(24) + p == exp\n\n exp = Period('2011-04-03', freq=freq)\n assert p + np.timedelta64(2, 'D') == exp\n with pytest.raises(TypeError):\n np.timedelta64(2, 'D') + p\n\n exp = Period('2011-04-02', freq=freq)\n assert p + np.timedelta64(3600 * 24, 's') == exp\n with pytest.raises(TypeError):\n np.timedelta64(3600 * 24, 's') + p\n\n exp = Period('2011-03-30', freq=freq)\n assert p + timedelta(-2) == exp\n assert timedelta(-2) + p == exp\n\n exp = Period('2011-04-03', freq=freq)\n assert p + timedelta(hours=48) == exp\n assert timedelta(hours=48) + p == exp\n\n for o in [offsets.YearBegin(2), offsets.MonthBegin(1),\n offsets.Minute(), np.timedelta64(4, 'h'),\n timedelta(hours=23)]:\n with pytest.raises(period.IncompatibleFrequency):\n p + o\n\n if isinstance(o, np.timedelta64):\n with pytest.raises(TypeError):\n o + p\n else:\n with pytest.raises(period.IncompatibleFrequency):\n o + p\n\n for freq in ['H', '2H', '3H']:\n p = Period('2011-04-01 09:00', freq=freq)\n\n exp = Period('2011-04-03 09:00', freq=freq)\n assert p + offsets.Day(2) == exp\n assert offsets.Day(2) + p == exp\n\n exp = Period('2011-04-01 12:00', freq=freq)\n assert p + offsets.Hour(3) == exp\n assert offsets.Hour(3) + p == exp\n\n exp = Period('2011-04-01 12:00', freq=freq)\n assert p + np.timedelta64(3, 'h') == exp\n with pytest.raises(TypeError):\n np.timedelta64(3, 'h') + p\n\n exp = Period('2011-04-01 10:00', freq=freq)\n assert p + np.timedelta64(3600, 's') == exp\n with pytest.raises(TypeError):\n np.timedelta64(3600, 's') + p\n\n exp = Period('2011-04-01 11:00', freq=freq)\n assert p + timedelta(minutes=120) == exp\n assert timedelta(minutes=120) + p == exp\n\n exp = Period('2011-04-05 12:00', freq=freq)\n assert p + timedelta(days=4, minutes=180) == exp\n assert timedelta(days=4, minutes=180) + p == exp\n\n for o in [offsets.YearBegin(2), offsets.MonthBegin(1),\n offsets.Minute(), np.timedelta64(3200, 's'),\n timedelta(hours=23, minutes=30)]:\n with pytest.raises(period.IncompatibleFrequency):\n p + o\n\n if isinstance(o, np.timedelta64):\n with pytest.raises(TypeError):\n o + p\n else:\n with pytest.raises(period.IncompatibleFrequency):\n o + p\n\n def test_add_offset_nat(self):\n # freq is DateOffset\n for freq in ['A', '2A', '3A']:\n p = Period('NaT', freq=freq)\n for o in [offsets.YearEnd(2)]:\n assert p + o is tslib.NaT\n assert o + p is tslib.NaT\n\n for o in [offsets.YearBegin(2), offsets.MonthBegin(1),\n offsets.Minute(), np.timedelta64(365, 'D'),\n timedelta(365)]:\n assert p + o is tslib.NaT\n\n if isinstance(o, np.timedelta64):\n with pytest.raises(TypeError):\n o + p\n else:\n assert o + p is tslib.NaT\n\n for freq in ['M', '2M', '3M']:\n p = Period('NaT', freq=freq)\n for o in [offsets.MonthEnd(2), offsets.MonthEnd(12)]:\n assert p + o is tslib.NaT\n\n if isinstance(o, np.timedelta64):\n with pytest.raises(TypeError):\n o + p\n else:\n assert o + p is tslib.NaT\n\n for o in [offsets.YearBegin(2), offsets.MonthBegin(1),\n offsets.Minute(), np.timedelta64(365, 'D'),\n timedelta(365)]:\n assert p + o is tslib.NaT\n\n if isinstance(o, np.timedelta64):\n with pytest.raises(TypeError):\n o + p\n else:\n assert o + p is tslib.NaT\n\n # freq is Tick\n for freq in ['D', '2D', '3D']:\n p = Period('NaT', freq=freq)\n for o in [offsets.Day(5), offsets.Hour(24), np.timedelta64(2, 'D'),\n np.timedelta64(3600 * 24, 's'), timedelta(-2),\n timedelta(hours=48)]:\n assert p + o is tslib.NaT\n\n if isinstance(o, np.timedelta64):\n with pytest.raises(TypeError):\n o + p\n else:\n assert o + p is tslib.NaT\n\n for o in [offsets.YearBegin(2), offsets.MonthBegin(1),\n offsets.Minute(), np.timedelta64(4, 'h'),\n timedelta(hours=23)]:\n assert p + o is tslib.NaT\n\n if isinstance(o, np.timedelta64):\n with pytest.raises(TypeError):\n o + p\n else:\n assert o + p is tslib.NaT\n\n for freq in ['H', '2H', '3H']:\n p = Period('NaT', freq=freq)\n for o in [offsets.Day(2), offsets.Hour(3), np.timedelta64(3, 'h'),\n np.timedelta64(3600, 's'), timedelta(minutes=120),\n timedelta(days=4, minutes=180)]:\n assert p + o is tslib.NaT\n\n if not isinstance(o, np.timedelta64):\n assert o + p is tslib.NaT\n\n for o in [offsets.YearBegin(2), offsets.MonthBegin(1),\n offsets.Minute(), np.timedelta64(3200, 's'),\n timedelta(hours=23, minutes=30)]:\n assert p + o is tslib.NaT\n\n if isinstance(o, np.timedelta64):\n with pytest.raises(TypeError):\n o + p\n else:\n assert o + p is tslib.NaT\n\n def test_sub_pdnat(self):\n # GH 13071\n p = pd.Period('2011-01', freq='M')\n assert p - pd.NaT is pd.NaT\n assert pd.NaT - p is pd.NaT\n\n p = pd.Period('NaT', freq='M')\n assert p - pd.NaT is pd.NaT\n assert pd.NaT - p is pd.NaT\n\n def test_sub_offset(self):\n # freq is DateOffset\n for freq in ['A', '2A', '3A']:\n p = Period('2011', freq=freq)\n assert p - offsets.YearEnd(2) == Period('2009', freq=freq)\n\n for o in [offsets.YearBegin(2), offsets.MonthBegin(1),\n offsets.Minute(), np.timedelta64(365, 'D'),\n timedelta(365)]:\n with pytest.raises(period.IncompatibleFrequency):\n p - o\n\n for freq in ['M', '2M', '3M']:\n p = Period('2011-03', freq=freq)\n assert p - offsets.MonthEnd(2) == Period('2011-01', freq=freq)\n assert p - offsets.MonthEnd(12) == Period('2010-03', freq=freq)\n\n for o in [offsets.YearBegin(2), offsets.MonthBegin(1),\n offsets.Minute(), np.timedelta64(365, 'D'),\n timedelta(365)]:\n with pytest.raises(period.IncompatibleFrequency):\n p - o\n\n # freq is Tick\n for freq in ['D', '2D', '3D']:\n p = Period('2011-04-01', freq=freq)\n assert p - offsets.Day(5) == Period('2011-03-27', freq=freq)\n assert p - offsets.Hour(24) == Period('2011-03-31', freq=freq)\n assert p - np.timedelta64(2, 'D') == Period(\n '2011-03-30', freq=freq)\n assert p - np.timedelta64(3600 * 24, 's') == Period(\n '2011-03-31', freq=freq)\n assert p - timedelta(-2) == Period('2011-04-03', freq=freq)\n assert p - timedelta(hours=48) == Period('2011-03-30', freq=freq)\n\n for o in [offsets.YearBegin(2), offsets.MonthBegin(1),\n offsets.Minute(), np.timedelta64(4, 'h'),\n timedelta(hours=23)]:\n with pytest.raises(period.IncompatibleFrequency):\n p - o\n\n for freq in ['H', '2H', '3H']:\n p = Period('2011-04-01 09:00', freq=freq)\n assert p - offsets.Day(2) == Period('2011-03-30 09:00', freq=freq)\n assert p - offsets.Hour(3) == Period('2011-04-01 06:00', freq=freq)\n assert p - np.timedelta64(3, 'h') == Period(\n '2011-04-01 06:00', freq=freq)\n assert p - np.timedelta64(3600, 's') == Period(\n '2011-04-01 08:00', freq=freq)\n assert p - timedelta(minutes=120) == Period(\n '2011-04-01 07:00', freq=freq)\n assert p - timedelta(days=4, minutes=180) == Period(\n '2011-03-28 06:00', freq=freq)\n\n for o in [offsets.YearBegin(2), offsets.MonthBegin(1),\n offsets.Minute(), np.timedelta64(3200, 's'),\n timedelta(hours=23, minutes=30)]:\n with pytest.raises(period.IncompatibleFrequency):\n p - o\n\n def test_sub_offset_nat(self):\n # freq is DateOffset\n for freq in ['A', '2A', '3A']:\n p = Period('NaT', freq=freq)\n for o in [offsets.YearEnd(2)]:\n assert p - o is tslib.NaT\n\n for o in [offsets.YearBegin(2), offsets.MonthBegin(1),\n offsets.Minute(), np.timedelta64(365, 'D'),\n timedelta(365)]:\n assert p - o is tslib.NaT\n\n for freq in ['M', '2M', '3M']:\n p = Period('NaT', freq=freq)\n for o in [offsets.MonthEnd(2), offsets.MonthEnd(12)]:\n assert p - o is tslib.NaT\n\n for o in [offsets.YearBegin(2), offsets.MonthBegin(1),\n offsets.Minute(), np.timedelta64(365, 'D'),\n timedelta(365)]:\n assert p - o is tslib.NaT\n\n # freq is Tick\n for freq in ['D', '2D', '3D']:\n p = Period('NaT', freq=freq)\n for o in [offsets.Day(5), offsets.Hour(24), np.timedelta64(2, 'D'),\n np.timedelta64(3600 * 24, 's'), timedelta(-2),\n timedelta(hours=48)]:\n assert p - o is tslib.NaT\n\n for o in [offsets.YearBegin(2), offsets.MonthBegin(1),\n offsets.Minute(), np.timedelta64(4, 'h'),\n timedelta(hours=23)]:\n assert p - o is tslib.NaT\n\n for freq in ['H', '2H', '3H']:\n p = Period('NaT', freq=freq)\n for o in [offsets.Day(2), offsets.Hour(3), np.timedelta64(3, 'h'),\n np.timedelta64(3600, 's'), timedelta(minutes=120),\n timedelta(days=4, minutes=180)]:\n assert p - o is tslib.NaT\n\n for o in [offsets.YearBegin(2), offsets.MonthBegin(1),\n offsets.Minute(), np.timedelta64(3200, 's'),\n timedelta(hours=23, minutes=30)]:\n assert p - o is tslib.NaT\n\n def test_nat_ops(self):\n for freq in ['M', '2M', '3M']:\n p = Period('NaT', freq=freq)\n assert p + 1 is tslib.NaT\n assert 1 + p is tslib.NaT\n assert p - 1 is tslib.NaT\n assert p - Period('2011-01', freq=freq) is tslib.NaT\n assert Period('2011-01', freq=freq) - p is tslib.NaT\n\n def test_period_ops_offset(self):\n p = Period('2011-04-01', freq='D')\n result = p + offsets.Day()\n exp = pd.Period('2011-04-02', freq='D')\n assert result == exp\n\n result = p - offsets.Day(2)\n exp = pd.Period('2011-03-30', freq='D')\n assert result == exp\n\n msg = r\"Input cannot be converted to Period\\(freq=D\\)\"\n with tm.assert_raises_regex(period.IncompatibleFrequency, msg):\n p + offsets.Hour(2)\n\n with tm.assert_raises_regex(period.IncompatibleFrequency, msg):\n p - offsets.Hour(2)\n\n\ndef test_period_immutable():\n # see gh-17116\n per = pd.Period('2014Q1')\n with pytest.raises(AttributeError):\n per.ordinal = 14\n\n freq = per.freq\n with pytest.raises(AttributeError):\n per.freq = 2 * freq\n",
"# -*- coding: utf-8 -*-\n# pylint: disable-msg=E1101,W0612\n\nfrom warnings import catch_warnings\n\nimport pytest\n\nfrom pandas import Panel, Panel4D\nfrom pandas.util.testing import (assert_panel_equal,\n assert_panel4d_equal,\n assert_almost_equal)\n\nimport pandas.util.testing as tm\nimport pandas.util._test_decorators as td\nfrom .test_generic import Generic\n\n\nclass TestPanel(Generic):\n _typ = Panel\n _comparator = lambda self, x, y: assert_panel_equal(x, y, by_blocks=True)\n\n @td.skip_if_no('xarray', min_version='0.7.0')\n def test_to_xarray(self):\n from xarray import DataArray\n\n with catch_warnings(record=True):\n p = tm.makePanel()\n\n result = p.to_xarray()\n assert isinstance(result, DataArray)\n assert len(result.coords) == 3\n assert_almost_equal(list(result.coords.keys()),\n ['items', 'major_axis', 'minor_axis'])\n assert len(result.dims) == 3\n\n # idempotency\n assert_panel_equal(result.to_pandas(), p)\n\n\nclass TestPanel4D(Generic):\n _typ = Panel4D\n _comparator = lambda self, x, y: assert_panel4d_equal(x, y, by_blocks=True)\n\n def test_sample(self):\n pytest.skip(\"sample on Panel4D\")\n\n @td.skip_if_no('xarray', min_version='0.7.0')\n def test_to_xarray(self):\n from xarray import DataArray\n\n with catch_warnings(record=True):\n p = tm.makePanel4D()\n\n result = p.to_xarray()\n assert isinstance(result, DataArray)\n assert len(result.coords) == 4\n assert_almost_equal(list(result.coords.keys()),\n ['labels', 'items', 'major_axis',\n 'minor_axis'])\n assert len(result.dims) == 4\n\n # non-convertible\n pytest.raises(ValueError, lambda: result.to_pandas())\n\n\n# run all the tests, but wrap each in a warning catcher\nfor t in ['test_rename', 'test_get_numeric_data',\n 'test_get_default', 'test_nonzero',\n 'test_downcast', 'test_constructor_compound_dtypes',\n 'test_head_tail',\n 'test_size_compat', 'test_split_compat',\n 'test_unexpected_keyword',\n 'test_stat_unexpected_keyword', 'test_api_compat',\n 'test_stat_non_defaults_args',\n 'test_truncate_out_of_bounds',\n 'test_metadata_propagation', 'test_copy_and_deepcopy',\n 'test_sample']:\n\n def f():\n def tester(self):\n f = getattr(super(TestPanel, self), t)\n with catch_warnings(record=True):\n f()\n return tester\n\n setattr(TestPanel, t, f())\n\n def f():\n def tester(self):\n f = getattr(super(TestPanel4D, self), t)\n with catch_warnings(record=True):\n f()\n return tester\n\n setattr(TestPanel4D, t, f())\n"
] | [
[
"pandas.Series",
"pandas.util.testing.assert_index_equal",
"numpy.random.randint",
"pandas.IntervalIndex.from_arrays",
"pandas.util.testing.assert_numpy_array_equal",
"pandas.util.testing.assert_categorical_equal",
"pandas.compat.text_type",
"pandas.Index",
"pandas.DatetimeIndex",
"pandas.core.config.option_context",
"pandas.core.indexes.api.CategoricalIndex._create_categorical",
"pandas.Categorical.from_codes",
"pandas.Categorical",
"pandas.util.testing.makeCategoricalIndex",
"pandas.core.indexes.api.Index",
"pandas.core.indexes.api.CategoricalIndex",
"pandas.core.dtypes.dtypes.CategoricalDtype",
"numpy.array",
"pandas.CategoricalIndex",
"pandas.IntervalIndex.from_intervals",
"numpy.random.seed",
"pandas.util.testing.assert_raises_regex",
"pandas.compat.range"
],
[
"pandas.Series",
"pandas._libs.tslibs.timezones.maybe_get_tz",
"pandas.offsets.Day",
"pandas.util.testing.assert_produces_warning",
"pandas.compat.iteritems",
"pandas.util.testing.round_trip_pickle",
"pandas.offsets.Hour",
"pandas.Period._from_ordinal",
"pandas.Period.now",
"pandas.offsets.MonthBegin",
"pandas.Index",
"pandas.offsets.BDay",
"pandas.offsets.QuarterEnd",
"pandas.offsets.MonthEnd",
"pandas._libs.tslibs.timezones.dateutil_gettz",
"pandas.core.indexes.period.pnow",
"pandas.compat.numpy.np_datetime64_compat",
"pandas.offsets.YearBegin",
"numpy.timedelta64",
"pandas.offsets.YearEnd",
"pandas.util.testing.assert_raises_regex",
"pandas.offsets.BusinessDay",
"numpy.datetime64",
"pandas.offsets.Minute",
"pandas.Period",
"pandas.Timestamp",
"numpy.empty"
],
[
"pandas.util.testing.makePanel4D",
"pandas.util.testing.assert_panel4d_equal",
"pandas.util.testing.makePanel",
"pandas.util.testing.assert_panel_equal",
"pandas.util._test_decorators.skip_if_no"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
adammoody/Megatron-DeepSpeed | [
"972211163608818fe9e5ba821246f18d0a5dc264",
"972211163608818fe9e5ba821246f18d0a5dc264",
"972211163608818fe9e5ba821246f18d0a5dc264",
"972211163608818fe9e5ba821246f18d0a5dc264"
] | [
"megatron/checkpointing.py",
"megatron/data/biencoder_dataset_utils.py",
"megatron/optimizer/clip_grads.py",
"megatron/data/data_samplers.py"
] | [
"# coding=utf-8\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\"\"\"Input/output checkpointing.\"\"\"\n\nimport os\nimport random\nimport sys\nimport numpy as np\n\nimport torch\n\nfrom megatron.global_vars import codecarbon_tracker_flush\nfrom megatron import (get_args,\n mpu,\n print_rank_0,\n update_num_microbatches,\n utils)\n\n_CHECKPOINT_VERSION = None\n\ndef set_checkpoint_version(value):\n global _CHECKPOINT_VERSION\n if _CHECKPOINT_VERSION is not None:\n assert _CHECKPOINT_VERSION == value, \\\n \"checkpoint versions do not match\"\n _CHECKPOINT_VERSION = value\n\ndef get_checkpoint_version():\n global _CHECKPOINT_VERSION\n return _CHECKPOINT_VERSION\n\ndef check_checkpoint_args(checkpoint_args):\n \"\"\"Ensure fixed arguments for a model are the same for the input\n arguments and the one retrieved from checkpoint.\"\"\"\n args = get_args()\n\n def _compare(arg_name, old_arg_name=None):\n if old_arg_name is not None:\n checkpoint_value = getattr(checkpoint_args, old_arg_name)\n else:\n checkpoint_value = getattr(checkpoint_args, arg_name)\n args_value = getattr(args, arg_name)\n error_message = '{} value from checkpoint ({}) is not equal to the ' \\\n 'input argument value ({}).'.format(\n arg_name, checkpoint_value, args_value)\n assert checkpoint_value == args_value, error_message\n\n _compare('num_layers')\n _compare('hidden_size')\n _compare('num_attention_heads')\n _compare('max_position_embeddings')\n _compare('position_embedding_type')\n if args.vocab_file:\n _compare('make_vocab_size_divisible_by')\n _compare('padded_vocab_size')\n _compare('tokenizer_type')\n if get_checkpoint_version() < 3.0:\n _compare('tensor_model_parallel_size',\n old_arg_name='model_parallel_size')\n if get_checkpoint_version() >= 3.0:\n _compare('tensor_model_parallel_size')\n _compare('pipeline_model_parallel_size')\n\n\ndef ensure_directory_exists(filename):\n \"\"\"Build filename's path if it does not already exists.\"\"\"\n dirname = os.path.dirname(filename)\n if not os.path.exists(dirname):\n os.makedirs(dirname)\n\n\ndef get_checkpoint_name(checkpoints_path, iteration,\n release=False):\n \"\"\"A unified checkpoint name.\"\"\"\n if release:\n directory = 'release'\n else:\n directory = 'iter_{:07d}'.format(iteration)\n # Use both the tensor and pipeline MP rank.\n if mpu.get_pipeline_model_parallel_world_size() == 1:\n return os.path.join(checkpoints_path, directory,\n 'mp_rank_{:02d}'.format(\n mpu.get_tensor_model_parallel_rank()),\n 'model_optim_rng.pt')\n return os.path.join(checkpoints_path, directory,\n 'mp_rank_{:02d}_{:03d}'.format(\n mpu.get_tensor_model_parallel_rank(),\n mpu.get_pipeline_model_parallel_rank()),\n 'model_optim_rng.pt')\n\n\ndef get_checkpoint_tracker_filename(checkpoints_path):\n \"\"\"Tracker file rescords the latest chckpoint during\n training to restart from.\"\"\"\n return os.path.join(checkpoints_path, 'latest_checkpointed_iteration.txt')\n\n\ndef save_checkpoint(iteration, model, optimizer, lr_scheduler):\n \"\"\"Save a model checkpoint.\"\"\"\n args = get_args()\n\n # Only rank zero of the data parallel writes to the disk.\n if not args.deepspeed:\n model = utils.unwrap_model(model)\n\n print_rank_0('saving checkpoint at iteration {:7d} to {}'.format(\n iteration, args.save))\n\n if not torch.distributed.is_initialized() or mpu.get_data_parallel_rank() == 0 \\\n or args.deepspeed:\n\n # Arguments, iteration, and model.\n state_dict = {}\n state_dict['args'] = args\n state_dict['checkpoint_version'] = 3.0\n state_dict['iteration'] = iteration\n\n # DeepSpeed saves the model/optimizer/scheduler\n if not args.deepspeed:\n if len(model) == 1:\n state_dict['model'] = model[0].state_dict_for_save_checkpoint()\n else:\n for i in range(len(model)):\n mpu.set_virtual_pipeline_model_parallel_rank(i)\n state_dict['model%d' % i] = model[i].state_dict_for_save_checkpoint()\n\n # Optimizer stuff.\n if not args.no_save_optim:\n if optimizer is not None:\n state_dict['optimizer'] = optimizer.state_dict()\n if lr_scheduler is not None:\n state_dict['lr_scheduler'] = lr_scheduler.state_dict()\n\n # RNG states.\n if not args.no_save_rng:\n state_dict['random_rng_state'] = random.getstate()\n state_dict['np_rng_state'] = np.random.get_state()\n state_dict['torch_rng_state'] = torch.get_rng_state()\n state_dict['cuda_rng_state'] = torch.cuda.get_rng_state()\n state_dict['rng_tracker_states'] \\\n = mpu.get_cuda_rng_tracker().get_states()\n\n # Save.\n checkpoint_name = get_checkpoint_name(args.save, iteration)\n if not args.deepspeed:\n ensure_directory_exists(checkpoint_name)\n torch.save(state_dict, checkpoint_name)\n\n if args.deepspeed:\n # Saving is a collective communication\n checkpoint_name = get_checkpoint_name(args.save, iteration)\n # Trim off the filename and mp_rank_* directory.\n for _ in range(3):\n checkpoint_name = os.path.dirname(checkpoint_name)\n model[0].save_checkpoint(checkpoint_name, client_state=state_dict)\n\n # Wait so everyone is done (necessary)\n if torch.distributed.is_initialized():\n torch.distributed.barrier()\n\n print_rank_0(' successfully saved checkpoint at iteration {:7d} to {}'.format(\n iteration, args.save))\n\n # And update the latest iteration\n if not torch.distributed.is_initialized() or torch.distributed.get_rank() == 0:\n tracker_filename = get_checkpoint_tracker_filename(args.save)\n with open(tracker_filename, 'w') as f:\n f.write(str(iteration))\n\n # Wait so everyone is done (not necessary)\n if torch.distributed.is_initialized():\n torch.distributed.barrier()\n\n # since the code can be exited or aborted in various places we use the checkpoint saving as\n # a save saving point for the codecarbon tracker. If the program doesn't run to its normal\n # end, then only the data since the last saved checkpoint will be lost.\n codecarbon_tracker_flush()\n\ndef _transpose_first_dim(t, num_splits, num_splits_first, model):\n input_shape = t.size()\n # We use a self_attention module but the values extracted aren't\n # specific to self attention so should work for cross attention as well\n while hasattr(model, 'module'):\n model = model.module\n attention_module = model.language_model.encoder.layers[0].self_attention\n hidden_size_per_attention_head = attention_module.hidden_size_per_attention_head\n num_attention_heads_per_partition = attention_module.num_attention_heads_per_partition\n if num_splits_first:\n \"\"\"[num_splits * np * hn, h]\n -->(view) [num_splits, np, hn, h]\n -->(tranpose) [np, num_splits, hn, h]\n -->(view) [np * num_splits * hn, h] \"\"\"\n\n intermediate_shape = \\\n (num_splits, num_attention_heads_per_partition,\n hidden_size_per_attention_head) + input_shape[1:]\n\n t = t.view(*intermediate_shape)\n t = t.transpose(0, 1).contiguous()\n else:\n \"\"\"[np * hn * num_splits, h]\n -->(view) [np, hn, num_splits, h]\n -->(tranpose) [np, num_splits, hn, h]\n -->(view) [np * num_splits * hn, h] \"\"\"\n\n intermediate_shape = \\\n (num_attention_heads_per_partition,\n hidden_size_per_attention_head, num_splits) +\\\n input_shape[1:]\n\n t = t.view(*intermediate_shape)\n t = t.transpose(1, 2).contiguous()\n t = t.view(*input_shape)\n\n return t\n\ndef fix_query_key_value_ordering(model, checkpoint_version):\n \"\"\"Fix up query/key/value matrix ordering if checkpoint\n version is smaller than 2.0\n \"\"\"\n if checkpoint_version < 2.0:\n if isinstance(model, list):\n assert len(model)==1\n model = model[0]\n for name, param in model.named_parameters():\n if name.endswith(('.query_key_value.weight', '.query_key_value.bias')):\n if checkpoint_version == 0:\n fixed_param = _transpose_first_dim(param.data, 3, True, model)\n elif checkpoint_version == 1.0:\n fixed_param = _transpose_first_dim(param.data, 3, False, model)\n else:\n print_rank_0(f\"Invalid checkpoint version {checkpoint_version}.\")\n sys.exit()\n param.data.copy_(fixed_param)\n if name.endswith(('.key_value.weight', '.key_value.bias')):\n if checkpoint_version == 0:\n fixed_param = _transpose_first_dim(param.data, 2, True, model)\n elif checkpoint_version == 1.0:\n fixed_param = _transpose_first_dim(param.data, 2, False, model)\n else:\n print_rank_0(f\"Invalid checkpoint version {checkpoint_version}.\")\n sys.exit()\n param.data.copy_(fixed_param)\n print_rank_0(\" succesfully fixed query-key-values ordering for\"\n \" checkpoint version {}\".format(checkpoint_version))\n\ndef load_checkpoint(model, optimizer, lr_scheduler, load_arg='load', strict=True):\n \"\"\"Load a model checkpoint and return the iteration.\n strict (bool): whether to strictly enforce that the keys in\n :attr:`state_dict` of the checkpoint match the names of\n parameters and buffers in model.\n \"\"\"\n args = get_args()\n load_dir = getattr(args, load_arg)\n\n if args.deepspeed:\n loaded_dir, state_dict = model[0].load_checkpoint(load_dir)\n if loaded_dir is None:\n print_rank_0('WARNING: could not find the metadata file {} '.format(\n load_dir))\n print_rank_0(' will not load any checkpoints and will start from '\n 'random')\n return 0\n release = False\n else:\n model = utils.unwrap_model(model)\n\n # Read the tracker file and set the iteration.\n tracker_filename = get_checkpoint_tracker_filename(load_dir)\n\n # If no tracker file, return iretation zero.\n if not os.path.isfile(tracker_filename):\n print_rank_0('WARNING: could not find the metadata file {} '.format(\n tracker_filename))\n print_rank_0(' will not load any checkpoints and will start from '\n 'random')\n return 0\n\n # Otherwise, read the tracker file and either set the iteration or\n # mark it as a release checkpoint.\n iteration = 0\n release = False\n with open(tracker_filename, 'r') as f:\n metastring = f.read().strip()\n try:\n iteration = int(metastring)\n except ValueError:\n release = metastring == 'release'\n if not release:\n print_rank_0('ERROR: Invalid metadata file {}. Exiting'.format(\n tracker_filename))\n sys.exit()\n\n assert iteration > 0 or release, 'error parsing metadata file {}'.format(\n tracker_filename)\n\n # Checkpoint.\n checkpoint_name = get_checkpoint_name(load_dir, iteration, release)\n print_rank_0(f' loading checkpoint from {args.load} at iteration {iteration}')\n\n # Load the checkpoint.\n try:\n state_dict = torch.load(checkpoint_name, map_location='cpu')\n except ModuleNotFoundError:\n from megatron.fp16_deprecated import loss_scaler\n # For backward compatibility.\n print_rank_0(' > deserializing using the old code structure ...')\n sys.modules['fp16.loss_scaler'] = sys.modules[\n 'megatron.fp16_deprecated.loss_scaler']\n sys.modules['megatron.fp16.loss_scaler'] = sys.modules[\n 'megatron.fp16_deprecated.loss_scaler']\n state_dict = torch.load(checkpoint_name, map_location='cpu')\n sys.modules.pop('fp16.loss_scaler', None)\n sys.modules.pop('megatron.fp16.loss_scaler', None)\n except BaseException as e:\n print_rank_0('could not load the checkpoint')\n print_rank_0(e)\n sys.exit()\n\n # set checkpoint version\n set_checkpoint_version(state_dict.get('checkpoint_version', 0))\n\n # Set iteration.\n if args.finetune or release:\n iteration = 0\n else:\n try:\n iteration = state_dict['iteration']\n except KeyError:\n try: # Backward compatible with older checkpoints\n iteration = state_dict['total_iters']\n except KeyError:\n print_rank_0('A metadata file exists but unable to load '\n 'iteration from checkpoint {}, exiting'.format(\n checkpoint_name))\n sys.exit()\n\n # Check arguments.\n assert args.consumed_train_samples == 0\n assert args.consumed_valid_samples == 0\n if 'args' in state_dict:\n checkpoint_args = state_dict['args']\n check_checkpoint_args(checkpoint_args)\n args.consumed_train_samples = getattr(checkpoint_args,\n 'consumed_train_samples', 0)\n update_num_microbatches(consumed_samples=args.consumed_train_samples)\n args.consumed_valid_samples = getattr(checkpoint_args,\n 'consumed_valid_samples', 0)\n else:\n print_rank_0('could not find arguments in the checkpoint ...')\n\n # Model.\n if not args.deepspeed:\n if len(model) == 1:\n model[0].load_state_dict(state_dict['model'], strict=strict)\n else:\n for i in range(len(model)):\n mpu.set_virtual_pipeline_model_parallel_rank(i)\n model[i].load_state_dict(state_dict['model%d' % i], strict=strict)\n\n # Fix up query/key/value matrix ordering if needed\n checkpoint_version = get_checkpoint_version()\n print_rank_0(f' checkpoint version {checkpoint_version}')\n fix_query_key_value_ordering(model, checkpoint_version)\n\n # Optimizer.\n if not args.deepspeed:\n if not release and not args.finetune and not args.no_load_optim:\n try:\n if optimizer is not None:\n optimizer.load_state_dict(state_dict['optimizer'])\n if lr_scheduler is not None:\n lr_scheduler.load_state_dict(state_dict['lr_scheduler'])\n except KeyError:\n print_rank_0('Unable to load optimizer from checkpoint {}. '\n 'Specify --no-load-optim or --finetune to prevent '\n 'attempting to load the optimizer state, '\n 'exiting ...'.format(checkpoint_name))\n sys.exit()\n\n # rng states.\n if not release and not args.finetune and not args.no_load_rng:\n try:\n random.setstate(state_dict['random_rng_state'])\n np.random.set_state(state_dict['np_rng_state'])\n torch.set_rng_state(state_dict['torch_rng_state'])\n torch.cuda.set_rng_state(state_dict['cuda_rng_state'])\n # Check for empty states array\n if not state_dict['rng_tracker_states']:\n raise KeyError\n mpu.get_cuda_rng_tracker().set_states(\n state_dict['rng_tracker_states'])\n except KeyError:\n print_rank_0('Unable to load rng state from checkpoint {}. '\n 'Specify --no-load-rng or --finetune to prevent '\n 'attempting to load the rng state, '\n 'exiting ...'.format(checkpoint_name))\n sys.exit()\n\n # Some utilities want to load a checkpoint without distributed being initialized\n if torch.distributed.is_initialized():\n torch.distributed.barrier()\n\n print_rank_0(f' successfully loaded checkpoint from {args.load} '\n f'at iteration {iteration}')\n\n return iteration\n\n\ndef load_biencoder_checkpoint(model, only_query_model=False,\n only_context_model=False, custom_load_path=None):\n \"\"\"\n selectively load retrieval models for indexing/retrieving\n from saved checkpoints\n \"\"\"\n\n args = get_args()\n\n model = utils.unwrap_model(model)\n\n load_path = custom_load_path if custom_load_path is not None else args.load\n\n tracker_filename = get_checkpoint_tracker_filename(load_path)\n with open(tracker_filename, 'r') as f:\n iteration = int(f.read().strip())\n\n checkpoint_name = get_checkpoint_name(load_path, iteration, False)\n if mpu.get_data_parallel_rank() == 0:\n print('global rank {} is loading checkpoint {}'.format(\n torch.distributed.get_rank(), checkpoint_name))\n\n state_dict = torch.load(checkpoint_name, map_location='cpu')\n ret_state_dict = state_dict['model']\n\n if only_query_model:\n ret_state_dict.pop('context_model')\n if only_context_model:\n ret_state_dict.pop('query_model')\n\n assert len(model) == 1\n model[0].load_state_dict(ret_state_dict)\n torch.distributed.barrier()\n\n if mpu.get_data_parallel_rank() == 0:\n print(' successfully loaded {}'.format(checkpoint_name))\n\n return model\n",
"import os\nimport time\n\nimport numpy as np\nimport torch\n\nfrom megatron import get_args, get_tokenizer, mpu, print_rank_0\nfrom megatron.data.dataset_utils import create_masked_lm_predictions, \\\n pad_and_convert_to_numpy\nfrom megatron.data.data_samplers import MegatronPretrainingSampler\n\ndef make_attention_mask(source_block, target_block):\n \"\"\"\n Returns a 2-dimensional (2-D) attention mask\n :param source_block: 1-D array\n :param target_block: 1-D array\n \"\"\"\n mask = (target_block[None, :] >= 1) * (source_block[:, None] >= 1)\n mask = mask.astype(np.int64)\n # (source_length, target_length)\n return mask\n\ndef get_one_epoch_dataloader(dataset, micro_batch_size=None):\n \"\"\"Specifically one epoch to be used in an indexing job.\"\"\"\n args = get_args()\n\n if micro_batch_size is None:\n micro_batch_size = args.micro_batch_size\n num_workers = args.num_workers\n\n # Use megatron's sampler with consumed samples set to 0 as\n # this is only for evaluation and don't intend to resume half way.\n # Also, set the drop last to false as don't intend to remove\n # the last batch\n batch_sampler = MegatronPretrainingSampler(\n total_samples=len(dataset),\n consumed_samples=0,\n micro_batch_size=args.micro_batch_size,\n data_parallel_rank=mpu.get_data_parallel_rank(),\n data_parallel_size=mpu.get_data_parallel_world_size(),\n drop_last=False)\n\n return torch.utils.data.DataLoader(dataset,\n batch_sampler=batch_sampler,\n num_workers=num_workers,\n pin_memory=True)\n\n\ndef get_ict_batch(data_iterator):\n # Items and their type.\n keys = ['query_tokens', 'query_mask',\n 'context_tokens', 'context_mask', 'block_data']\n datatype = torch.int64\n\n # Broadcast data.\n if data_iterator is None:\n data = None\n else:\n data = next(data_iterator)\n data_b = mpu.broadcast_data(keys, data, datatype)\n\n # Unpack.\n query_tokens = data_b['query_tokens'].long()\n query_mask = data_b['query_mask'] < 0.5\n context_tokens = data_b['context_tokens'].long()\n context_mask = data_b['context_mask'] < 0.5\n block_indices = data_b['block_data'].long()\n\n return query_tokens, query_mask,\\\n context_tokens, context_mask, block_indices\n\n\ndef join_str_list(str_list):\n \"\"\"Join a list of strings, handling spaces appropriately\"\"\"\n result = \"\"\n for s in str_list:\n if s.startswith(\"##\"):\n result += s[2:]\n else:\n result += \" \" + s\n return result\n\n\nclass BlockSampleData(object):\n \"\"\"A struct for fully describing a fixed-size block of data as used in REALM\n\n :param start_idx: for first sentence of the block\n :param end_idx: for last sentence of the block (may be partially truncated in sample construction)\n :param doc_idx: the index of the document from which the block comes in the original indexed dataset\n :param block_idx: a unique integer identifier given to every block.\n \"\"\"\n def __init__(self, start_idx, end_idx, doc_idx, block_idx):\n self.start_idx = start_idx\n self.end_idx = end_idx\n self.doc_idx = doc_idx\n self.block_idx = block_idx\n\n def as_array(self):\n return np.array([self.start_idx, self.end_idx, self.doc_idx, self.block_idx]).astype(np.int64)\n\n def as_tuple(self):\n return self.start_idx, self.end_idx, self.doc_idx, self.block_idx\n\n\nclass BlockSamplesMapping(object):\n def __init__(self, mapping_array):\n # make sure that the array is compatible with BlockSampleData\n assert mapping_array.shape[1] == 4\n self.mapping_array = mapping_array\n\n def __len__(self):\n return self.mapping_array.shape[0]\n\n def __getitem__(self, idx):\n \"\"\"Get the data associated with an indexed sample.\"\"\"\n sample_data = BlockSampleData(*self.mapping_array[idx])\n return sample_data\n\n\ndef get_block_samples_mapping(block_dataset, title_dataset, data_prefix, num_epochs,\n max_num_samples, max_seq_length, seed, name, use_one_sent_docs=False):\n \"\"\"Get samples mapping for a dataset over fixed size blocks. This function also requires\n a dataset of the titles for the source documents since their lengths must be taken into account.\n\n :return: samples_mapping (BlockSamplesMapping)\n \"\"\"\n\n if not num_epochs:\n if not max_num_samples:\n raise ValueError(\"Need to specify either max_num_samples \"\n \"or num_epochs\")\n num_epochs = np.iinfo(np.int32).max - 1\n if not max_num_samples:\n max_num_samples = np.iinfo(np.int64).max - 1\n\n # Filename of the index mapping\n indexmap_filename = data_prefix\n indexmap_filename += '_{}_indexmap'.format(name)\n if num_epochs != (np.iinfo(np.int32).max - 1):\n indexmap_filename += '_{}ep'.format(num_epochs)\n if max_num_samples != (np.iinfo(np.int64).max - 1):\n indexmap_filename += '_{}mns'.format(max_num_samples)\n indexmap_filename += '_{}msl'.format(max_seq_length)\n indexmap_filename += '_{}s'.format(seed)\n if use_one_sent_docs:\n indexmap_filename += '_1sentok'\n indexmap_filename += '.npy'\n\n # Build the indexed mapping if not exist.\n if mpu.get_data_parallel_rank() == 0 and \\\n not os.path.isfile(indexmap_filename):\n print(' > WARNING: could not find index map file {}, building '\n 'the indices on rank 0 ...'.format(indexmap_filename))\n\n # Make sure the types match the helpers input types.\n assert block_dataset.doc_idx.dtype == np.int64\n assert block_dataset.sizes.dtype == np.int32\n\n # Build samples mapping\n verbose = torch.distributed.get_rank() == 0\n start_time = time.time()\n print_rank_0(' > building samples index mapping for {} ...'.format(\n name))\n\n from megatron.data import helpers\n mapping_array = helpers.build_blocks_mapping(\n block_dataset.doc_idx,\n block_dataset.sizes,\n title_dataset.sizes,\n num_epochs,\n max_num_samples,\n max_seq_length - 3, # account for added tokens\n seed,\n verbose,\n use_one_sent_docs)\n\n\n print_rank_0(' > done building samples index mapping')\n np.save(indexmap_filename, mapping_array, allow_pickle=True)\n print_rank_0(' > saved the index mapping in {}'.format(\n indexmap_filename))\n # Make sure all the ranks have built the mapping\n print_rank_0(' > elapsed time to build and save samples mapping '\n '(seconds): {:4f}'.format(\n time.time() - start_time))\n\n # This should be a barrier but nccl barrier assumes\n # device_index=rank which is not the case for model\n # parallel case\n counts = torch.cuda.LongTensor([1])\n torch.distributed.all_reduce(counts, group=mpu.get_data_parallel_group())\n assert counts[0].item() == torch.distributed.get_world_size(\n group=mpu.get_data_parallel_group())\n\n # Load indexed dataset.\n print_rank_0(' > loading indexed mapping from {}'.format(\n indexmap_filename))\n start_time = time.time()\n\n mapping_array = np.load(indexmap_filename, allow_pickle=True, mmap_mode='r')\n samples_mapping = BlockSamplesMapping(mapping_array)\n\n print_rank_0(' loaded indexed file in {:3.3f} seconds'.format(\n time.time() - start_time))\n print_rank_0(' total number of samples: {}'.format(\n mapping_array.shape[0]))\n\n return samples_mapping\n",
"# coding=utf-8\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\"\"\"Gradient clipping.\"\"\"\n\nimport torch\nfrom torch._six import inf\n\nfrom apex.multi_tensor_apply import multi_tensor_applier\nimport amp_C\n\nfrom megatron import mpu\nfrom megatron.model.module import param_is_not_shared\nfrom megatron.mpu.layers import param_is_not_tensor_parallel_duplicate\n\n\ndef clip_grad_norm_fp32(parameters, max_norm, norm_type=2):\n \"\"\"Clips gradient norm of an iterable of parameters whose gradients\n are in fp32.\n\n This is adapted from torch.nn.utils.clip_grad.clip_grad_norm_ and\n added functionality to handle model parallel parameters. Note that\n the gradients are modified in place.\n\n Arguments:\n parameters (Iterable[Tensor] or Tensor): an iterable of Tensors or a\n single Tensor that will have gradients normalized\n max_norm (float or int): max norm of the gradients\n norm_type (float or int): type of the used p-norm. Can be ``'inf'`` for\n infinity norm.\n\n Returns:\n Total norm of the parameters (viewed as a single vector).\n \"\"\"\n\n if isinstance(parameters, torch.Tensor):\n parameters = [parameters]\n\n # Filter parameters based on:\n # - grad should not be none\n # - parameter should not be shared\n # - should not be a replica due to tensor model parallelism\n grads = []\n grads_for_norm = []\n for param in parameters:\n grad_not_none = param.grad is not None\n is_not_shared = param_is_not_shared(param)\n is_not_tp_duplicate = param_is_not_tensor_parallel_duplicate(param)\n grad = param.grad.detach()\n if grad_not_none:\n # Make sure the grads are in fp32\n assert param.grad.type() == 'torch.cuda.FloatTensor'\n grads.append(grad)\n if grad_not_none and is_not_shared and is_not_tp_duplicate:\n grads_for_norm.append(grad)\n\n # Norm parameters.\n max_norm = float(max_norm)\n norm_type = float(norm_type)\n total_norm = 0.0\n\n # Calculate norm.\n if norm_type == inf:\n total_norm = max(grad.abs().max() for grad in grads_for_norm)\n total_norm_cuda = torch.cuda.FloatTensor([float(total_norm)])\n # Take max across all model-parallel GPUs.\n torch.distributed.all_reduce(total_norm_cuda,\n op=torch.distributed.ReduceOp.MAX,\n group=mpu.get_model_parallel_group())\n total_norm = total_norm_cuda[0].item()\n\n else:\n if norm_type == 2.0:\n dummy_overflow_buf = torch.cuda.IntTensor([0])\n # Use apex's multi-tensor applier for efficiency reasons.\n # Multi-tensor applier takes a function and a list of list\n # and performs the operation on that list all in one kernel.\n grad_norm, _ = multi_tensor_applier(\n amp_C.multi_tensor_l2norm,\n dummy_overflow_buf,\n [grads_for_norm],\n False # no per-parameter norm\n )\n # Since we will be summing across data parallel groups,\n # we need the pow(norm-type).\n total_norm = grad_norm ** norm_type\n\n else:\n for grad in grads_for_norm:\n grad_norm = torch.norm(grad, norm_type)\n total_norm += grad_norm ** norm_type\n\n # Sum across all model-parallel GPUs.\n torch.distributed.all_reduce(total_norm,\n op=torch.distributed.ReduceOp.SUM,\n group=mpu.get_model_parallel_group())\n total_norm = total_norm.item() ** (1.0 / norm_type)\n\n # Scale.\n clip_coeff = max_norm / (total_norm + 1.0e-6)\n if clip_coeff < 1.0:\n dummy_overflow_buf = torch.cuda.IntTensor([0])\n multi_tensor_applier(amp_C.multi_tensor_scale,\n dummy_overflow_buf,\n [grads, grads],\n clip_coeff)\n\n return total_norm\n\n\ndef count_zeros_fp32(parameters):\n\n if isinstance(parameters, torch.Tensor):\n parameters = [parameters]\n\n # Filter parameters based on:\n # - grad should not be none\n # - parameter should not be shared\n # - should not be a replica due to tensor model parallelism\n total_num_zeros = 0.0\n for param in parameters:\n grad_not_none = param.grad is not None\n is_not_shared = param_is_not_shared(param)\n is_not_tp_duplicate = param_is_not_tensor_parallel_duplicate(param)\n if grad_not_none and is_not_shared and is_not_tp_duplicate:\n grad = param.grad.detach()\n num_zeros = grad.numel() - torch.count_nonzero(grad)\n total_num_zeros = num_zeros + total_num_zeros\n\n # Sum across all model-parallel GPUs.\n torch.distributed.all_reduce(total_num_zeros,\n op=torch.distributed.ReduceOp.SUM,\n group=mpu.get_model_parallel_group())\n total_num_zeros = total_num_zeros.item()\n\n return total_num_zeros\n",
"# coding=utf-8\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\"\"\"Dataloaders.\"\"\"\n\n\nimport torch\nimport random\nfrom megatron import get_args\nfrom megatron import mpu\n\n\ndef build_pretraining_data_loader(dataset, consumed_samples):\n \"\"\"Buld dataloader given an input dataset.\"\"\"\n\n if dataset is None:\n return None\n args = get_args()\n\n # Megatron sampler\n if args.dataloader_type == 'single':\n batch_sampler = MegatronPretrainingSampler(\n total_samples=len(dataset),\n consumed_samples=consumed_samples,\n micro_batch_size=args.micro_batch_size,\n data_parallel_rank=mpu.get_data_parallel_rank(),\n data_parallel_size=mpu.get_data_parallel_world_size())\n elif args.dataloader_type == 'cyclic':\n batch_sampler = MegatronPretrainingRandomSampler(\n total_samples=len(dataset),\n consumed_samples=consumed_samples,\n micro_batch_size=args.micro_batch_size,\n data_parallel_rank=mpu.get_data_parallel_rank(),\n data_parallel_size=mpu.get_data_parallel_world_size())\n else:\n raise Exception('{} dataloader type is not supported.'.format(\n args.dataloader_type))\n\n # Torch dataloader.\n return torch.utils.data.DataLoader(dataset,\n batch_sampler=batch_sampler,\n num_workers=args.num_workers,\n pin_memory=True)\n\nclass MegatronPretrainingSampler:\n\n def __init__(self, total_samples, consumed_samples, micro_batch_size,\n data_parallel_rank, data_parallel_size, drop_last=True):\n # Keep a copy of input params for later use.\n self.total_samples = total_samples\n self.consumed_samples = consumed_samples\n self.micro_batch_size = micro_batch_size\n self.data_parallel_rank = data_parallel_rank\n self.micro_batch_times_data_parallel_size = \\\n self.micro_batch_size * data_parallel_size\n self.drop_last = drop_last\n\n # Sanity checks.\n assert self.total_samples > 0, \\\n 'no sample to consume: {}'.format(self.total_samples)\n assert self.consumed_samples < self.total_samples, \\\n 'no samples left to consume: {}, {}'.format(self.consumed_samples,\n self.total_samples)\n assert self.micro_batch_size > 0\n assert data_parallel_size > 0\n assert self.data_parallel_rank < data_parallel_size, \\\n 'data_parallel_rank should be smaller than data size: {}, ' \\\n '{}'.format(self.data_parallel_rank, data_parallel_size)\n\n def __len__(self):\n return self.total_samples\n\n def get_start_end_idx(self):\n start_idx = self.data_parallel_rank * self.micro_batch_size\n end_idx = start_idx + self.micro_batch_size\n return start_idx, end_idx\n\n def __iter__(self):\n batch = []\n # Last batch will be dropped if drop_last is not set False\n for idx in range(self.consumed_samples, self.total_samples):\n batch.append(idx)\n if len(batch) == self.micro_batch_times_data_parallel_size:\n start_idx, end_idx = self.get_start_end_idx()\n yield batch[start_idx:end_idx]\n batch = []\n\n # Check the last partial batch and see drop_last is set\n if len(batch) > 0 and not self.drop_last:\n start_idx, end_idx = self.get_start_end_idx()\n yield batch[start_idx:end_idx]\n\n\nclass MegatronPretrainingRandomSampler:\n\n def __init__(self, total_samples, consumed_samples, micro_batch_size,\n data_parallel_rank, data_parallel_size):\n # Keep a copy of input params for later use.\n self.total_samples = total_samples\n self.consumed_samples = consumed_samples\n self.micro_batch_size = micro_batch_size\n self.data_parallel_rank = data_parallel_rank\n self.data_parallel_size = data_parallel_size\n self.micro_batch_times_data_parallel_size = \\\n self.micro_batch_size * data_parallel_size\n self.last_batch_size = \\\n self.total_samples % self.micro_batch_times_data_parallel_size\n\n # Sanity checks.\n assert self.total_samples > 0, \\\n 'no sample to consume: {}'.format(self.total_samples)\n assert self.micro_batch_size > 0\n assert data_parallel_size > 0\n assert self.data_parallel_rank < data_parallel_size, \\\n 'data_parallel_rank should be smaller than data size: {}, ' \\\n '{}'.format(self.data_parallel_rank, data_parallel_size)\n\n def __len__(self):\n return self.total_samples\n\n def __iter__(self):\n active_total_samples = self.total_samples - self.last_batch_size\n self.epoch = self.consumed_samples // active_total_samples\n current_epoch_samples = self.consumed_samples % active_total_samples\n assert current_epoch_samples % self.micro_batch_times_data_parallel_size == 0\n\n # data sharding and random sampling\n bucket_size = (self.total_samples // self.micro_batch_times_data_parallel_size) \\\n * self.micro_batch_size\n bucket_offset = current_epoch_samples // self.data_parallel_size\n start_idx = self.data_parallel_rank * bucket_size\n \n g = torch.Generator()\n g.manual_seed(self.epoch)\n random_idx = torch.randperm(bucket_size, generator=g).tolist()\n idx_range = [start_idx + x for x in random_idx[bucket_offset:]]\n\n batch = []\n # Last batch if not complete will be dropped.\n for idx in idx_range:\n batch.append(idx)\n if len(batch) == self.micro_batch_size:\n self.consumed_samples += self.micro_batch_times_data_parallel_size\n yield batch\n batch = []\n"
] | [
[
"torch.set_rng_state",
"numpy.random.get_state",
"torch.load",
"torch.distributed.get_rank",
"torch.distributed.is_initialized",
"torch.distributed.barrier",
"torch.get_rng_state",
"numpy.random.set_state",
"torch.cuda.get_rng_state",
"torch.cuda.set_rng_state",
"torch.save"
],
[
"torch.distributed.get_rank",
"torch.utils.data.DataLoader",
"torch.cuda.LongTensor",
"numpy.save",
"numpy.iinfo",
"numpy.load",
"numpy.array"
],
[
"torch.norm",
"torch.cuda.IntTensor",
"torch.count_nonzero"
],
[
"torch.randperm",
"torch.Generator",
"torch.utils.data.DataLoader"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
tycallen/fast-reid | [
"66683fa95bc7d7222659e8db3ac04e5b8e366190",
"66683fa95bc7d7222659e8db3ac04e5b8e366190"
] | [
"fastreid/layers/cos_softmax.py",
"tools/deploy/onnx_export.py"
] | [
"# encoding: utf-8\n\"\"\"\n@author: xingyu liao\n@contact: [email protected]\n\"\"\"\n\nimport torch\nfrom torch import nn\nimport torch.nn.functional as F\nfrom torch.nn import Parameter\n\n\nclass CosSoftmax(nn.Module):\n r\"\"\"Implement of large margin cosine distance:\n Args:\n in_feat: size of each input sample\n num_classes: size of each output sample\n \"\"\"\n\n def __init__(self, cfg, in_feat, num_classes):\n super().__init__()\n self.in_features = in_feat\n self._num_classes = num_classes\n self.s = cfg.MODEL.HEADS.SCALE\n self.m = cfg.MODEL.HEADS.MARGIN\n self.weight = Parameter(torch.Tensor(num_classes, in_feat))\n nn.init.xavier_uniform_(self.weight)\n\n def forward(self, features, targets):\n # --------------------------- cos(theta) & phi(theta) ---------------------------\n cosine = F.linear(F.normalize(features), F.normalize(self.weight))\n phi = cosine - self.m\n # --------------------------- convert label to one-hot ---------------------------\n targets = F.one_hot(targets, num_classes=self._num_classes)\n output = (targets * phi) + ((1.0 - targets) * cosine)\n output *= self.s\n\n return output\n\n def extra_repr(self):\n return 'in_features={}, num_classes={}, scale={}, margin={}'.format(\n self.in_feat, self._num_classes, self.s, self.m\n )\n",
"# encoding: utf-8\n\"\"\"\n@author: xingyu liao\n@contact: [email protected]\n\"\"\"\n\nimport os\nimport argparse\nimport io\nimport sys\n\nimport onnx\nimport onnxoptimizer\nimport torch\nfrom onnxsim import simplify\nfrom torch.onnx import OperatorExportTypes\n\nsys.path.append('../../')\n\nfrom fastreid.config import get_cfg\nfrom fastreid.modeling.meta_arch import build_model\nfrom fastreid.utils.file_io import PathManager\nfrom fastreid.utils.checkpoint import Checkpointer\nfrom fastreid.utils.logger import setup_logger\n\n# import some modules added in project like this below\n# sys.path.append('../../projects/FastDistill')\n# from fastdistill import *\n\nlogger = setup_logger(name='onnx_export')\n\n\ndef setup_cfg(args):\n cfg = get_cfg()\n cfg.merge_from_file(args.config_file)\n cfg.merge_from_list(args.opts)\n cfg.freeze()\n return cfg\n\n\ndef get_parser():\n parser = argparse.ArgumentParser(description=\"Convert Pytorch to ONNX model\")\n\n parser.add_argument(\n \"--config-file\",\n metavar=\"FILE\",\n help=\"path to config file\",\n )\n parser.add_argument(\n \"--name\",\n default=\"baseline\",\n help=\"name for converted model\"\n )\n parser.add_argument(\n \"--output\",\n default='onnx_model',\n help='path to save converted onnx model'\n )\n parser.add_argument(\n '--batch-size',\n default=1,\n type=int,\n help=\"the maximum batch size of onnx runtime\"\n )\n parser.add_argument(\n \"--opts\",\n help=\"Modify config options using the command-line 'KEY VALUE' pairs\",\n default=[],\n nargs=argparse.REMAINDER,\n )\n return parser\n\n\ndef remove_initializer_from_input(model):\n if model.ir_version < 4:\n print(\n 'Model with ir_version below 4 requires to include initilizer in graph input'\n )\n return\n\n inputs = model.graph.input\n name_to_input = {}\n for input in inputs:\n name_to_input[input.name] = input\n\n for initializer in model.graph.initializer:\n if initializer.name in name_to_input:\n inputs.remove(name_to_input[initializer.name])\n\n return model\n\n\ndef export_onnx_model(model, inputs):\n \"\"\"\n Trace and export a model to onnx format.\n Args:\n model (nn.Module):\n inputs (torch.Tensor): the model will be called by `model(*inputs)`\n Returns:\n an onnx model\n \"\"\"\n assert isinstance(model, torch.nn.Module)\n\n # make sure all modules are in eval mode, onnx may change the training state\n # of the module if the states are not consistent\n def _check_eval(module):\n assert not module.training\n\n model.apply(_check_eval)\n\n logger.info(\"Beginning ONNX file converting\")\n # Export the model to ONNX\n with torch.no_grad():\n with io.BytesIO() as f:\n torch.onnx.export(\n model,\n inputs,\n f,\n operator_export_type=OperatorExportTypes.ONNX_ATEN_FALLBACK,\n # verbose=True, # NOTE: uncomment this for debugging\n # export_params=True,\n )\n onnx_model = onnx.load_from_string(f.getvalue())\n\n logger.info(\"Completed convert of ONNX model\")\n\n # Apply ONNX's Optimization\n logger.info(\"Beginning ONNX model path optimization\")\n all_passes = onnxoptimizer.get_available_passes()\n passes = [\"extract_constant_to_initializer\", \"eliminate_unused_initializer\", \"fuse_bn_into_conv\"]\n assert all(p in all_passes for p in passes)\n onnx_model = onnxoptimizer.optimize(onnx_model, passes)\n logger.info(\"Completed ONNX model path optimization\")\n return onnx_model\n\n\nif __name__ == '__main__':\n args = get_parser().parse_args()\n cfg = setup_cfg(args)\n\n cfg.defrost()\n cfg.MODEL.BACKBONE.PRETRAIN = False\n if cfg.MODEL.HEADS.POOL_LAYER == 'fastavgpool':\n cfg.MODEL.HEADS.POOL_LAYER = 'avgpool'\n model = build_model(cfg)\n Checkpointer(model).load(cfg.MODEL.WEIGHTS)\n model.backbone.deploy(True)\n model.eval()\n logger.info(model)\n\n inputs = torch.randn(args.batch_size, 3, cfg.INPUT.SIZE_TEST[0], cfg.INPUT.SIZE_TEST[1])\n onnx_model = export_onnx_model(model, inputs)\n\n model_simp, check = simplify(onnx_model)\n\n model_simp = remove_initializer_from_input(model_simp)\n\n assert check, \"Simplified ONNX model could not be validated\"\n\n PathManager.mkdirs(args.output)\n\n save_path = os.path.join(args.output, args.name+'.onnx')\n onnx.save_model(model_simp, save_path)\n logger.info(\"ONNX model file has already saved to {}!\".format(save_path))\n"
] | [
[
"torch.nn.functional.one_hot",
"torch.nn.functional.normalize",
"torch.Tensor",
"torch.nn.init.xavier_uniform_"
],
[
"torch.randn",
"torch.onnx.export",
"torch.no_grad"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
JinYAnGHe/openvino_training_extensions | [
"a0b4456a3c9fe6c1b7eabc9d5eb4e74d01453dee",
"a0b4456a3c9fe6c1b7eabc9d5eb4e74d01453dee",
"a0b4456a3c9fe6c1b7eabc9d5eb4e74d01453dee"
] | [
"pytorch_toolkit/face_recognition/model/blocks/mobilenet_v2_blocks.py",
"pytorch_toolkit/face_recognition/utils/read_tfboard.py",
"pytorch_toolkit/face_recognition/model/cnn6.py"
] | [
"\"\"\"\n Copyright (c) 2018 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.nn as nn\n\nfrom model.blocks.shared_blocks import SELayer\n\n\nclass InvertedResidual(nn.Module):\n \"\"\"Implementation of the modified Inverted residual block\"\"\"\n def __init__(self, in_channels, out_channels, stride, expand_ratio, outp_size=None):\n super(InvertedResidual, self).__init__()\n self.stride = stride\n assert stride in [1, 2]\n\n self.use_res_connect = self.stride == 1 and in_channels == out_channels\n\n self.inv_block = nn.Sequential(\n nn.Conv2d(in_channels, in_channels * expand_ratio, 1, 1, 0, bias=False),\n nn.BatchNorm2d(in_channels * expand_ratio),\n nn.PReLU(),\n\n nn.Conv2d(in_channels * expand_ratio, in_channels * expand_ratio, 3, stride, 1,\n groups=in_channels * expand_ratio, bias=False),\n nn.BatchNorm2d(in_channels * expand_ratio),\n nn.PReLU(),\n\n nn.Conv2d(in_channels * expand_ratio, out_channels, 1, 1, 0, bias=False),\n nn.BatchNorm2d(out_channels),\n # SELayer(out_channels, 8, nn.PReLU, outp_size)\n )\n\n def forward(self, x):\n if self.use_res_connect:\n return x + self.inv_block(x)\n\n return self.inv_block(x)\n",
"from tensorboard.backend.event_processing import event_accumulator\n\nea=event_accumulator.EventAccumulator('../logs_landm/2019_08_04_14_38_LandNet-NoSE/events.out.tfevents.1564900704.Workstation')\nea.Reload()\n# print(ea.scalars.Keys())\n# ea1=event_accumulator.EventAccumulator('./dsm_aug/eval_0/events.out.tfevents.1562407251.Workstation')\n# ea1.Reload()\n# print(ea.scalars.Keys())\n\n# print([(i.step, i.value) for i in class_loss])\nimport matplotlib.pyplot as plt\nfig, axes = plt.subplots(3, 1)\nloss=ea.scalars.Items('Loss/train_loss')\naxes[0].plot([i.step for i in loss],[i.value for i in loss],label='loss', linewidth=1)\naxes[0].set_xlim(0)\naxes[0].set_ylim(0, 0.2)\naxes[0].set_yticks([0.02, 0.1, 0.2])\naxes[0].grid(True, linestyle='-.')\n\navg_error=ea.scalars.Items('Quality/Avg_error')\naxes[1].plot([i.step for i in avg_error],[i.value for i in avg_error],label='avg_error', linewidth=1, color='mediumblue')\naxes[1].set_xlim(0)\naxes[1].set_ylim(0, 0.4)\naxes[1].set_yticks([0.2, 0.04, 0.4])\naxes[1].grid(True, linestyle='-.')\n\nfr=ea.scalars.Items('Quality/Failure_rate')\naxes[2].plot([i.step for i in fr],[i.value for i in fr],label='failure_rate', linewidth=1, color='c')\naxes[2].set_xlim(0)\naxes[2].set_yticks([1,0.5,0.04])\naxes[2].grid(True, linestyle='-.')\naxes[0].set_ylabel(\"Loss\")\naxes[1].set_ylabel(\"NME\")\naxes[2].set_ylabel(\"Failure rate\")\naxes[2].set_xlabel(\"step\")\nplt.show()",
"import torch.nn as nn\n# import torch\nimport math\nfrom .common import ModelInterface\n\n\nclass CNN6(ModelInterface):\n \"\"\"Facial landmarks localization network\"\"\"\n def __init__(self):\n super(CNN6, self).__init__()\n self.bn_first = nn.BatchNorm2d(3)\n activation = nn.ReLU\n self.landnet = nn.Sequential(\n nn.Conv2d(3, 32, kernel_size=3, padding=1),\n activation(),\n nn.MaxPool2d(2, stride=2),\n nn.BatchNorm2d(32),\n nn.Conv2d(32, 64, kernel_size=3, padding=1),\n activation(),\n nn.MaxPool2d(2, stride=2),\n nn.BatchNorm2d(64),\n nn.Conv2d(64, 128, kernel_size=3, padding=1),\n activation(),\n nn.MaxPool2d(2, stride=2),\n nn.BatchNorm2d(128),\n nn.Conv2d(128, 256, kernel_size=3, padding=1),\n activation(),\n nn.MaxPool2d(2, stride=2),\n nn.BatchNorm2d(256),\n nn.Conv2d(256, 512, kernel_size=3, padding=1),\n activation(),\n nn.MaxPool2d(2, stride=2),\n nn.BatchNorm2d(512)\n )\n self.fc_loc = nn.Conv2d(512, 32, kernel_size=2, padding=0)\n self.init_weights()\n\n def forward(self, x):\n xs = self.landnet(self.bn_first(x))\n xs = self.fc_loc(xs)\n return xs\n\n def get_input_res(self):\n return 64, 64\n\n def set_dropout_ratio(self, ratio):\n pass\n\n def init_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 if m.weight is not None:\n m.weight.data.fill_(1)\n if m.bias is not None:\n m.bias.data.zero_()\n# def main():\n# input = torch.randint(0, 255, (2, 3, 64, 64), dtype=torch.float32)\n\n# model = CNN6()\n# out = model.forward(input)\n# print(out.shape)\n\n# main()"
] | [
[
"torch.nn.PReLU",
"torch.nn.Conv2d",
"torch.nn.BatchNorm2d"
],
[
"matplotlib.pyplot.show",
"matplotlib.pyplot.subplots"
],
[
"torch.nn.MaxPool2d",
"torch.nn.Conv2d",
"torch.nn.BatchNorm2d"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
jaipradeesh/sagemaker-python-sdk | [
"ef842108ccaa324d2be15978aa678926dd1c21ea"
] | [
"tests/unit/test_amazon_estimator.py"
] | [
"# Copyright 2017-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\"). You\n# may not use this file except in compliance with the License. A copy of\n# the License is located at\n#\n# http://aws.amazon.com/apache2.0/\n#\n# or in the \"license\" file accompanying this file. This file is\n# distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF\n# ANY KIND, either express or implied. See the License for the specific\n# language governing permissions and limitations under the License.\nfrom __future__ import absolute_import\n\nimport numpy as np\nimport pytest\nfrom mock import Mock, patch, call\n\n# Use PCA as a test implementation of AmazonAlgorithmEstimator\nfrom sagemaker.amazon.pca import PCA\nfrom sagemaker.amazon.amazon_estimator import upload_numpy_to_s3_shards, _build_shards, registry, get_image_uri\n\nCOMMON_ARGS = {'role': 'myrole', 'train_instance_count': 1, 'train_instance_type': 'ml.c4.xlarge'}\n\nREGION = \"us-west-2\"\nBUCKET_NAME = \"Some-Bucket\"\nTIMESTAMP = '2017-11-06-14:14:15.671'\n\n\[email protected]()\ndef sagemaker_session():\n boto_mock = Mock(name='boto_session', region_name=REGION)\n sms = Mock(name='sagemaker_session', boto_session=boto_mock,\n region_name=REGION, config=None, local_mode=False)\n sms.boto_region_name = REGION\n sms.default_bucket = Mock(name='default_bucket', return_value=BUCKET_NAME)\n returned_job_description = {'AlgorithmSpecification': {'TrainingInputMode': 'File',\n 'TrainingImage': registry(\"us-west-2\") + \"/pca:1\"},\n 'ModelArtifacts': {'S3ModelArtifacts': \"s3://some-bucket/model.tar.gz\"},\n 'HyperParameters':\n {'sagemaker_submit_directory': '\"s3://some/sourcedir.tar.gz\"',\n 'checkpoint_path': '\"s3://other/1508872349\"',\n 'sagemaker_program': '\"iris-dnn-classifier.py\"',\n 'sagemaker_enable_cloudwatch_metrics': 'false',\n 'sagemaker_container_log_level': '\"logging.INFO\"',\n 'sagemaker_job_name': '\"neo\"',\n 'training_steps': '100'},\n 'RoleArn': 'arn:aws:iam::366:role/IMRole',\n 'ResourceConfig':\n {'VolumeSizeInGB': 30,\n 'InstanceCount': 1,\n 'InstanceType': 'ml.c4.xlarge'},\n 'StoppingCondition': {'MaxRuntimeInSeconds': 24 * 60 * 60},\n 'TrainingJobName': 'neo',\n 'TrainingJobStatus': 'Completed',\n 'OutputDataConfig': {'KmsKeyId': '',\n 'S3OutputPath': 's3://place/output/neo'},\n 'TrainingJobOutput': {'S3TrainingJobOutput': 's3://here/output.tar.gz'}}\n sms.sagemaker_client.describe_training_job = Mock(name='describe_training_job',\n return_value=returned_job_description)\n return sms\n\n\ndef test_gov_ecr_uri():\n assert get_image_uri('us-gov-west-1', 'kmeans', 'latest') == \\\n '226302683700.dkr.ecr.us-gov-west-1.amazonaws.com/kmeans:latest'\n\n assert get_image_uri('us-iso-east-1', 'kmeans', 'latest') == \\\n '490574956308.dkr.ecr.us-iso-east-1.c2s.ic.gov/kmeans:latest'\n\n\ndef test_init(sagemaker_session):\n pca = PCA(num_components=55, sagemaker_session=sagemaker_session, **COMMON_ARGS)\n assert pca.num_components == 55\n\n\ndef test_init_all_pca_hyperparameters(sagemaker_session):\n pca = PCA(num_components=55, algorithm_mode='randomized',\n subtract_mean=True, extra_components=33, sagemaker_session=sagemaker_session,\n **COMMON_ARGS)\n assert pca.num_components == 55\n assert pca.algorithm_mode == 'randomized'\n assert pca.extra_components == 33\n\n\ndef test_init_estimator_args(sagemaker_session):\n pca = PCA(num_components=1, train_max_run=1234, sagemaker_session=sagemaker_session,\n data_location='s3://some-bucket/some-key/', **COMMON_ARGS)\n assert pca.train_instance_type == COMMON_ARGS['train_instance_type']\n assert pca.train_instance_count == COMMON_ARGS['train_instance_count']\n assert pca.role == COMMON_ARGS['role']\n assert pca.train_max_run == 1234\n assert pca.data_location == 's3://some-bucket/some-key/'\n\n\ndef test_data_location_validation(sagemaker_session):\n pca = PCA(num_components=2, sagemaker_session=sagemaker_session, **COMMON_ARGS)\n with pytest.raises(ValueError):\n pca.data_location = \"nots3://abcd/efgh\"\n\n\ndef test_data_location_does_not_call_default_bucket(sagemaker_session):\n data_location = \"s3://my-bucket/path/\"\n pca = PCA(num_components=2, sagemaker_session=sagemaker_session, data_location=data_location, **COMMON_ARGS)\n assert pca.data_location == data_location\n assert not sagemaker_session.default_bucket.called\n\n\ndef test_prepare_for_training(sagemaker_session):\n pca = PCA(num_components=55, sagemaker_session=sagemaker_session, **COMMON_ARGS)\n\n train = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 8.0], [44.0, 55.0, 66.0]]\n labels = [99, 85, 87, 2]\n records = pca.record_set(np.array(train), np.array(labels))\n\n pca._prepare_for_training(records, mini_batch_size=1)\n assert pca.feature_dim == 3\n assert pca.mini_batch_size == 1\n\n\ndef test_prepare_for_training_list(sagemaker_session):\n pca = PCA(num_components=55, sagemaker_session=sagemaker_session, **COMMON_ARGS)\n\n train = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 8.0], [44.0, 55.0, 66.0]]\n labels = [99, 85, 87, 2]\n records = [pca.record_set(np.array(train), np.array(labels))]\n\n pca._prepare_for_training(records, mini_batch_size=1)\n assert pca.feature_dim == 3\n assert pca.mini_batch_size == 1\n\n\ndef test_prepare_for_training_list_no_train_channel(sagemaker_session):\n pca = PCA(num_components=55, sagemaker_session=sagemaker_session, **COMMON_ARGS)\n\n train = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 8.0], [44.0, 55.0, 66.0]]\n labels = [99, 85, 87, 2]\n records = [pca.record_set(np.array(train), np.array(labels), 'test')]\n\n with pytest.raises(ValueError) as ex:\n pca._prepare_for_training(records, mini_batch_size=1)\n\n assert 'Must provide train channel.' in str(ex)\n\n\n@patch('time.strftime', return_value=TIMESTAMP)\ndef test_fit_ndarray(time, sagemaker_session):\n mock_s3 = Mock()\n mock_object = Mock()\n mock_s3.Object = Mock(return_value=mock_object)\n sagemaker_session.boto_session.resource = Mock(return_value=mock_s3)\n kwargs = dict(COMMON_ARGS)\n kwargs['train_instance_count'] = 3\n pca = PCA(num_components=55, sagemaker_session=sagemaker_session,\n data_location='s3://{}/key-prefix/'.format(BUCKET_NAME), **kwargs)\n train = [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 8.0], [44.0, 55.0, 66.0]]\n labels = [99, 85, 87, 2]\n pca.fit(pca.record_set(np.array(train), np.array(labels)))\n mock_s3.Object.assert_any_call(\n BUCKET_NAME, 'key-prefix/PCA-2017-11-06-14:14:15.671/matrix_0.pbr'.format(TIMESTAMP))\n mock_s3.Object.assert_any_call(\n BUCKET_NAME, 'key-prefix/PCA-2017-11-06-14:14:15.671/matrix_1.pbr'.format(TIMESTAMP))\n mock_s3.Object.assert_any_call(\n BUCKET_NAME, 'key-prefix/PCA-2017-11-06-14:14:15.671/matrix_2.pbr'.format(TIMESTAMP))\n mock_s3.Object.assert_any_call(\n BUCKET_NAME, 'key-prefix/PCA-2017-11-06-14:14:15.671/.amazon.manifest'.format(TIMESTAMP))\n\n assert mock_object.put.call_count == 4\n\n\ndef test_build_shards():\n array = np.array([1, 2, 3, 4])\n shards = _build_shards(4, array)\n assert shards == [np.array([1]), np.array([2]), np.array([3]), np.array([4])]\n\n shards = _build_shards(3, array)\n for out, expected in zip(shards, map(np.array, [[1], [2], [3, 4]])):\n assert np.array_equal(out, expected)\n\n with pytest.raises(ValueError):\n shards = _build_shards(5, array)\n\n\ndef test_upload_numpy_to_s3_shards():\n mock_s3 = Mock()\n mock_object = Mock()\n mock_s3.Object = Mock(return_value=mock_object)\n array = np.array([[j for j in range(10)] for i in range(10)])\n labels = np.array([i for i in range(10)])\n upload_numpy_to_s3_shards(3, mock_s3, BUCKET_NAME, \"key-prefix\", array, labels)\n mock_s3.Object.assert_has_calls([call(BUCKET_NAME, 'key-prefix/matrix_0.pbr')])\n mock_s3.Object.assert_has_calls([call(BUCKET_NAME, 'key-prefix/matrix_1.pbr')])\n mock_s3.Object.assert_has_calls([call(BUCKET_NAME, 'key-prefix/matrix_2.pbr')])\n"
] | [
[
"numpy.array",
"numpy.array_equal"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
UmaTaru/run | [
"be29e4d41a4de3dee27cd6796801bfe51382d294",
"be29e4d41a4de3dee27cd6796801bfe51382d294",
"be29e4d41a4de3dee27cd6796801bfe51382d294",
"be29e4d41a4de3dee27cd6796801bfe51382d294",
"be29e4d41a4de3dee27cd6796801bfe51382d294",
"be29e4d41a4de3dee27cd6796801bfe51382d294",
"be29e4d41a4de3dee27cd6796801bfe51382d294"
] | [
"torchMoji/torchmoji/model_def.py",
"torch/autograd/_functions/blas.py",
"torch/legacy/nn/BCECriterion.py",
"ParlAI/parlai/agents/fairseq/fairseq.py",
"ParlAI/parlai/mturk/tasks/personachat/personachat_chat/worlds.py",
"ParlAI/parlai/core/image_featurizers.py",
"torch/tensor.py"
] | [
"# -*- coding: utf-8 -*-\n\"\"\" Model definition functions and weight loading.\n\"\"\"\n\nfrom __future__ import print_function, division, unicode_literals\n\nfrom os.path import exists\n\nimport torch\nimport torch.nn as nn\nfrom torch.autograd import Variable\nfrom torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence, PackedSequence\n\nfrom torchMoji.torchmoji.lstm import LSTMHardSigmoid\nfrom torchMoji.torchmoji.attlayer import Attention\nfrom torchMoji.torchmoji.global_variables import NB_TOKENS, NB_EMOJI_CLASSES\n\n\ndef torchmoji_feature_encoding(weight_path, return_attention=False):\n \"\"\" Loads the pretrained torchMoji model for extracting features\n from the penultimate feature layer. In this way, it transforms\n the text into its emotional encoding.\n\n # Arguments:\n weight_path: Path to model weights to be loaded.\n return_attention: If true, output will include weight of each input token\n used for the prediction\n\n # Returns:\n Pretrained model for encoding text into feature vectors.\n \"\"\"\n\n model = TorchMoji(nb_classes=None,\n nb_tokens=NB_TOKENS,\n feature_output=True,\n return_attention=return_attention)\n load_specific_weights(model, weight_path, exclude_names=['output_layer'])\n return model\n\n\ndef torchmoji_emojis(weight_path, return_attention=False):\n \"\"\" Loads the pretrained torchMoji model for extracting features\n from the penultimate feature layer. In this way, it transforms\n the text into its emotional encoding.\n\n # Arguments:\n weight_path: Path to model weights to be loaded.\n return_attention: If true, output will include weight of each input token\n used for the prediction\n\n # Returns:\n Pretrained model for encoding text into feature vectors.\n \"\"\"\n\n model = TorchMoji(nb_classes=NB_EMOJI_CLASSES,\n nb_tokens=NB_TOKENS,\n return_attention=return_attention)\n model.load_state_dict(torch.load(weight_path))\n return model\n\n\ndef torchmoji_transfer(nb_classes, weight_path=None, extend_embedding=0,\n embed_dropout_rate=0.1, final_dropout_rate=0.5):\n \"\"\" Loads the pretrained torchMoji model for finetuning/transfer learning.\n Does not load weights for the softmax layer.\n\n Note that if you are planning to use class average F1 for evaluation,\n nb_classes should be set to 2 instead of the actual number of classes\n in the dataset, since binary classification will be performed on each\n class individually.\n\n Note that for the 'new' method, weight_path should be left as None.\n\n # Arguments:\n nb_classes: Number of classes in the dataset.\n weight_path: Path to model weights to be loaded.\n extend_embedding: Number of tokens that have been added to the\n vocabulary on top of NB_TOKENS. If this number is larger than 0,\n the embedding layer's dimensions are adjusted accordingly, with the\n additional weights being set to random values.\n embed_dropout_rate: Dropout rate for the embedding layer.\n final_dropout_rate: Dropout rate for the final Softmax layer.\n\n # Returns:\n Model with the given parameters.\n \"\"\"\n\n model = TorchMoji(nb_classes=nb_classes,\n nb_tokens=NB_TOKENS + extend_embedding,\n embed_dropout_rate=embed_dropout_rate,\n final_dropout_rate=final_dropout_rate,\n output_logits=True)\n if weight_path is not None:\n load_specific_weights(model, weight_path,\n exclude_names=['output_layer'],\n extend_embedding=extend_embedding)\n return model\n\n\nclass TorchMoji(nn.Module):\n def __init__(self, nb_classes, nb_tokens, feature_output=False, output_logits=False,\n embed_dropout_rate=0, final_dropout_rate=0, return_attention=False):\n \"\"\"\n torchMoji model.\n IMPORTANT: The model is loaded in evaluation mode by default (self.eval())\n\n # Arguments:\n nb_classes: Number of classes in the dataset.\n nb_tokens: Number of tokens in the dataset (i.e. vocabulary size).\n feature_output: If True the model returns the penultimate\n feature vector rather than Softmax probabilities\n (defaults to False).\n output_logits: If True the model returns logits rather than probabilities\n (defaults to False).\n embed_dropout_rate: Dropout rate for the embedding layer.\n final_dropout_rate: Dropout rate for the final Softmax layer.\n return_attention: If True the model also returns attention weights over the sentence\n (defaults to False).\n \"\"\"\n super(TorchMoji, self).__init__()\n\n embedding_dim = 256\n hidden_size = 512\n attention_size = 4 * hidden_size + embedding_dim\n\n self.feature_output = feature_output\n self.embed_dropout_rate = embed_dropout_rate\n self.final_dropout_rate = final_dropout_rate\n self.return_attention = return_attention\n self.hidden_size = hidden_size\n self.output_logits = output_logits\n self.nb_classes = nb_classes\n\n self.add_module('embed', nn.Embedding(nb_tokens, embedding_dim))\n # dropout2D: embedding channels are dropped out instead of words\n # many exampels in the datasets contain few words that losing one or more words can alter the emotions completely\n self.add_module('embed_dropout', nn.Dropout2d(embed_dropout_rate))\n self.add_module('lstm_0', LSTMHardSigmoid(embedding_dim, hidden_size, batch_first=True, bidirectional=True))\n self.add_module('lstm_1', LSTMHardSigmoid(hidden_size*2, hidden_size, batch_first=True, bidirectional=True))\n self.add_module('attention_layer', Attention(attention_size=attention_size, return_attention=return_attention))\n if not feature_output:\n self.add_module('final_dropout', nn.Dropout(final_dropout_rate))\n if output_logits:\n self.add_module('output_layer', nn.Sequential(nn.Linear(attention_size, nb_classes if self.nb_classes > 2 else 1)))\n else:\n self.add_module('output_layer', nn.Sequential(nn.Linear(attention_size, nb_classes if self.nb_classes > 2 else 1),\n nn.Softmax() if self.nb_classes > 2 else nn.Sigmoid()))\n self.init_weights()\n # Put model in evaluation mode by default\n self.eval()\n\n def init_weights(self):\n \"\"\"\n Here we reproduce Keras default initialization weights for consistency with Keras version\n \"\"\"\n ih = (param.data for name, param in self.named_parameters() if 'weight_ih' in name)\n hh = (param.data for name, param in self.named_parameters() if 'weight_hh' in name)\n b = (param.data for name, param in self.named_parameters() if 'bias' in name)\n nn.init.uniform(self.embed.weight.data, a=-0.5, b=0.5)\n for t in ih:\n nn.init.xavier_uniform(t)\n for t in hh:\n nn.init.orthogonal(t)\n for t in b:\n nn.init.constant(t, 0)\n if not self.feature_output:\n nn.init.xavier_uniform(self.output_layer[0].weight.data)\n\n def forward(self, input_seqs):\n \"\"\" Forward pass.\n\n # Arguments:\n input_seqs: Can be one of Numpy array, Torch.LongTensor, Torch.Variable, Torch.PackedSequence.\n\n # Return:\n Same format as input format (except for PackedSequence returned as Variable).\n \"\"\"\n # Check if we have Torch.LongTensor inputs or not Torch.Variable (assume Numpy array in this case), take note to return same format\n return_numpy = False\n return_tensor = False\n if isinstance(input_seqs, (torch.LongTensor, torch.cuda.LongTensor)):\n input_seqs = Variable(input_seqs)\n return_tensor = True\n elif not isinstance(input_seqs, Variable):\n input_seqs = Variable(torch.from_numpy(input_seqs.astype('int64')).long())\n return_numpy = True\n\n # If we don't have a packed inputs, let's pack it\n reorder_output = False\n if not isinstance(input_seqs, PackedSequence):\n ho = self.lstm_0.weight_hh_l0.data.new(2, input_seqs.size()[0], self.hidden_size).zero_()\n co = self.lstm_0.weight_hh_l0.data.new(2, input_seqs.size()[0], self.hidden_size).zero_()\n\n # Reorder batch by sequence length\n input_lengths = torch.LongTensor([torch.max(input_seqs[i, :].data.nonzero()) + 1 for i in range(input_seqs.size()[0])])\n input_lengths, perm_idx = input_lengths.sort(0, descending=True)\n input_seqs = input_seqs[perm_idx][:, :input_lengths.max()]\n\n # Pack sequence and work on data tensor to reduce embeddings/dropout computations\n packed_input = pack_padded_sequence(input_seqs, input_lengths.cpu().numpy(), batch_first=True)\n reorder_output = True\n else:\n ho = self.lstm_0.weight_hh_l0.data.data.new(2, input_seqs.size()[0], self.hidden_size).zero_()\n co = self.lstm_0.weight_hh_l0.data.data.new(2, input_seqs.size()[0], self.hidden_size).zero_()\n input_lengths = input_seqs.batch_sizes\n packed_input = input_seqs\n\n hidden = (Variable(ho, requires_grad=False), Variable(co, requires_grad=False))\n\n # Embed with an activation function to bound the values of the embeddings\n x = self.embed(packed_input.data)\n x = nn.Tanh()(x)\n\n # pyTorch 2D dropout2d operate on axis 1 which is fine for us\n x = self.embed_dropout(x)\n\n # Update packed sequence data for RNN\n packed_input = PackedSequence(x, packed_input.batch_sizes)\n\n # skip-connection from embedding to output eases gradient-flow and allows access to lower-level features\n # ordering of the way the merge is done is important for consistency with the pretrained model\n lstm_0_output, _ = self.lstm_0(packed_input, hidden)\n lstm_1_output, _ = self.lstm_1(lstm_0_output, hidden)\n\n # Update packed sequence data for attention layer\n packed_input = PackedSequence(torch.cat((lstm_1_output.data,\n lstm_0_output.data,\n packed_input.data), dim=1),\n packed_input.batch_sizes)\n\n input_seqs, _ = pad_packed_sequence(packed_input, batch_first=True)\n\n x, att_weights = self.attention_layer(input_seqs, input_lengths)\n\n # output class probabilities or penultimate feature vector\n if not self.feature_output:\n x = self.final_dropout(x)\n outputs = self.output_layer(x)\n else:\n outputs = x\n\n # Reorder output if needed\n if reorder_output:\n reorered = Variable(outputs.data.new(outputs.size()))\n reorered[perm_idx] = outputs\n outputs = reorered\n\n # Adapt return format if needed\n if return_tensor:\n outputs = outputs.data\n if return_numpy:\n outputs = outputs.data.numpy()\n\n if self.return_attention:\n return outputs, att_weights\n else:\n return outputs\n\n\ndef load_specific_weights(model, weight_path, exclude_names=[], extend_embedding=0, verbose=True):\n \"\"\" Loads model weights from the given file path, excluding any\n given layers.\n\n # Arguments:\n model: Model whose weights should be loaded.\n weight_path: Path to file containing model weights.\n exclude_names: List of layer names whose weights should not be loaded.\n extend_embedding: Number of new words being added to vocabulary.\n verbose: Verbosity flag.\n\n # Raises:\n ValueError if the file at weight_path does not exist.\n \"\"\"\n if not exists(weight_path):\n raise ValueError('ERROR (load_weights): The weights file at {} does '\n 'not exist. Refer to the README for instructions.'\n .format(weight_path))\n\n if extend_embedding and 'embed' in exclude_names:\n raise ValueError('ERROR (load_weights): Cannot extend a vocabulary '\n 'without loading the embedding weights.')\n\n # Copy only weights from the temporary model that are wanted\n # for the specific task (e.g. the Softmax is often ignored)\n weights = torch.load(weight_path)\n for key, weight in weights.items():\n if any(excluded in key for excluded in exclude_names):\n if verbose:\n print('Ignoring weights for {}'.format(key))\n continue\n\n try:\n model_w = model.state_dict()[key]\n except KeyError:\n raise KeyError(\"Weights had parameters {},\".format(key)\n + \" but could not find this parameters in model.\")\n\n if verbose:\n print('Loading weights for {}'.format(key))\n\n # extend embedding layer to allow new randomly initialized words\n # if requested. Otherwise, just load the weights for the layer.\n if 'embed' in key and extend_embedding > 0:\n weight = torch.cat((weight, model_w[NB_TOKENS:, :]), dim=0)\n if verbose:\n print('Extended vocabulary for embedding layer ' +\n 'from {} to {} tokens.'.format(\n NB_TOKENS, NB_TOKENS + extend_embedding))\n try:\n model_w.copy_(weight)\n except:\n print('While copying the weigths named {}, whose dimensions in the model are'\n ' {} and whose dimensions in the saved file are {}, ...'.format(\n key, model_w.size(), weight.size()))\n raise\n",
"import torch\n\nfrom ..function import Function, InplaceFunction\n\n\n# TODO: no need to save all args if the grad w.r.t. some of them is not needed\ndef _get_output(ctx, arg, inplace=False):\n if inplace:\n ctx.mark_dirty(arg)\n return arg\n else:\n return arg.new().resize_as_(arg)\n\n\nclass Addmm(InplaceFunction):\n\n @staticmethod\n def forward(ctx, add_matrix, matrix1, matrix2, alpha=1, beta=1, inplace=False):\n ctx.alpha = alpha\n ctx.beta = beta\n ctx.save_for_backward(matrix1, matrix2)\n output = _get_output(ctx, add_matrix, inplace=inplace)\n return torch.addmm(alpha, add_matrix, beta,\n matrix1, matrix2, out=output)\n\n @staticmethod\n def backward(ctx, grad_output):\n matrix1, matrix2 = ctx.saved_variables\n grad_add_matrix = grad_matrix1 = grad_matrix2 = None\n\n if ctx.needs_input_grad[0]:\n grad_add_matrix = grad_output\n if ctx.alpha != 1:\n grad_add_matrix = grad_add_matrix.mul(ctx.alpha)\n\n if ctx.needs_input_grad[1]:\n grad_matrix1 = torch.mm(grad_output, matrix2.t())\n if ctx.beta != 1:\n grad_matrix1 *= ctx.beta\n\n if ctx.needs_input_grad[2]:\n grad_matrix2 = torch.mm(matrix1.t(), grad_output)\n if ctx.beta != 1:\n grad_matrix2 *= ctx.beta\n\n return grad_add_matrix, grad_matrix1, grad_matrix2, None, None, None\n\n\nclass Addbmm(InplaceFunction):\n\n @staticmethod\n def forward(ctx, add_matrix, batch1, batch2, alpha=1, beta=1, inplace=False):\n ctx.alpha = alpha\n ctx.beta = beta\n ctx.save_for_backward(batch1, batch2)\n output = _get_output(ctx, add_matrix, inplace=inplace)\n return torch.addbmm(alpha, add_matrix, beta,\n batch1, batch2, out=output)\n\n @staticmethod\n def backward(ctx, grad_output):\n batch1, batch2 = ctx.saved_variables\n grad_add_matrix = grad_batch1 = grad_batch2 = None\n\n if ctx.needs_input_grad[0]:\n grad_add_matrix = grad_output\n if ctx.alpha != 1:\n grad_add_matrix = grad_add_matrix.mul(ctx.alpha)\n\n if any(ctx.needs_input_grad[1:]):\n batch_grad_output = (grad_output\n .unsqueeze(0)\n .expand(batch1.size(0), batch1.size(1), batch2.size(2)))\n\n if ctx.needs_input_grad[1]:\n grad_batch1 = torch.bmm(batch_grad_output, batch2.transpose(1, 2))\n if ctx.beta != 1:\n grad_batch1 *= ctx.beta\n\n if ctx.needs_input_grad[2]:\n grad_batch2 = torch.bmm(batch1.transpose(1, 2), batch_grad_output)\n if ctx.beta != 1:\n grad_batch2 *= ctx.beta\n\n return grad_add_matrix, grad_batch1, grad_batch2, None, None, None\n\n\nclass Baddbmm(InplaceFunction):\n\n @staticmethod\n def forward(ctx, add_batch, batch1, batch2, alpha=1, beta=1, inplace=False):\n ctx.alpha = alpha\n ctx.beta = beta\n ctx.save_for_backward(batch1, batch2)\n output = _get_output(ctx, add_batch, inplace=inplace)\n return torch.baddbmm(alpha, add_batch, beta,\n batch1, batch2, out=output)\n\n @staticmethod\n def backward(ctx, grad_output):\n batch1, batch2 = ctx.saved_variables\n grad_add_batch = grad_batch1 = grad_batch2 = None\n\n if ctx.needs_input_grad[0]:\n grad_add_batch = grad_output\n if ctx.alpha != 1:\n grad_add_batch = grad_add_batch.mul(ctx.alpha)\n\n if ctx.needs_input_grad[1]:\n grad_batch1 = torch.bmm(grad_output, batch2.transpose(1, 2))\n if ctx.beta != 1:\n grad_batch1 *= ctx.beta\n\n if ctx.needs_input_grad[2]:\n grad_batch2 = torch.bmm(batch1.transpose(1, 2), grad_output)\n if ctx.beta != 1:\n grad_batch2 *= ctx.beta\n\n return grad_add_batch, grad_batch1, grad_batch2, None, None, None\n\n\nclass Addmv(InplaceFunction):\n\n @staticmethod\n def forward(ctx, add_vector, matrix, vector, alpha=1, beta=1, inplace=False):\n ctx.alpha = alpha\n ctx.beta = beta\n ctx.save_for_backward(matrix, vector)\n output = _get_output(ctx, add_vector, inplace=inplace)\n return torch.addmv(alpha, add_vector, beta,\n matrix, vector, out=output)\n\n @staticmethod\n def backward(ctx, grad_output):\n matrix, vector = ctx.saved_variables\n grad_add_vector = grad_matrix = grad_vector = None\n\n if ctx.needs_input_grad[0]:\n grad_add_vector = grad_output\n if ctx.alpha != 1:\n grad_add_vector = grad_add_vector.mul(ctx.alpha)\n\n if ctx.needs_input_grad[1]:\n grad_matrix = torch.ger(grad_output, vector)\n if ctx.beta != 1:\n grad_matrix *= ctx.beta\n\n if ctx.needs_input_grad[2]:\n grad_vector = torch.mv(matrix.t(), grad_output)\n if ctx.beta != 1:\n grad_vector *= ctx.beta\n\n return grad_add_vector, grad_matrix, grad_vector, None, None, None\n\n\nclass Addr(InplaceFunction):\n\n @staticmethod\n def forward(ctx, add_matrix, vector1, vector2, alpha=1, beta=1, inplace=False):\n ctx.alpha = alpha\n ctx.beta = beta\n ctx.save_for_backward(vector1, vector2)\n output = _get_output(ctx, add_matrix, inplace=inplace)\n return torch.addr(alpha, add_matrix, beta,\n vector1, vector2, out=output)\n\n @staticmethod\n def backward(ctx, grad_output):\n vector1, vector2 = ctx.saved_variables\n grad_add_matrix = grad_vector1 = grad_vector2 = None\n\n if ctx.needs_input_grad[0]:\n grad_add_matrix = grad_output\n if ctx.alpha != 1:\n grad_add_matrix = grad_add_matrix.mul(ctx.alpha)\n\n if ctx.needs_input_grad[1]:\n grad_vector1 = torch.mv(grad_output, vector2)\n if ctx.beta != 1:\n grad_vector1 *= ctx.beta\n\n if ctx.needs_input_grad[2]:\n # TODO: maybe it's better to do transpose + mv + transpose\n grad_vector2 = torch.mm(vector1.unsqueeze(0), grad_output).squeeze(0)\n if ctx.beta != 1:\n grad_vector2 *= ctx.beta\n\n return grad_add_matrix, grad_vector1, grad_vector2, None, None, None\n\n\nclass Dot(Function):\n\n @staticmethod\n def forward(ctx, vector1, vector2):\n ctx.save_for_backward(vector1, vector2)\n ctx.sizes = (vector1.size(), vector2.size())\n return vector1.new((vector1.dot(vector2),))\n\n @staticmethod\n def backward(ctx, grad_output):\n vector1, vector2 = ctx.saved_variables\n grad_vector1 = grad_vector2 = None\n\n if ctx.needs_input_grad[0]:\n grad_vector1 = vector2.mul(grad_output.expand(ctx.sizes[1])).view(ctx.sizes[0])\n\n if ctx.needs_input_grad[1]:\n grad_vector2 = vector1.mul(grad_output.expand(ctx.sizes[0])).view(ctx.sizes[1])\n\n return grad_vector1, grad_vector2\n",
"import torch\nfrom .Criterion import Criterion\n\n# TODO: use THNN\n\n\nclass BCECriterion(Criterion):\n eps = 1e-12\n\n def __init__(self, weights=None, sizeAverage=True):\n if weights is not None and weights.dim() != 1:\n raise ValueError(\"weights input should be 1D Tensor\")\n\n super(BCECriterion, self).__init__()\n self.sizeAverage = sizeAverage\n self.buffer = None\n self.weights = weights\n\n def updateOutput(self, input, target):\n # - log(input) * target - log(1 - input) * (1 - target)\n if input.nelement() != target.nelement():\n raise RuntimeError(\"input and target size mismatch\")\n\n if self.buffer is None:\n self.buffer = input.new()\n\n buffer = self.buffer\n weights = self.weights\n\n buffer.resize_as_(input)\n\n if weights is not None and target.dim() != 1:\n weights = self.weights.view(1, target.size(1)).expand_as(target)\n\n # log(input) * target\n torch.add(input, self.eps, out=buffer).log_()\n if weights is not None:\n buffer.mul_(weights)\n\n output = torch.dot(target, buffer)\n\n # log(1 - input) * (1 - target)\n torch.mul(input, -1, out=buffer).add_(1 + self.eps).log_()\n if weights is not None:\n buffer.mul_(weights)\n\n output = output + torch.sum(buffer)\n output = output - torch.dot(target, buffer)\n\n if self.sizeAverage:\n output = output / input.nelement()\n\n self.output = - output\n\n return self.output\n\n def updateGradInput(self, input, target):\n # - (target - input) / ( input (1 - input) )\n # The gradient is slightly incorrect:\n # It should have be divided by (input + self.eps) (1 - input + self.eps)\n # but it is divided by input (1 - input + self.eps) + self.eps\n # This modification requires less memory to be computed.\n if input.nelement() != target.nelement():\n raise RuntimeError(\"input and target size mismatch\")\n\n if self.buffer is None:\n self.buffer = input.new()\n\n buffer = self.buffer\n weights = self.weights\n gradInput = self.gradInput\n\n if weights is not None and target.dim() != 1:\n weights = self.weights.view(1, target.size(1)).expand_as(target)\n\n buffer.resize_as_(input)\n # - x ( 1 + self.eps -x ) + self.eps\n torch.add(input, -1, out=buffer).add_(-self.eps).mul_(input).add_(-self.eps)\n\n gradInput.resize_as_(input)\n # y - x\n torch.add(target, -1, input, out=gradInput)\n # - (y - x) / ( x ( 1 + self.eps -x ) + self.eps )\n gradInput.div_(buffer)\n\n if weights is not None:\n gradInput.mul_(weights)\n\n if self.sizeAverage:\n gradInput.div_(target.nelement())\n\n return gradInput\n",
"#!/usr/bin/env python3\n\n# Copyright (c) Facebook, Inc. and its affiliates.\n# This source code is licensed under the MIT license found in the\n# LICENSE file in the root directory of this source tree.\n\n\"\"\"\nParlAI has limited support for using models from\n`Fairseq <https://github.com/pytorch/fairseq>`_. Fairseq often supports more\nexperimental seq2seq architectures with fast fp16 training.\n\nFairseq models can be used for many default tasks by combining a\n``--arch`` flag. For example:\n\n`python -m parlai.scripts.train -t convai2 -m fairseq -a transformer`\n\"\"\"\n\n\nfrom parlai.core.dict import DictionaryAgent\nfrom parlai.core.utils import argsort, padded_tensor\n\ntry:\n from fairseq import models, optim, criterions\n\n # this is a hack around versioning check because fairseq doesn't\n # announce version numbers yet\n # fairseq 0.5.0 has fp16_trainer, 0.6.0 does not\n try:\n from fairseq import fp16_trainer # noqa: F401\n except ImportError:\n pass\n else:\n raise ImportError\nexcept ImportError:\n raise ImportError(\n \"Please run \\\"pip install -U 'git+https://github.com/pytorch/\"\n \"[email protected]#egg=fairseq'\\\"\"\n )\nfrom fairseq import trainer\nfrom fairseq.sequence_generator import SequenceGenerator\nfrom fairseq.sequence_scorer import SequenceScorer\nfrom fairseq import options\nfrom fairseq.tasks.fairseq_task import FairseqTask\nfrom fairseq.utils import convert_padding_direction, load_model_state\nfrom fairseq.meters import AverageMeter\n\nfrom parlai.core.torch_agent import TorchAgent, Output\nfrom parlai.core.build_data import modelzoo_path\nfrom parlai.core.utils import round_sigfigs\n\nimport argparse\nimport torch\nimport os\nimport numpy as np\nimport json\nfrom collections import defaultdict\n\n\n# If a model file is loaded, these arguments may NOT be overridden in the\n# command line:\nNON_OVERRIDABLE_ARGS = {\n 'arch',\n 'encoder_embed_dim',\n 'encoder_layers',\n 'decoder_embed_dim',\n 'decoder_layers',\n 'decoder_out_embed_dim',\n 'decoder_attention',\n}\n\n\ndef _fairseq_opt_wrapper(opt, skip_pretrained_embedding_loading=False):\n \"\"\"\n Marshalls from a dict to a argparse.Namespace object for API compatibility.\n\n Also does some necessary post-processing needed for fairseq. Optionally can\n override pretrained embedding options, which is useful if we're just loading\n a model from a checkpoint.\n\n :param opt: dict. ParlAI options passed around from everywhere.\n :param skip_pretrained_embedding_loading: bool. Don't preload word embeddings.\n :return: an argparse.Namespace object for use in fairseq-py.\n \"\"\"\n args = argparse.Namespace()\n\n # first set args according to ParlAI options\n for key in opt:\n if opt[key] is not None:\n setattr(args, key, opt[key])\n\n # at this point the user *must* have specified an arch\n if not hasattr(args, \"arch\"):\n raise ValueError(\"--arch/-a must be specified\")\n # fill in default options from the model\n models.ARCH_CONFIG_REGISTRY[args.arch](args)\n\n # post processing of args. See\n # https://github.com/pytorch/fairseq/blob/v0.5.0/fairseq/options.py#L95\n if hasattr(args, \"lr\"):\n args.lr = options.eval_str_list(args.lr, type=float)\n if hasattr(args, \"update_freq\"):\n args.update_freq = options.eval_str_list(args.update_freq, int)\n if hasattr(args, \"max_sentences_valid\"):\n args.max_sentences_valid = args.max_sentences\n if args.truncate == -1:\n # some torch agents use positional embeddings, which must have a max length\n args.truncate = 1024\n if not hasattr(args, \"max_source_positions\"):\n # fairseq uses a different name for this CLI parameter\n # Sometimes it's set in model defaults, but not for all models\n args.max_source_positions = args.truncate\n # if we don't have source lengths, we don't have target lengths\n args.max_target_positions = args.truncate\n\n # handle modelzoo if possible\n for k in (\"encoder_embed_path\", \"decoder_embed_path\"):\n if getattr(args, k, None) is None:\n # not an argument for this model, pretrained embeddings don't matter\n continue\n elif skip_pretrained_embedding_loading:\n # if we want to skip pretrained, then hide the option from fairseq\n setattr(args, k, None)\n else:\n # otherwise we may need to modelzoo adjust the path for fairseq\n import warnings\n\n warnings.warn(\"We recommend using --embedding-type instead\")\n setattr(args, k, modelzoo_path(opt.get(\"datapath\"), getattr(args, k)))\n\n # Here we hardcode a few options that we currently do not support\n # turn off distributed training\n args.distributed_world_size = 1\n args.distributed_rank = 0\n\n return args, vars(args)\n\n\nclass _FairseqDictionary(DictionaryAgent):\n \"\"\"\n Skeleton dictionary class needed for interaction with fairseq-py.\n\n This class mostly just adds some basic API behavior that Fairseq internally\n expects from dictionaries.\n\n It also inserts a fake token at the 0th index of the dictionary, as\n fairseq-py maintains backwards compatibility with fairseq-lua, which uses\n 1 indexing.\n \"\"\"\n\n # Name of our fake lua compatibility token\n _LUA = '__LUACOMPAT__'\n\n def __init__(self, *args, **kwargs):\n super().__init__(*args, **kwargs)\n # insert the fairseq-lua compatibility token to emulate 1-indexing.\n # This 1-indexing assumption is baked into a couple of places in fairseq-py,\n # and is unavoidable at the moment.\n #\n # Because of the structure of DictionaryAgent, it's difficult to force\n # a token in the 0th position without breaking load()ing. I've found\n # this to be the best way.\n\n # add the token to the dictionary\n self.add_token(_FairseqDictionary._LUA)\n # force it to be the \"most frequent\" token\n self.freq[_FairseqDictionary._LUA] = self.freq[self.null_token] + 1\n # sort the list to ensure the lua token is placed first. trim=False to\n # ensure shuffle is non-destructive.\n self.sort(trim=False)\n\n def pad(self):\n return self.pad_index\n\n def eos(self):\n return self[self.end_token]\n\n def unk(self):\n return self[self.unk_token]\n\n @property\n def pad_index(self):\n return self[self.null_token]\n\n @property\n def eos_index(self):\n return self[self.end_token]\n\n @property\n def bos_index(self):\n return self[self.start_token]\n\n @property\n def unk_index(self):\n return self[self.unk_token]\n\n def add_symbol(self):\n raise NotImplementedError(\"This is a fake class\")\n\n @property\n def symbols(self):\n return self.tok2ind.keys()\n\n\nclass _ParlaiTask(FairseqTask):\n \"\"\"Skeleton task class needed for interaction with fairseq-py.\"\"\"\n\n def __init__(self, dictionary):\n self.dict = dictionary\n\n @property\n def target_dictionary(self):\n return self.dict\n\n @property\n def source_dictionary(self):\n return self.dict\n\n\nclass FairseqAgent(TorchAgent):\n \"\"\"Generic wrapper around fairseq for use in ParlAI\"\"\"\n\n metrics = {}\n\n @classmethod\n def add_cmdline_args(cls, argparser):\n \"\"\"Add command-line arguments specifically for this agent.\"\"\"\n # first we need to add the general torch agent operations\n super(FairseqAgent, cls).add_cmdline_args(argparser)\n\n # let's store any defaults that were overridden\n old_defaults = argparser._defaults\n if 'clip_norm' not in old_defaults:\n # fairseq has a few awful defaults\n old_defaults['clip_norm'] = 1.0\n if 'optimizer' not in old_defaults:\n old_defaults['optimizer'] = 'adam'\n old_defaults['adam_betas'] = '(0.9,0.98)'\n\n agent = argparser.add_argument_group('Fairseq Arguments')\n agent.add_argument(\n '--fp16', default=False, type='bool', help='Use fp16 training'\n )\n agent.add_argument(\n '--fp16-init-scale',\n default=2 ** 7,\n type=int,\n help='default FP16 loss scale',\n )\n agent.add_argument(\n '--seed',\n default=1,\n type=int,\n metavar='N',\n help='pseudo random number generator seed',\n )\n agent.add_argument(\n '--skip-generation',\n default=False,\n type='bool',\n metavar='BOOL',\n help='Skips test time beam search. Much faster if you only need PPL',\n )\n\n # Check subargs for generation, optimizers, criterions, archs, etc\n options.add_generation_args(argparser)\n options.add_optimization_args(argparser)\n options.add_checkpoint_args(argparser)\n\n # restore any user set defaults that fairseq possibly overrode\n argparser.set_defaults(**old_defaults)\n known_args = argparser.parse_known_args(nohelp=True)[0]\n\n if hasattr(known_args, \"optimizer\"):\n optimizer = known_args.optimizer\n opt_group = argparser.add_argument_group(\n '{} optimizer arguments'.format(optimizer)\n )\n optim.OPTIMIZER_REGISTRY[optimizer].add_args(opt_group)\n if hasattr(known_args, \"lr_scheduler\"):\n lr_scheduler = known_args.lr_scheduler\n lr_group = argparser.add_argument_group(\n '{} scheduler arguments'.format(lr_scheduler)\n )\n optim.lr_scheduler.LR_SCHEDULER_REGISTRY[lr_scheduler].add_args(lr_group)\n # We need to find out the fairseq model-specific options, so grab the\n # architecture stuff and look up its options\n arch_group = options.add_model_args(argparser)\n # Fairseq marks the arch flag as required, but it may be specified\n # by a saved model cache, so we do some weird stuff to undo that\n for a in arch_group._actions:\n if a.dest == \"arch\":\n a.required = False\n a.default = None\n break\n\n # once again restore any user-set defaults\n argparser.set_defaults(**old_defaults)\n known_args = argparser.parse_known_args(nohelp=True)[0]\n\n if hasattr(known_args, \"arch\") and known_args.arch is not None:\n arch = known_args.arch\n arch_group = argparser.add_argument_group(\n \"{} architecture arguments\".format(arch)\n )\n models.ARCH_MODEL_REGISTRY[arch].add_args(arch_group)\n\n if hasattr(known_args, \"criterion\"):\n crit_group = argparser.add_argument_group(\n '{} criterion arguments'.format(known_args.criterion)\n )\n criterions.CRITERION_REGISTRY[known_args.criterion].add_args(crit_group)\n\n # one last time, restore any user set defaults\n argparser.set_defaults(**old_defaults)\n # default weight decay in fairseq is zero not None\n argparser.set_defaults(weight_decay=0.0)\n\n @staticmethod\n def dictionary_class():\n # Force use of the Fairseq Dictionary\n return _FairseqDictionary\n\n def __init__(self, opt, shared=None):\n # In general use a basic TorchAgent wherever possible\n super().__init__(opt, shared)\n if not shared:\n # this is not a shared instance of this class, so do full initialization\n\n # check early if we're going to be loading the model from a checkpoint\n model_file_exists = self.opt.get('model_file') and os.path.isfile(\n self.opt['model_file']\n )\n\n # fairseq expects options to be in argparse format, instead of a dict\n # We also need to do some argument postprocessing and whatnot\n # We'll skip pretrained embeddings if we're going to override them with\n # a model checkpoint anyway\n self.args, self.opt = _fairseq_opt_wrapper(opt, model_file_exists)\n\n # seed the RNG\n torch.manual_seed(self.args.seed)\n\n # Just some identifying info\n self.id = \"fairseq:{}\".format(self.args.arch)\n\n # We need a placeholder task for fairseq\n self.task = _ParlaiTask(self.dict)\n\n # meters for keeping track of loss, ppl, etc.\n self.meters = defaultdict(AverageMeter)\n\n # actually construct the criterion, model and generator\n self.criterion = self.build_criterion()\n self.model = self.build_model()\n\n # Construct the generator and scorer\n self.generator = SequenceGenerator(\n [self.model],\n tgt_dict=self.dict,\n beam_size=self.args.beam,\n stop_early=(not self.args.no_early_stop),\n normalize_scores=(not self.args.unnormalized),\n len_penalty=self.args.lenpen,\n unk_penalty=self.args.unkpen,\n sampling=self.args.sampling,\n sampling_topk=self.args.sampling_topk,\n sampling_temperature=self.args.sampling_temperature,\n )\n self.scorer = SequenceScorer([self.model], self.dict)\n\n # TODO: we might choose to add a --no-fp16 opt in the future to\n # explicitly disable fp16 instead\n if not self.args.fp16 and torch.cuda.get_device_capability(0)[0] >= 7:\n print(\"Heads up: using --fp16 could be a lot faster!\")\n if self.use_cuda:\n self.trainer = trainer.Trainer(\n self.args, self.task, self.model, self.criterion, None\n )\n self.trainer._build_optimizer()\n else:\n self.trainer = None\n\n # if the model already existed, let's preload it and the trainer\n if model_file_exists:\n print('Loading existing model params from ' + self.opt['model_file'])\n self.load(self.opt.get('model_file'))\n\n # move things to the GPU if possible\n if self.use_cuda:\n self.model = self.model.cuda()\n self.generator = self.generator.cuda()\n else:\n self.model = shared['model']\n self.trainer = shared['trainer']\n self.generator = shared['generator']\n self.dict = shared['dict']\n self.args = shared['args']\n self.meters = shared['meters']\n\n # Start things off clean\n self.reset()\n\n def _check_opts_unchanged(self, saved_opts, current_opts):\n \"\"\"Verify that critical options do not differ in command line vs saved model\"\"\"\n for k in NON_OVERRIDABLE_ARGS:\n if k not in saved_opts or k not in current_opts:\n # if it's not an option needed by this fairseq model, don't stress\n continue\n if saved_opts[k] != current_opts[k]:\n raise ValueError(\n '{} cannot be overridden when --model-file is specified'.format(k)\n )\n\n def build_model(self):\n \"\"\"\n Construct the actual Fairseq model. Default implementation is to use\n Fairseq's arch builder, but this method may be overridden to build custom\n models.\n \"\"\"\n model_class = models.ARCH_MODEL_REGISTRY[self.args.arch]\n model = model_class.build_model(self.args, self.task)\n if self.args.embedding_type != 'random':\n self._copy_embeddings(\n model.encoder.embed_tokens.weight, self.args.embedding_type\n )\n return model\n\n def build_criterion(self):\n \"\"\"Set up the grader.\"\"\"\n # TorchAgent will call this without ready=True before self.args is ready\n return criterions.build_criterion(self.args, self.task)\n\n def share(self):\n shared = super().share()\n shared['model'] = self.model\n shared['trainer'] = self.trainer\n shared['generator'] = self.generator\n shared['dict'] = self.dict\n shared['args'] = self.args\n shared['meters'] = self.meters\n return shared\n\n def save(self, path):\n \"\"\"Save using fairseq's checkpointing.\"\"\"\n if not path:\n return\n self.trainer.save_checkpoint(path, {'opt': self.opt, 'epoch': 0})\n # Parlai expects options to also be saved\n with open(path + '.opt', 'w') as handle:\n # overridden options shouldn't be stored, only the main ones\n if 'override' in self.opt:\n del self.opt['override']\n json.dump(self.opt, handle)\n\n # force save the dict\n self.dict.save(path + '.dict', sort=False)\n\n def load(self, path):\n \"\"\"Load using fairseq's checkpointing.\"\"\"\n if self.trainer:\n old_options = self.trainer.load_checkpoint(path, self.args.reset_optimizer)\n self._check_opts_unchanged(old_options, self.opt)\n else:\n load_model_state(path, self.model)\n\n def shutdown(self):\n if not hasattr(self, 'trainer'):\n # looks like this is a \"fake\" model that isn't actually used for batch_act.\n # we don't need to save this one.\n return\n super().shutdown()\n\n def reset(self):\n \"\"\"Reset observation and episode_done.\"\"\"\n super().reset()\n self.reset_metrics()\n\n def is_valid(self, obs):\n \"\"\"Override from TorchAgent.\n Check if an observation has no tokens in it.\"\"\"\n return len(obs.get('text_vec', [])) > 0\n\n def batchify(self, obs_batch):\n \"\"\"\n Override parent batchify to set requirements for fairseq.\n\n Fairseq depends on sorted batch inputs for a call to rnn.pad_packed_sequence.\n Fairseq models cannot handle zero length sentences\n \"\"\"\n return super().batchify(obs_batch, sort=True)\n\n def _update_metrics(self, metrics, sample):\n if metrics is None:\n # probably got an overflow in fp16 mode. don't count this sample\n return\n\n bsz = len(sample['target'])\n ntok = sample['ntokens']\n ssize = metrics['sample_size']\n\n for k, v in metrics.items():\n if k in {'ntokens', 'nsentences', 'sample_size'}:\n # don't need these\n continue\n elif k == \"nll_loss\":\n # nll loss is always normalized by ntokens\n self.meters[k].update(v, ntok)\n elif k == \"loss\":\n # loss is explicitly normalized by passed up sample size\n self.meters[k].update(v, ssize)\n else:\n # assume everything else it's averaged over bsz\n self.meters[k].update(v, bsz)\n\n def train_step(self, batch):\n \"\"\"Process batch of inputs and targets and train on them.\n\n :param batch: parlai.core.torch_agent.Batch, contains tensorized\n version of observations.\n \"\"\"\n if batch.text_vec is None:\n return\n self.is_training = True\n sample = self._make_sample(batch)\n self.model.train()\n metrics = self.trainer.train_step([sample])\n self._update_metrics(metrics, sample)\n\n def eval_step(self, batch):\n \"\"\"Process batch of inputs.\n\n If the batch includes labels, calculate validation metrics as well.\n If --skip-generation is not set, return a prediction for each input.\n\n :param batch: parlai.core.torch_agent.Batch, contains tensorized\n version of observations.\n \"\"\"\n if batch.text_vec is None:\n return\n self.is_training = False\n samples = self._make_sample(batch)\n self.model.eval()\n if batch.label_vec is not None and self.trainer is not None:\n # Interactive mode won't have a gold label\n metrics = self.trainer.valid_step(samples)\n self._update_metrics(metrics, samples)\n\n # Output placeholders\n reranked_cands = None\n generated_output = None\n\n # Grade each of the candidate sequences\n if batch.candidate_vecs is not None:\n bsz = len(batch.text_vec)\n reranked_cands = []\n # score the candidates for each item in the batch separately, so that\n # we can support variable number of candidates\n for i in range(bsz):\n cands = batch.candidate_vecs[i]\n if not cands:\n reranked_cands.append(None)\n continue\n ncand = len(cands)\n # repeat the input many times\n xs = batch.text_vec[i].unsqueeze(0).expand(ncand, -1)\n # some models crash if there's leading padding on every example\n xs = xs[:, : batch.text_lengths[i]]\n # and appropriately pack the outputs\n ys, _ = padded_tensor(cands, self.NULL_IDX, self.use_cuda)\n s = self._make_sample(xs=xs, ys=ys)\n # perform the actual grading, extract the scores\n scored = list(self.scorer.score_batched_itr([s], cuda=self.use_cuda))\n scores = [s[3][0]['score'].item() for s in scored]\n # intentional hanging comma here; argsort returns a list\n ranked, = argsort(scores, batch.candidates[i], descending=True)\n reranked_cands.append(ranked)\n\n # Next generate freely to create our response\n if not self.args.skip_generation:\n generated_output = self._generate(samples)\n elif reranked_cands:\n # we're skiping generation, but we're also grading candidates\n # so output the highest ranked candidate\n # In the case of zero candidates, we don't have something to rank,\n # so we may need to pass on that None\n generated_output = [\n ranked and ranked[0] or None for ranked in reranked_cands\n ]\n else:\n # no output at all\n pass\n\n return Output(generated_output, reranked_cands)\n\n def _generate(self, samples):\n no_prev_token = {\n k: v for k, v in samples['net_input'].items() if k != 'prev_output_tokens'\n }\n gens = self.generator.generate(no_prev_token, maxlen=64)\n bsz = samples['net_input']['src_tokens'].size(0)\n responses = []\n for i in range(bsz):\n beams = gens[i]\n selected = max(beams, key=lambda x: x[\"score\"])\n tokens = selected[\"tokens\"]\n start = 0\n end = -1\n for i, t in enumerate(tokens):\n t = t.item()\n if t == self.dict.bos_index:\n # don't include <s> token\n start = i + 1\n continue\n if t == self.dict.eos_index:\n # stop (and don't include) </s> token\n end = i\n break\n responses.append(self.dict.vec2txt(tokens[start:end]))\n return responses\n\n def report(self):\n \"\"\"Return metrics calculated by the model.\"\"\"\n # if we haven't initialized yet, just return a dummy object\n if not hasattr(self, \"trainer\"):\n return {}\n\n output = {k: v.avg for k, v in self.meters.items()}\n\n if \"nll_loss\" in self.meters:\n # special case, we used sentence averaging so ppl comes from nll_loss\n output[\"ppl\"] = np.exp2(self.meters[\"nll_loss\"].avg)\n else:\n # normal case, just use loss\n output[\"ppl\"] = np.exp2(self.meters[\"loss\"].avg)\n\n # Fairseq trainer metrics we'll pass up the way\n trainer_metrics = {\"ups\", \"wps\", \"gnorm\", \"clip\"}\n if self.is_training:\n for k in trainer_metrics:\n output[k] = self.trainer.meters[k].avg\n\n # for display purposes\n output = {k: round_sigfigs(v, 4) for k, v in output.items()}\n return output\n\n def reset_metrics(self):\n \"\"\"Reset metrics calculated by the model back to zero.\"\"\"\n if not hasattr(self, \"trainer\"):\n # We haven't set up the trainer yet, so we don't have any metrics\n return\n # We need to reset everything\n self.meters.clear()\n if self.trainer:\n for k in self.trainer.meters:\n self.trainer.meters[k].reset()\n\n def receive_metrics(self, metrics_dict):\n \"\"\"Update lr scheduler with validation loss.\"\"\"\n # TODO: this should be smarter\n self.trainer.lr_step(-1, metrics_dict[\"loss\"])\n\n # Helper functions\n def _seq_length(self, xs):\n \"\"\"Compute length of the sequence (non-padded size).\"\"\"\n return xs.ne(self.dict.pad_index).long().sum(dim=-1)\n\n def _right_shifted_ys(self, ys):\n \"\"\"Replace first token with EOS and shift remaining tokens right 1.\"\"\"\n result = torch.LongTensor(ys.size())\n result[:, 0] = self.dict.eos_index\n result[:, 1:] = ys[:, :-1]\n return result\n\n def _make_sample(self, batch=None, xs=None, ys=None):\n \"\"\"Generate a sample object that Fairseq expects.\"\"\"\n # add extra info to samples\n if batch is None and xs is None:\n raise ValueError(\"Must supply either batch or xs\")\n if batch is None and ys is None:\n raise ValueError(\"Must supply either batch or ys\")\n if xs is None:\n xs = batch.text_vec\n if ys is None:\n ys = batch.label_vec\n repadded = convert_padding_direction(xs, self.dict.pad(), right_to_left=True)\n sample = {}\n sample[\"id\"] = torch.arange(len(xs) - 1)\n sample[\"net_input\"] = {\n \"src_tokens\": repadded,\n \"src_lengths\": self._seq_length(xs),\n }\n if ys is not None:\n sample[\"target\"] = ys\n sample[\"ntokens\"] = sum(self._seq_length(ys)).item()\n sample[\"net_input\"][\"prev_output_tokens\"] = self._right_shifted_ys(ys)\n return sample\n",
"#!/usr/bin/env python3\n\n# Copyright (c) Facebook, Inc. and its affiliates.\n# This source code is licensed under the MIT license found in the\n# LICENSE file in the root directory of this source tree.\nfrom parlai.mturk.core.worlds import MTurkOnboardWorld\nfrom parlai.mturk.core.agents import TIMEOUT_MESSAGE\nfrom parlai.core.worlds import validate, MultiAgentDialogWorld\nfrom joblib import Parallel, delayed\nfrom extract_and_save_personas import main as main_extract\nimport numpy as np\nimport time\nimport os\nimport pickle\nimport random\n\nONBOARD_MSG = '\\nWelcome! Below is your persona \\\n (you can find it on the left side of the chat)\\n \\\n When you are ready to start your conversation, \\\n click the \"I am ready, continue\" button below\\n'\nTIMEOUT_MSG = '<b> The other person has timed out. \\\n Please click the \"Done with this HIT\" button below to finish this HIT.\\\n </b>'\nWAITING_MSG = 'Please wait while we match you with another worker...'\n\n\nclass PersonasGenerator(object):\n def __init__(self, opt):\n self.personas_idx_stack_path = os.path.join(\n opt['extract_personas_path'], './personas_idx_stack.pkl'\n )\n\n self.personas_path = '{}/personas-{}'.format(\n opt['extract_personas_path'],\n opt['persona_type'] + 'Revised' if opt['revised'] else 'Original',\n )\n\n if not os.path.exists(self.personas_path):\n opt['personas_path'] = self.personas_path\n main_extract(opt)\n self.personas_name_list = []\n\n for f_name in os.listdir(self.personas_path):\n if f_name.endswith('.pkl'):\n self.personas_name_list.append(f_name)\n\n if os.path.exists(self.personas_idx_stack_path):\n with open(self.personas_idx_stack_path, 'rb') as handle:\n self.idx_stack = pickle.load(handle)\n else:\n self.idx_stack = []\n self.add_idx_stack()\n self.save_idx_stack()\n pass\n\n def add_idx_stack(self):\n stack = [i for i in range(len(self.personas_name_list))]\n random.seed()\n random.shuffle(stack)\n self.idx_stack = stack + self.idx_stack\n\n def pop_persona(self):\n if len(self.idx_stack) == 0:\n self.add_idx_stack()\n idx = self.idx_stack.pop()\n data = np.load(\n os.path.join(self.personas_path, self.personas_name_list[int(idx)])\n )\n return (idx, data)\n\n def push_persona(self, idx):\n self.idx_stack.append(idx)\n\n def save_idx_stack(self):\n with open(self.personas_idx_stack_path, 'wb') as handle:\n pickle.dump(self.idx_stack, handle)\n\n\nclass PersonaProfileWorld(MTurkOnboardWorld):\n \"\"\"A world that provides a persona to the MTurkAgent\"\"\"\n\n def __init__(self, opt, mturk_agent):\n self.task_type = 'sandbox' if opt['is_sandbox'] else 'live'\n self.max_persona_time = opt['max_persona_time']\n super().__init__(opt, mturk_agent)\n\n def parley(self):\n persona_idx, data = self.mturk_agent.persona_generator.pop_persona()\n self.mturk_agent.persona_idx = persona_idx\n self.mturk_agent.persona_data = data\n persona_text = ''\n for s in data:\n persona_text += '<b><span style=\"color:blue\">' '{}\\n</span></b>'.format(\n s.strip()\n )\n\n self.mturk_agent.observe(\n {\n 'id': 'SYSTEM',\n 'show_persona': True,\n 'text': ONBOARD_MSG + '<br>' + persona_text + '<br>',\n }\n )\n\n act = self.mturk_agent.act(timeout=self.max_persona_time)\n\n # timeout\n if act['episode_done'] or (('text' in act and act['text'] == TIMEOUT_MESSAGE)):\n\n self.mturk_agent.persona_generator.push_persona(\n self.mturk_agent.persona_idx\n )\n self.mturk_agent.persona_generator.save_idx_stack()\n self.episodeDone = True\n return\n\n if 'text' not in act:\n control_msg = {'id': 'SYSTEM', 'text': WAITING_MSG}\n self.mturk_agent.observe(validate(control_msg))\n self.episodeDone = True\n\n\nclass PersonaChatWorld(MultiAgentDialogWorld):\n def __init__(\n self,\n opt,\n agents=None,\n shared=None,\n range_turn=(4, 7),\n max_turn=10,\n max_resp_time=120,\n world_tag='NONE',\n agent_timeout_shutdown=120,\n ):\n self.agents = agents\n self.turn_idx = 0\n self.range_turn = range_turn\n self.max_turn = max_turn\n self.n_turn = np.random.randint(self.range_turn[0], self.range_turn[1]) + 1\n self.dialog = []\n self.task_type = 'sandbox' if opt['is_sandbox'] else 'live'\n self.chat_done = False\n self.world_tag = world_tag\n\n # below are timeout protocols\n self.max_resp_time = max_resp_time # in secs\n self.agent_timeout_shutdown = agent_timeout_shutdown\n super().__init__(opt, agents, shared)\n\n # get personas\n self.personas = [\n (ag.persona_data if hasattr(ag, 'persona_data') else None)\n for ag in self.agents\n ]\n\n def parley(self):\n self.turn_idx += 1\n\n control_msg = {'episode_done': False}\n control_msg['id'] = 'SYSTEM'\n\n print(self.world_tag + ' is at turn {}...'.format(self.turn_idx))\n\n \"\"\"If at first turn, we need to give each agent their persona\"\"\"\n if self.turn_idx == 1:\n for idx, agent in enumerate(self.agents):\n persona_text = ''\n for s in self.personas[idx]:\n persona_text += (\n '<b><span style=\"color:blue\">'\n '{}\\n</span></b>'.format(s.strip())\n )\n control_msg['persona_text'] = persona_text\n control_msg['text'] = self.get_instruction(\n tag='start', agent_id=agent.id\n )\n agent.observe(validate(control_msg))\n if idx == 0:\n time.sleep(3)\n\n \"\"\"If we get to the min turns, inform turker that they can end if they\n want\n \"\"\"\n if self.turn_idx == self.n_turn + 1:\n for idx, agent in enumerate(self.agents):\n control_msg['text'] = self.get_instruction(idx, tag='exceed_min_turns')\n control_msg['exceed_min_turns'] = True\n agent.observe(validate(control_msg))\n\n \"\"\"Otherwise, we proceed accordingly\"\"\"\n acts = [None, None]\n for idx, agent in enumerate(self.agents):\n if not self.chat_done:\n acts[idx] = agent.act(timeout=self.max_resp_time)\n if self.check_timeout(acts[idx]):\n return\n\n if self.turn_idx > 1:\n # only check if message is too short on first message\n while self.is_msg_tooshortlong(acts[idx], agent) or self.is_exact_match(\n acts[idx], agent\n ):\n acts[idx] = agent.act()\n else:\n while self.is_exact_match(acts[idx], agent):\n acts[idx] = agent.act()\n\n if acts[idx]['episode_done']:\n self.chat_done = True\n for ag in self.agents:\n # if agent disconnected\n if ag != agent and ag.some_agent_disconnected:\n control_msg['text'] = (\n 'The other worker unexpectedly diconnected. '\n 'Please click \"Done with this HIT\" button below to '\n 'finish this HIT.'\n )\n control_msg['episode_done'] = True\n ag.observe(validate(control_msg))\n return\n # agent ends chat after exceeding minimum number of turns\n if self.turn_idx > self.n_turn:\n for ag in self.agents:\n ag.observe(validate(acts[idx]))\n control_msg['text'] = (\n 'One of you ended the chat. Thanks for your time! '\n 'Please click \"Done with this HIT\" button below '\n 'to finish this HIT.'\n )\n control_msg['episode_done'] = True\n ag.observe(validate(control_msg))\n return\n\n else:\n self.dialog.append((idx, acts[idx]['text']))\n for other_agent in self.agents:\n if other_agent != agent:\n other_agent.observe(validate(acts[idx]))\n\n def shutdown(self):\n global shutdown_agent\n\n def shutdown_agent(mturk_agent):\n mturk_agent.shutdown()\n\n Parallel(n_jobs=len(self.agents), backend='threading')(\n delayed(shutdown_agent)(agent) for agent in self.agents\n )\n\n def episode_done(self):\n return self.chat_done\n\n def get_instruction(self, agent_id=None, tag='first'):\n if tag == 'start':\n return (\n '\\nSuccessfully matched. Now let\\'s get to know each other'\n 'through the chat! \\nYou need to finish at least <b>'\n + str(self.n_turn)\n + ' chat turns</b>, after that you can click the \"Done\" button '\n 'to end the chat. \\n'\n '<b>You can track your character description on the left.</b> '\n '\\n <span style=\"color:blue\"><b>Please try to speak to the '\n 'other person as if you are the character assigned.</b></span>'\n '\\n <span style=\"color:blue\"><b>Do not trivially copy the '\n 'character descriptions into the message.</b></span>'\n )\n\n if tag == 'chat_not_done':\n return (\n 'Sorry, we need at least <b>'\n + str(self.n_turn + 1 - self.turn_idx)\n + ' more turn(s)</b> to finish. '\n 'Please send a new message:'\n )\n\n if tag == 'timeout':\n return (\n '<b>{}</b> is timeout. Please click the \"Done with this HIT\" '\n 'button below to exit this HIT. No rejections.'.format(agent_id)\n )\n\n if tag == 'exceed_min_turns':\n return (\n '\\n {} chat turns finished! \\n Keep chatting or you can click '\n 'the \"Done\" button to end the chat if it\\'s your turn.'.format(\n self.n_turn\n )\n )\n\n def save_data(self):\n # save persona_idx_stack\n convo_finished = True\n bad_workers = []\n for ag in self.agents:\n if (\n ag.hit_is_abandoned\n or ag.hit_is_returned\n or ag.disconnected\n or ag.hit_is_expired\n ):\n bad_workers.append(ag.worker_id)\n convo_finished = False\n if not convo_finished or self.dialog == []:\n for ag in self.agents:\n ag.not_approve = True\n ag.persona_generator.push_persona(ag.persona_idx)\n print(\n \"\\n******* Push persona {} back to stack. *******\\n\".format(\n ag.persona_idx\n )\n )\n\n data_path = self.opt['extract_personas_path']\n if not os.path.exists(data_path):\n os.makedirs(data_path)\n if convo_finished:\n filename = os.path.join(\n data_path,\n '{}_{}_{}.pkl'.format(\n time.strftime(\"%Y%m%d-%H%M%S\"),\n np.random.randint(0, 1000),\n self.task_type,\n ),\n )\n else:\n filename = os.path.join(\n data_path,\n '{}_{}_{}_incomplete.pkl'.format(\n time.strftime(\"%Y%m%d-%H%M%S\"),\n np.random.randint(0, 1000),\n self.task_type,\n ),\n )\n print(self.world_tag + ': Data successfully saved at {}.'.format(filename))\n pickle.dump(\n {\n 'personas': self.personas,\n 'dialog': self.dialog,\n 'workers': [ag.worker_id for ag in self.agents],\n 'bad_workers': bad_workers,\n 'n_turn': self.n_turn,\n },\n open(filename, 'wb'),\n )\n\n def is_exact_match(self, act, ag, tolerance=0):\n if act['episode_done']:\n return False\n\n control_msg = {'episode_done': False}\n control_msg['id'] = 'SYSTEM'\n\n text = act['text']\n if text not in ['', ' ', ' ', ' ']:\n n_word_match = 0\n for per in ag.persona_data:\n per_parse = per.split(' ')\n regular_words = ['', ' ', 'I', 'I\\'m', 'My', 'i']\n for r_w in regular_words:\n if r_w in per_parse:\n per_parse.remove(r_w)\n per_subseq = [\n ' '.join(per_parse[i : i + len(per_parse) - tolerance])\n for i in range(tolerance + 1)\n ]\n for pp in per_subseq:\n if pp in ['', ' ', ' ', ' ']:\n per_subseq.remove(pp)\n n_word_match += sum([(paa in text) for paa in per_subseq])\n if n_word_match > 0:\n control_msg['text'] = (\n 'We found that you <b><span style=\"color:red\">trivially '\n 'copied character descriptions</span></b>. Please '\n 'rephrase your message again.'\n )\n ag.observe(validate(control_msg))\n return True\n else:\n return False\n\n def is_msg_tooshortlong(self, act, ag, th_min=5, th_max=17):\n if act['episode_done']:\n return False\n\n control_msg = {'episode_done': False}\n control_msg['id'] = 'SYSTEM'\n\n msg_len = len(act['text'].split(' '))\n if msg_len < th_min:\n control_msg['text'] = (\n 'Your message is too short, please make it more than '\n '<b><span style=\"color:red\">5 words</span></b>.'\n )\n ag.observe(validate(control_msg))\n return True\n if msg_len > th_max:\n control_msg['text'] = (\n 'Your message is too long, please make it less than '\n '<b><span style=\"color:red\">15 words</span></b>.'\n )\n ag.observe(validate(control_msg))\n return True\n return False\n\n def reset_random(self):\n self.n_turn = np.random.randint(self.range_turn[0], self.range_turn[1]) + 1\n\n def check_timeout(self, act):\n if act['text'] == '[TIMEOUT]' and act['episode_done']:\n control_msg = {'episode_done': True}\n control_msg['id'] = 'SYSTEM'\n control_msg['text'] = self.get_instruction(\n agent_id=act['id'], tag='timeout'\n )\n for ag in self.agents:\n if ag.id != act['id']:\n ag.observe(validate(control_msg))\n self.chat_done = True\n return True\n else:\n return False\n\n def review_work(self):\n global review_agent\n\n def review_agent(ag):\n if hasattr(ag, 'not_approve'):\n pass\n else:\n ag.approve_work()\n\n Parallel(n_jobs=len(self.agents), backend='threading')(\n delayed(review_agent)(agent) for agent in self.agents\n )\n",
"#!/usr/bin/env python3\n\n# Copyright (c) Facebook, Inc. and its affiliates.\n# This source code is licensed under the MIT license found in the\n# LICENSE file in the root directory of this source tree.\n\n\"\"\"Provide functionality for loading images.\"\"\"\n\nimport parlai.core.build_data as build_data\n\nimport os\nfrom PIL import Image\nfrom zipfile import ZipFile\n\n_greyscale = ' .,:;crsA23hHG#98&@'\n_cache_size = 84000\n\n\nclass ImageLoader:\n \"\"\"Extract image feature using pretrained CNN network.\"\"\"\n\n def __init__(self, opt):\n self.opt = opt.copy()\n self.use_cuda = False\n self.netCNN = None\n self.im = opt.get('image_mode', 'none')\n if self.im not in ['none', 'raw', 'ascii']:\n if 'image_mode' not in opt or 'image_size' not in opt:\n raise RuntimeError(\n 'Need to add image arguments to opt. See '\n 'parlai.core.params.ParlaiParser.add_image_args'\n )\n self.image_mode = opt['image_mode']\n self.image_size = opt['image_size']\n self.crop_size = opt['image_cropsize']\n self._lazy_import_torch()\n self._init_transform()\n if 'resnet' in self.image_mode:\n self._init_resnet_cnn()\n elif 'resnext' in self.image_mode:\n self._init_resnext_cnn()\n else:\n raise RuntimeError(\n 'Image mode {} not supported'.format(self.image_mode)\n )\n\n def _lazy_import_torch(self):\n try:\n import torch\n except ImportError:\n raise ImportError('Need to install Pytorch: go to pytorch.org')\n import torchvision\n import torchvision.transforms as transforms\n import torch.nn as nn\n\n self.use_cuda = not self.opt.get('no_cuda', False) and torch.cuda.is_available()\n if self.use_cuda:\n print('[ Using CUDA ]')\n torch.cuda.set_device(self.opt.get('gpu', -1))\n self.torch = torch\n self.torchvision = torchvision\n self.transforms = transforms\n self.nn = nn\n\n def _init_transform(self):\n # initialize the transform function using torch vision.\n self.transform = self.transforms.Compose(\n [\n self.transforms.Scale(self.image_size),\n self.transforms.CenterCrop(self.crop_size),\n self.transforms.ToTensor(),\n self.transforms.Normalize(\n mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]\n ),\n ]\n )\n\n def _init_resnet_cnn(self):\n \"\"\"Lazily initialize preprocessor model.\n\n When image_mode is one of the ``resnet`` varieties\n \"\"\"\n cnn_type, layer_num = self._image_mode_switcher()\n # initialize the pretrained CNN using pytorch.\n CNN = getattr(self.torchvision.models, cnn_type)\n\n # cut off the additional layer.\n self.netCNN = self.nn.Sequential(\n *list(CNN(pretrained=True).children())[:layer_num]\n )\n\n if self.use_cuda:\n self.netCNN.cuda()\n\n def _init_resnext_cnn(self):\n \"\"\"Lazily initialize preprocessor model\n\n When image_mode is one of the ``resnext101_..._wsl`` varieties\n \"\"\"\n try:\n model = self.torch.hub.load('facebookresearch/WSL-Images', self.image_mode)\n # cut off layer for ImageNet classification\n self.netCNN = self.nn.Sequential(*list(model.children())[:-1])\n except RuntimeError as e:\n # Perhaps specified one of the wrong model names\n print(\n 'If you have specified one of the resnext101 wsl models, '\n 'please make sure it is one of the following: \\n'\n 'resnext101_32x8d_wsl, resnext101_32x16d_wsl, '\n 'resnext101_32x32d_wsl, resnext101_32x48d_wsl'\n )\n raise e\n except AttributeError:\n # E.g. \"module 'torch' has no attribute 'hub'\"\n raise RuntimeError(\n 'Please install the latest pytorch distribution to have access '\n 'to the resnext101 wsl models (pytorch 1.1.0, torchvision 0.3.0)'\n )\n\n if self.use_cuda:\n self.netCNN.cuda()\n\n def _image_mode_switcher(self):\n switcher = {\n 'resnet152': ['resnet152', -1],\n 'resnet101': ['resnet101', -1],\n 'resnet50': ['resnet50', -1],\n 'resnet34': ['resnet34', -1],\n 'resnet18': ['resnet18', -1],\n 'resnet152_spatial': ['resnet152', -2],\n 'resnet101_spatial': ['resnet101', -2],\n 'resnet50_spatial': ['resnet50', -2],\n 'resnet34_spatial': ['resnet34', -2],\n 'resnet18_spatial': ['resnet18', -2],\n }\n\n if self.image_mode not in switcher:\n raise NotImplementedError(\n 'image preprocessing mode'\n + '{} not supported yet'.format(self.image_mode)\n )\n\n return switcher.get(self.image_mode)\n\n @classmethod\n def get_available_model_names(cls):\n \"\"\"\n Get a list of the available model variants in this ImageLoader.\n \"\"\"\n return [\n 'resnet152',\n 'resnet101',\n 'resnet50',\n 'resnet34',\n 'resnet18',\n 'resnet152_spatial',\n 'resnet101_spatial',\n 'resnet50_spatial',\n 'resnet34_spatial',\n 'resnet18_spatial',\n 'resnext101_32x8d_wsl',\n 'resnext101_32x16d_wsl',\n 'resnext101_32x32d_wsl',\n 'resnext101_32x48d_wsl',\n ]\n\n def extract(self, image, path=None):\n # check whether initialize CNN network.\n if not self.netCNN:\n self.init_cnn(self.opt)\n # extract the image feature\n transform = self.transform(image).unsqueeze(0)\n if self.use_cuda:\n transform = transform.cuda()\n with self.torch.no_grad():\n feature = self.netCNN(transform)\n # save the feature\n if path is not None:\n self.torch.save(feature.cpu(), path)\n return feature\n\n def _img_to_ascii(self, path):\n im = Image.open(path)\n im.thumbnail((60, 40), Image.BICUBIC)\n im = im.convert('L')\n asc = []\n for y in range(0, im.size[1]):\n for x in range(0, im.size[0]):\n lum = 255 - im.getpixel((x, y))\n asc.append(_greyscale[lum * len(_greyscale) // 256])\n asc.append('\\n')\n return ''.join(asc)\n\n def load(self, path):\n \"\"\"Load from a given path.\"\"\"\n opt = self.opt\n mode = opt.get('image_mode', 'raw')\n is_zip = False\n if mode is None or mode == 'none':\n # don't need to load images\n return None\n elif '.zip' in path:\n # assume format path/to/file.zip/image_name.jpg\n is_zip = True\n sep = path.index('.zip') + 4\n zipname = path[:sep]\n file_name = path[sep + 1 :]\n path = ZipFile(zipname, 'r').open(file_name)\n if opt['task'] != 'pytorch_teacher':\n task = opt['task']\n else:\n task = opt['image_load_task']\n prepath = os.path.join(opt['datapath'], task)\n imagefn = ''.join(zipname.strip('.zip').split('/')[-2:]) + path.name\n if mode == 'raw':\n # raw just returns RGB values\n return Image.open(path).convert('RGB')\n elif mode == 'ascii':\n # convert images to ascii ¯\\_(ツ)_/¯\n return self._img_to_ascii(path)\n else:\n # otherwise, looks for preprocessed version under 'mode' directory\n if not is_zip:\n prepath, imagefn = os.path.split(path)\n dpath = os.path.join(prepath, mode)\n if not os.path.exists(dpath):\n build_data.make_dir(dpath)\n imagefn = imagefn.split('.')[0]\n new_path = os.path.join(prepath, mode, imagefn)\n if not os.path.isfile(new_path):\n return self.extract(Image.open(path).convert('RGB'), new_path)\n else:\n return self.torch.load(new_path)\n",
"import torch\nfrom . import _tensor_str\nfrom ._utils import _type, _cuda, _range, _rebuild_tensor\nimport sys\n\n\nclass _TensorBase(object):\n #: bool: True if this is a CUDA tensor\n is_cuda = False\n is_sparse = False\n\n def new(self, *args, **kwargs):\n \"\"\"Constructs a new tensor of the same data type.\"\"\"\n return self.__class__(*args, **kwargs)\n\n def type_as(self, tensor):\n \"\"\"Returns this tensor cast to the type of the given tensor.\n\n This is a no-op if the tensor is already of the correct type. This is\n equivalent to::\n\n self.type(tensor.type())\n\n Params:\n tensor (Tensor): the tensor which has the desired type\n \"\"\"\n return self.type(tensor.type())\n\n def cpu(self):\n \"\"\"Returns a CPU copy of this tensor if it's not already on the CPU\"\"\"\n return self.type(getattr(torch, self.__class__.__name__))\n\n def double(self):\n \"\"\"Casts this tensor to double type\"\"\"\n return self.type(type(self).__module__ + '.DoubleTensor')\n\n def float(self):\n \"\"\"Casts this tensor to float type\"\"\"\n return self.type(type(self).__module__ + '.FloatTensor')\n\n def half(self):\n \"\"\"Casts this tensor to half-precision float type\"\"\"\n return self.type(type(self).__module__ + '.HalfTensor')\n\n def long(self):\n \"\"\"Casts this tensor to long type\"\"\"\n return self.type(type(self).__module__ + '.LongTensor')\n\n def int(self):\n \"\"\"Casts this tensor to int type\"\"\"\n return self.type(type(self).__module__ + '.IntTensor')\n\n def short(self):\n \"\"\"Casts this tensor to short type\"\"\"\n return self.type(type(self).__module__ + '.ShortTensor')\n\n def char(self):\n \"\"\"Casts this tensor to char type\"\"\"\n return self.type(type(self).__module__ + '.CharTensor')\n\n def byte(self):\n \"\"\"Casts this tensor to byte type\"\"\"\n return self.type(type(self).__module__ + '.ByteTensor')\n\n def is_pinned(self):\n \"\"\"Returns true if this tensor resides in pinned memory\"\"\"\n storage = self.storage()\n return storage.is_pinned() if storage else False\n\n def pin_memory(self):\n \"\"\"Copies the tensor to pinned memory, if it's not already pinned.\"\"\"\n if self.is_cuda:\n raise TypeError(\"cannot pin '{0}' only CPU memory can be pinned\"\n .format(self.type()))\n storage = self.storage()\n if storage is None:\n storage = (self.storage_type())()\n return type(self)().set_(storage.pin_memory()).view_as(self)\n\n def share_memory_(self):\n \"\"\"Moves the underlying storage to shared memory.\n\n This is a no-op if the underlying storage is already in shared memory\n and for CUDA tensors. Tensors in shared memory cannot be resized.\n \"\"\"\n self.storage().share_memory_()\n return self\n\n def is_shared(self):\n \"\"\"Checks if tensor is in shared memory.\n\n This is always ``True`` for CUDA tensors.\n \"\"\"\n return self.storage().is_shared()\n\n def __deepcopy__(self, _memo):\n memo = _memo.setdefault('torch', {})\n if self._cdata in memo:\n return memo[self._cdata]\n new_storage = self.storage().__deepcopy__(_memo)\n new_tensor = self.new()\n new_tensor.set_(new_storage, self.storage_offset(), self.size(), self.stride())\n memo[self._cdata] = new_tensor\n return new_tensor\n\n def __reduce__(self):\n # NOTE: _rebuild_tensor does not call __setstate__\n args = self.__getstate__()\n return (_rebuild_tensor, args)\n\n def __getstate__(self):\n return (self.storage(),\n self.storage_offset(),\n tuple(self.size()),\n self.stride())\n\n def __setstate__(self, state):\n self.set_(*state)\n\n def __repr__(self):\n return str(self)\n\n def __str__(self):\n # All strings are unicode in Python 3, while we have to encode unicode\n # strings in Python2. If we can't, let python decide the best\n # characters to replace unicode characters with.\n if sys.version_info > (3,):\n return _tensor_str._str(self)\n else:\n if hasattr(sys.stdout, 'encoding'):\n return _tensor_str._str(self).encode(\n sys.stdout.encoding or 'UTF-8', 'replace')\n else:\n return _tensor_str._str(self).encode('UTF-8', 'replace')\n\n def __bool__(self):\n if self.numel() == 0:\n return False\n raise RuntimeError(\"bool value of non-empty \" + torch.typename(self) +\n \" objects is ambiguous\")\n\n __nonzero__ = __bool__\n\n def __iter__(self):\n return iter(map(lambda i: self.select(0, i), _range(self.size(0))))\n\n def split(self, split_size, dim=0):\n \"\"\"Splits this tensor into a tuple of tensors.\n\n See :func:`torch.split`.\n \"\"\"\n return torch.split(self, split_size, dim)\n\n def chunk(self, n_chunks, dim=0):\n \"\"\"Splits this tensor into a tuple of tensors.\n\n See :func:`torch.chunk`.\n \"\"\"\n return torch.chunk(self, n_chunks, dim)\n\n def tolist(self):\n \"\"\"Returns a nested list represenation of this tensor.\"\"\"\n dim = self.dim()\n if dim == 1:\n return [v for v in self]\n elif dim > 0:\n return [subt.tolist() for subt in self]\n return []\n\n def view_as(self, tensor):\n \"\"\"Returns this tensor viewed as the size as the specified tensor.\n\n This is equivalent to::\n\n self.view(tensor.size())\n \"\"\"\n return self.view(tensor.size())\n\n def permute(self, *dims):\n \"\"\"Permute the dimensions of this tensor.\n\n Args:\n *dims (int...): The desired ordering of dimensions\n\n Example:\n >>> x = torch.randn(2, 3, 5)\n >>> x.size()\n torch.Size([2, 3, 5])\n >>> x.permute(2, 0, 1).size()\n torch.Size([5, 2, 3])\n \"\"\"\n perm = list(dims)\n tensor = self\n n_dims = tensor.dim()\n assert len(perm) == n_dims, 'Invalid permutation'\n for i, p in enumerate(perm):\n if p != i and p != -1:\n j = i\n while True:\n assert 0 <= perm[j] and perm[j] < n_dims, 'Invalid permutation'\n tensor = tensor.transpose(j, perm[j])\n perm[j], j = -1, perm[j]\n if perm[j] == i:\n break\n perm[j] = -1\n return tensor\n\n def expand_as(self, tensor):\n \"\"\"Expands this tensor to the size of the specified tensor.\n\n This is equivalent to::\n\n self.expand(tensor.size())\n \"\"\"\n return self.expand(tensor.size())\n\n def repeat(self, *sizes):\n \"\"\"Repeats this tensor along the specified dimensions.\n\n Unlike :meth:`expand`, this function copies the tensor's data.\n\n Args:\n *sizes (torch.Size or int...): The number of times to repeat this tensor along each dimension\n\n Example:\n >>> x = torch.Tensor([1, 2, 3])\n >>> x.repeat(4, 2)\n 1 2 3 1 2 3\n 1 2 3 1 2 3\n 1 2 3 1 2 3\n 1 2 3 1 2 3\n [torch.FloatTensor of size 4x6]\n >>> x.repeat(4, 2, 1).size()\n torch.Size([4, 2, 3])\n \"\"\"\n # If args == (torch.Size,), then we need to unpack the tuple\n if len(sizes) == 1 and isinstance(sizes[0], torch.Size):\n sizes = sizes[0]\n repeats = list(sizes)\n result = self.new()\n src = self.contiguous()\n\n if len(repeats) < src.dim():\n raise ValueError('Number of dimensions of repeat dims can not be '\n 'smaller than number of dimensions of tensor')\n\n xtensor = src.new().set_(src)\n xsize = list(xtensor.size())\n for i in _range(len(repeats) - src.dim()):\n xsize = [1] + xsize\n\n size = torch.Size([a * b for a, b in zip(xsize, repeats)])\n xtensor.resize_(torch.Size(xsize))\n result.resize_(size)\n urtensor = result.new(result)\n for i in _range(xtensor.dim()):\n urtensor = urtensor.unfold(i, xtensor.size(i), xtensor.size(i))\n for i in _range(urtensor.dim() - xtensor.dim()):\n xsize = [1] + xsize\n xtensor.resize_(torch.Size(xsize))\n xxtensor = xtensor.expand_as(urtensor)\n urtensor.copy_(xxtensor)\n return result\n\n # TODO: add tests for operators\n def __add__(self, other):\n return self.add(other)\n __radd__ = __add__\n\n def __iadd__(self, other):\n return self.add_(other)\n\n def __sub__(self, other):\n return self.sub(other)\n\n def __rsub__(self, other):\n return self.new().resize_as_(self).fill_(other).add_(-1, self)\n\n def __isub__(self, other):\n return self.sub_(other)\n\n def __mul__(self, other):\n return self.mul(other)\n __rmul__ = __mul__\n\n def __imul__(self, other):\n return self.mul_(other)\n\n def __matmul__(self, other):\n dim_self = self.dim()\n try:\n dim_other = other.dim()\n except AttributeError: # not a tensor\n return NotImplemented\n if dim_self == 1 and dim_other == 1:\n return self.dot(other)\n if dim_self == 2 and dim_other == 1:\n return self.mv(other)\n if dim_self == 1 and dim_other == 2:\n return self.unsqueeze(0).mm(other).squeeze(0)\n elif dim_self == 2 and dim_other == 2:\n return self.mm(other)\n raise ValueError(\"both arguments to __matmul__ need to be 1D or 2D, \"\n \"but they are {}D and {}D\".format(dim_self, dim_other))\n\n def __pow__(self, other):\n return self.pow(other)\n\n def __ipow__(self, other):\n return self.pow_(other)\n\n def __div__(self, other):\n return self.div(other)\n __truediv__ = __div__\n\n def __rdiv__(self, other):\n return self.new().resize_as_(self).fill_(other).div_(self)\n __rtruediv__ = __rdiv__\n\n def __idiv__(self, other):\n return self.div_(other)\n\n def __mod__(self, other):\n return self.remainder(other)\n\n def __neg__(self):\n return self.neg()\n\n def __eq__(self, other):\n return self.eq(other)\n\n def __ne__(self, other):\n return self.ne(other)\n\n def __lt__(self, other):\n return self.lt(other)\n\n def __le__(self, other):\n return self.le(other)\n\n def __gt__(self, other):\n return self.gt(other)\n\n def __ge__(self, other):\n return self.ge(other)\n\n # TODO: add native add or and xor in the libs\n def __and__(self, other):\n if (type(self).__name__ != 'ByteTensor' or\n type(other).__name__ != 'ByteTensor'):\n raise RuntimeError('logical operations are supported on ByteTensors only')\n return (self + other).eq(2)\n\n def __or__(self, other):\n if (type(self).__name__ != 'ByteTensor' or\n type(other).__name__ != 'ByteTensor'):\n raise RuntimeError('logical operations are supported on ByteTensors only')\n return (self + other).gt(0)\n\n def __xor__(self, other):\n if (type(self).__name__ != 'ByteTensor' or\n type(other).__name__ != 'ByteTensor'):\n raise RuntimeError('logical operations are supported on ByteTensors only')\n return (self + other).eq(1)\n\n def __iand__(self, other):\n if (type(self).__name__ != 'ByteTensor' or\n type(other).__name__ != 'ByteTensor'):\n raise RuntimeError('logical operations are supported on ByteTensors only')\n return self.mul_(other)\n\n def __ior__(self, other):\n if (type(self).__name__ != 'ByteTensor' or\n type(other).__name__ != 'ByteTensor'):\n raise RuntimeError('logical operations are supported on ByteTensors only')\n return self.copy_((self + other).gt(0))\n\n def __ixor__(self, other):\n if (type(self).__name__ != 'ByteTensor' or\n type(other).__name__ != 'ByteTensor'):\n raise RuntimeError('logical operations are supported on ByteTensors only')\n return self.copy_((self + other).eq(1))\n\n def __invert__(self):\n if type(self).__name__ != 'ByteTensor':\n raise RuntimeError('logical operations are supported on ByteTensors only')\n return (1 - self)\n\n def __hash__(self):\n return id(self)\n\n\n_TensorBase.type = _type\n_TensorBase.cuda = _cuda\n"
] | [
[
"torch.nn.Softmax",
"torch.nn.init.uniform",
"torch.nn.Dropout",
"torch.nn.Dropout2d",
"torch.load",
"torch.cat",
"torch.nn.Embedding",
"torch.nn.Tanh",
"torch.nn.Sigmoid",
"torch.nn.utils.rnn.PackedSequence",
"torch.nn.utils.rnn.pad_packed_sequence",
"torch.nn.Linear",
"torch.nn.init.orthogonal",
"torch.nn.init.constant",
"torch.nn.init.xavier_uniform",
"torch.autograd.Variable"
],
[
"torch.ger",
"torch.addmv",
"torch.mv",
"torch.addr",
"torch.addmm",
"torch.baddbmm",
"torch.addbmm"
],
[
"torch.sum",
"torch.mul",
"torch.dot",
"torch.add"
],
[
"torch.manual_seed",
"numpy.exp2",
"torch.cuda.get_device_capability"
],
[
"numpy.random.randint"
],
[
"torch.cuda.is_available"
],
[
"torch.chunk",
"torch.Size",
"torch.typename",
"torch.split"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
madokast/cctpy | [
"b02c64220ea533a4fc9cad0b882d1be6edadf1c0"
] | [
"cctpy6_r100_wn_change/run.py"
] | [
"# from visdom import Visdom\n\nfrom cctpy import *\nfrom ccpty_cuda import *\nimport time\nimport numpy as np\n\nVIZ_PORT = 8098\n\nga32 = GPU_ACCELERATOR()\n\nmomentum_dispersions = [-0.05, -0.025, 0.0, 0.025, 0.05]\nparticle_number_per_plane_per_dp = 12\n\nparticle_number_per_gantry = len(momentum_dispersions) * particle_number_per_plane_per_dp * 2\n\ndefault_gantry = HUST_SC_GANTRY(\n DL1=0.9007765,\n GAP1=0.4301517,\n GAP2=0.370816,\n qs1_length=0.2340128,\n qs1_aperture_radius=60 * MM,\n qs1_gradient=0.0,\n qs1_second_gradient=0.0,\n qs2_length=0.200139,\n qs2_aperture_radius=60 * MM,\n qs2_gradient=0.0,\n qs2_second_gradient=0.0,\n\n DL2=2.35011,\n GAP3=0.43188,\n qs3_length=0.24379,\n)\ndefault_beamline = default_gantry.create_beamline()\nfirst_bending_length = default_gantry.first_bending_part_length()\nrun_distance = default_beamline.get_length() - first_bending_length\n\nsecond_bending_part_start_point = default_beamline.trajectory.point_at(first_bending_length)\nsecond_bending_part_start_direct = default_beamline.trajectory.direct_at(first_bending_length)\n\nip = ParticleFactory.create_proton_along(\n trajectory=default_beamline.trajectory,\n s=first_bending_length,\n kinetic_MeV=215\n)\n\nip_ran = ParticleFactory.create_proton_along(\n trajectory=default_beamline.trajectory,\n s=default_beamline.get_length(),\n kinetic_MeV=215\n)\n\npps = []\nfor dp in momentum_dispersions:\n pps.extend(PhaseSpaceParticle.phase_space_particles_along_positive_ellipse_in_xxp_plane(\n xMax=3.5 * MM, xpMax=7.5 * MM, delta=dp, number=particle_number_per_plane_per_dp\n ))\n pps.extend(PhaseSpaceParticle.phase_space_particles_along_positive_ellipse_in_yyp_plane(\n yMax=3.5 * MM, ypMax=7.5 * MM, delta=dp, number=particle_number_per_plane_per_dp\n ))\n\ntimes = 1\n\nparams_and_objs = []\n\n\ndef run(params: np.ndarray):\n global times\n start_time = time.time()\n\n gantry_number = params.shape[0]\n\n print(f\"机架数目{gantry_number}\")\n\n beamlines = create_beamlines(gantry_number, params)\n\n print(f\"制作机架用时{time.time() - start_time}\")\n ps = ParticleFactory.create_from_phase_space_particles(\n ip, ip.get_natural_coordinate_system(), pps\n )\n\n print(f\"粒子总数{len(ps) * gantry_number}\")\n\n ps_ran_list = ga32.track_multi_particle_beamlime_for_magnet_with_single_qs(\n bls=beamlines,\n ps=ps,\n distance=run_distance,\n footstep=20 * MM\n )\n\n statistic_x = BaseUtils.Statistic()\n statistic_y = BaseUtils.Statistic()\n statistic_beam_sizes = BaseUtils.Statistic()\n objs: List[List[float]] = []\n for gid in range(gantry_number): # ~120\n ps_ran = ps_ran_list[gid]\n pps_ran = PhaseSpaceParticle.create_from_running_particles(\n ip_ran, ip_ran.get_natural_coordinate_system(), ps_ran\n )\n obj: List[float] = []\n # 对于所有粒子\n for pid in range(0, len(pps_ran), particle_number_per_plane_per_dp):\n # 每 particle_number_per_plane_per_dp 个一组\n for pp in pps_ran[pid:pid + particle_number_per_plane_per_dp]:\n # 统计 x 和 y\n statistic_x.add(pp.x / MM)\n statistic_y.add(pp.y / MM) # mm\n # 分别求束斑\n beam_size_x = (statistic_x.max() - statistic_x.min()) / 2\n beam_size_y = (statistic_y.max() - statistic_y.min()) / 2\n statistic_x.clear()\n statistic_y.clear()\n\n # 只有 x 和 y 中大的我需要\n beam_size = max(beam_size_x, beam_size_y)\n statistic_beam_sizes.add(beam_size) # 用于统计均值\n obj.append(beam_size) # 用于记录每次束斑\n\n # 均值\n beam_size_avg = statistic_beam_sizes.average()\n statistic_beam_sizes.clear()\n objs.append([abs(bs - beam_size_avg) for bs in obj] + [beam_size_avg])\n\n objs_np = np.array(objs)\n\n for gid in range(gantry_number):\n param = params[gid]\n obj = objs_np[gid]\n params_and_objs.append(np.concatenate((param, obj)))\n\n np.savetxt(fname='./record/' + str(times) + '.txt', X=params_and_objs)\n try:\n # draw_viz(params_and_objs)\n pass\n except Exception as e:\n print(e)\n pass\n times += 1\n\n print(f\"用时{time.time() - start_time} s\")\n\n return objs_np\n\n\ndef create_beamlines(gantry_number, params):\n return BaseUtils.submit_process_task(\n task=create_beamline,\n param_list=[\n [params[i], second_bending_part_start_point, second_bending_part_start_direct] for i in range(gantry_number)\n ]\n )\n\n\ndef create_beamline(param, second_bending_part_start_point, second_bending_part_start_direct) -> Beamline:\n qs3_g = param[0]\n qs3_sg = param[1]\n\n dicct_tilt_1 = param[2]\n dicct_tilt_2 = param[3]\n dicct_tilt_3 = param[4]\n\n agcct_tilt_0 = param[5]\n agcct_tilt_2 = param[6]\n agcct_tilt_3 = param[7]\n\n dicct_current = param[8]\n agcct_current = param[9]\n\n agcct3_wn = int(param[10])\n agcct4_wn = int(param[11])\n agcct5_wn = int(param[12])\n\n return HUST_SC_GANTRY(\n qs3_gradient=qs3_g,\n qs3_second_gradient=qs3_sg,\n dicct345_tilt_angles=[30, dicct_tilt_1, dicct_tilt_2, dicct_tilt_3],\n agcct345_tilt_angles=[agcct_tilt_0, 30, agcct_tilt_2, agcct_tilt_3],\n dicct345_current=dicct_current,\n agcct345_current=agcct_current,\n agcct3_winding_number=agcct3_wn,\n agcct4_winding_number=agcct4_wn,\n agcct5_winding_number=agcct5_wn,\n agcct3_bending_angle=-67.5 * (agcct3_wn / (agcct3_wn + agcct4_wn + agcct5_wn)),\n agcct4_bending_angle=-67.5 * (agcct4_wn / (agcct3_wn + agcct4_wn + agcct5_wn)),\n agcct5_bending_angle=-67.5 * (agcct5_wn / (agcct3_wn + agcct4_wn + agcct5_wn)),\n\n DL1=0.9007765,\n GAP1=0.4301517,\n GAP2=0.370816,\n qs1_length=0.2340128,\n qs1_aperture_radius=60 * MM,\n qs1_gradient=0.0,\n qs1_second_gradient=0.0,\n qs2_length=0.200139,\n qs2_aperture_radius=60 * MM,\n qs2_gradient=0.0,\n qs2_second_gradient=0.0,\n\n DL2=2.35011,\n GAP3=0.43188,\n qs3_length=0.24379,\n\n agcct345_inner_small_r=92.5 * MM + 17.1 * MM,# 92.5\n agcct345_outer_small_r=108.5 * MM + 17.1 * MM, # 83+15\n dicct345_inner_small_r=124.5 * MM + 17.1 * MM, # 83+30+1\n dicct345_outer_small_r=140.5 * MM + 17.1 * MM, # 83+45 +2\n ).create_second_bending_part(\n start_point=second_bending_part_start_point,\n start_driect=second_bending_part_start_direct\n )\n\n\nwins = [] # 画图窗口\n\n\ndef draw_viz(params_and_objs):\n viz = Visdom(server='Http://127.0.0.1', port=VIZ_PORT)\n assert viz.check_connection()\n\n data = np.array(params_and_objs)\n\n x = np.array(list(range(data.shape[0])))\n\n xd = np.concatenate((x.reshape((-1, 1)), data), axis=1)\n\n # xd 每一列的意义\n # 0 编号 0-34265\n # 12 qs参数\n # 345 / 678 CCT倾斜角参数\n # 9 10 电流\n # 11 12 13 匝数\n # 14 15 16 17 18\n # 19 20 21 22 23 束斑和均值差\n # 24 束斑均值\n\n lables = ['qs-q', 'qs-s',\n 'dicct-t4', 'dicct-t6', 'dicct-t8',\n 'agcct-t2', 'agcct-t6', 'agcct-t8',\n 'dicct-I', 'agcct-I',\n 'agcct-wn0', 'agcct-wn1', 'agcct-wn2',\n 'diff_size1', 'diff_size2', 'diff_size3', 'diff_size4', 'diff_size5',\n 'diff_size6', 'diff_size7', 'diff_size8', 'diff_size9', 'diff_size0',\n 'beam_avg', 'max_diff_size']\n\n for i in range(len(lables)):\n if len(wins) != len(lables):\n if i == len(lables) - 1: # last\n wins.append(viz.scatter(\n X=np.vstack((xd[:, 0], np.max(xd[:, 14:24], axis=1))).T,\n opts={\n 'title': lables[i] + ' vs individual',\n 'xlabel': 'individual',\n 'ylabel': lables[i],\n 'markersize': 2\n }\n ))\n else:\n wins.append(viz.scatter(\n X=np.vstack((xd[:, 0], xd[:, i + 1])).T,\n opts={\n 'title': lables[i] + ' vs individual',\n 'xlabel': 'individual',\n 'ylabel': lables[i],\n 'markersize': 2\n }\n ))\n else:\n if i == len(lables) - 1: # last\n wins[i] = viz.scatter(\n X=np.vstack((xd[:, 0], np.max(xd[:, 14:24], axis=1))).T,\n win=wins[i],\n opts={\n 'title': lables[i] + ' vs individual',\n 'xlabel': 'individual',\n 'ylabel': lables[i],\n 'markersize': 2\n }\n )\n else:\n viz.scatter(\n X=np.vstack((xd[:, 0], xd[:, i + 1])).T,\n win=wins[i],\n opts={\n 'title': lables[i] + ' vs individual',\n 'xlabel': 'individual',\n 'ylabel': lables[i],\n 'markersize': 2\n }\n )\n"
] | [
[
"numpy.concatenate",
"numpy.max",
"numpy.array",
"numpy.vstack"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
dl4amc/dds | [
"2d53c74ea1f1452beb2c1c52d3048e4260f22948"
] | [
"subsamplers/cldnn.py"
] | [
"# coding: utf-8\n\n# Import all the things we need ---\n#get_ipython().magic(u'matplotlib inline')\nimport os,random\n#os.environ[\"KERAS_BACKEND\"] = \"theano\"\nos.environ[\"KERAS_BACKEND\"] = \"tensorflow\"\n#os.environ[\"THEANO_FLAGS\"] = \"device=gpu%d\"%(1) #disabled because we do not have a hardware GPU\nimport numpy as np\nfrom copy import deepcopy\n#import theano as th\n#import theano.tensor as T\nfrom keras.utils import np_utils\nfrom keras.models import load_model\nimport keras.models as models\nfrom keras.layers.core import Reshape,Dense,Dropout,Activation,Flatten\nfrom keras.layers.convolutional import Conv2D, MaxPooling2D, ZeroPadding2D\nfrom keras.regularizers import *\nfrom keras.optimizers import adam\nfrom keras.optimizers import adagrad\nimport matplotlib\nmatplotlib.use('Agg')\nimport matplotlib.pyplot as plt\n#import seaborn as sns\nimport cPickle, random, sys, keras\nfrom keras.utils import multi_gpu_model\nfrom keras import backend as K\nK.tensorflow_backend._get_available_gpus()\nimport tensorflow as tf\n\n\n# Dataset setup\nXd = cPickle.load(open(\"../data/RML2016.10b_dict.dat\", 'rb'))\nsnrs, mods = map(lambda j: sorted(list(set(map(lambda x: x[j], Xd.keys())))), [1, 0])\nX = []\nY_snr = []\nlbl = []\nfor snr in snrs:\n for mod in mods:\n X.append(Xd[(mod, snr)])\n for i in range(Xd[(mod, snr)].shape[0]): lbl.append((mod, snr))\n Y_snr = Y_snr + [mod]*6000\nX = np.vstack(X)\nY_snr = np.vstack(Y_snr)\n\n\ndef to_onehot(yy):\n yy1 = np.zeros([len(yy), max(yy) + 1])\n yy1[np.arange(len(yy)), yy] = 1\n return yy1\n\n\n# Use only the train split\nnp.random.seed(2016)\nn_examples = X.shape[0]\nn_train_valid = n_examples // 2\ntrain_valid_idx = np.random.choice(range(0, n_examples), size=n_train_valid, replace=False)\nX_train_valid = X[train_valid_idx]\nn_train = 3 * n_train_valid // 4\ntrain_idx = np.random.choice(range(0, n_train_valid), size=n_train, replace=False)\nX = X_train_valid[train_idx]\nvalid_idx = list(set(range(0, n_train_valid))-set(train_idx))\nX_valid = X_train_valid[valid_idx]\nY_snr = to_onehot(map(lambda x: mods.index(lbl[x][0]), range(X.shape[0])))\n\nprint(\"shape of X\", np.shape(X))\n# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\nnum_samples = 64\nnew_X = []\norig_model = load_model('../models/cldnn_ranker.h5')\nfor eva_iter in range(X.shape[0]//60000):\n snr_data = X[eva_iter*60000:(eva_iter+1)*60000]\n snr_out = Y_snr[eva_iter*60000:(eva_iter+1)*60000]\n snr_acc_list = []\n snr_data_copy = deepcopy(snr_data)\n for idx in range(X.shape[2]):\n snr_data = deepcopy(snr_data_copy)\n snr_data = snr_data.transpose((2, 1, 0))\n new_snr_data = np.append(snr_data[:idx], np.zeros((1, snr_data.shape[1], snr_data.shape[2])), axis=0)\n snr_data = np.append(new_snr_data, snr_data[idx+1:], axis=0)\n snr_data = snr_data.transpose((2, 1, 0))\n score = orig_model.evaluate(snr_data, snr_out, batch_size=60000, verbose=0)\n snr_acc_list.append((idx, score[1]))\n snr_acc_list.sort(key=lambda x: x[1])\n snr_acc_list = snr_acc_list[:num_samples]\n snr_acc_list.sort(key=lambda x: x[0]) \n snr_idxs = [ele[0] for ele in snr_acc_list]\n snr_data = snr_data.transpose((2, 1, 0))\n snr_data = snr_data[snr_idxs]\n snr_data = snr_data.transpose((2, 1, 0))\n new_X = new_X + [snr_data]\n print(eva_iter)\nX = np.vstack(new_X)\nnp.save('../ranker_samples/cldnn/cldnn_'+str(num_samples)+'.npy', X)\n"
] | [
[
"numpy.random.seed",
"matplotlib.use",
"numpy.append",
"numpy.shape",
"numpy.zeros",
"numpy.vstack"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
ofantomas/rlax | [
"58b3672b2f7ac1a400b3934ae9888c677f39b9e2",
"7bf3bf13d4496f1b708f4ccb5865215a16c618d6"
] | [
"rlax/_src/mpo_ops_test.py",
"examples/simple_dqn.py"
] | [
"# Copyright 2020 DeepMind Technologies Limited. 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 mpo_ops.py.\"\"\"\n\nimport functools\nimport math\n\nfrom absl.testing import absltest\nfrom absl.testing import parameterized\nimport haiku as hk\nimport jax\nimport jax.numpy as jnp\nimport numpy as np\nimport optax\nfrom rlax._src import distributions\nfrom rlax._src import mpo_ops\n\nNUM_SAMPLES = 10\nACTION_DIM = 3\nTIME_DIM = 8\nBATCH_DIM = 100\n\n# NOTE: These are not typical values used for MPO. In the test case, we know the\n# Q function perfectly so we loosen the bound on the mean to zone in to the\n# optimal policy very quickly. Similarly, we maintain a high variance to sample\n# distinct actions to explore and learn from.\n_INIT_TEMPERATURE = 0.2\n_INIT_ALPHA_MEAN = 0.001\n_INIT_ALPHA_COVARIANCE = float(1e6)\n\n_EPSILON_BOUND = 0.01\n_EPSILON_MEAN_BOUND = 10.0\n_EPSILON_COVARIANCE_BOUND = 1e-12\n\n_NUM_ITERATIONS = 5000\n_TARGET_UPDATE_PERIOD = 100\n_RANDOM_SEED = 42\n\n# The offset to ensure initially the policy is not close to 0\n_MEAN_OFFSET = 2.0\n\n# The final action should optimize down to be close to 0.0\n_MAX_ACTION_ERROR = 0.2\n_MAX_KL_ERROR = 1e-6\n\n_DIAGONAL_GAUSSIAN_DIST = distributions.gaussian_diagonal()\n_PROJECTION_OPERATOR = functools.partial(jnp.clip, a_min=1e-10)\n\n\ndef _hk_mock_policy_params(s_tm1):\n \"\"\"Returns mock policy params.\"\"\"\n # Outputs of the network are mu and sigma. Both shaped [B, ACTION_DIM].\n pi_out = hk.nets.MLP(\n output_sizes=[2 * ACTION_DIM],\n w_init=hk.initializers.VarianceScaling(1e-3),\n activation=jnp.tanh,\n activate_final=False,\n name='online_policy')(s_tm1)\n pi_mean, pi_cov = jnp.split(pi_out, 2, axis=-1)\n pi_cov = jax.nn.softplus(pi_cov)\n pi_mean = pi_mean + _MEAN_OFFSET\n return {'mean': pi_mean, 'stddev': pi_cov}\n\n\ndef _init_params(key):\n init_fn, _ = hk.transform(_hk_mock_policy_params)\n key_seq = hk.PRNGSequence(key)\n s_tm1 = jax.random.normal(\n next(key_seq), (TIME_DIM, BATCH_DIM, ACTION_DIM), jnp.float32)\n online_params = init_fn(next(key_seq), s_tm1)\n return dict(\n online=online_params,\n target=online_params,\n mpo=dict(\n temperature=_INIT_TEMPERATURE,\n alpha_mean=_INIT_ALPHA_MEAN,\n alpha_covariance=_INIT_ALPHA_COVARIANCE),\n )\n\n\ndef _mock_outputs(online_params, target_params, key, target_name):\n \"\"\"Returns mock network outputs.\"\"\"\n _, policy_params_fn = hk.transform(_hk_mock_policy_params)\n key_seq = hk.PRNGSequence(key)\n\n state_size = ACTION_DIM\n\n # Input state: [TIME_DIM, BATCH_DIM, DIM_STATE]\n s_tm1 = jax.random.normal(\n next(key_seq), (TIME_DIM, BATCH_DIM, state_size), jnp.float32)\n policy_params = policy_params_fn(online_params, None, s_tm1)\n target_policy_params = policy_params_fn(target_params, None, s_tm1)\n\n # Shape for actions: [NUM_SAMPLES, TIME_DIM, BATCH_DIM, ACTION_DIM]\n mean, stddev = target_policy_params['mean'], target_policy_params['stddev']\n mean_repeated = jnp.repeat(\n mean.reshape((1,) + mean.shape), NUM_SAMPLES, axis=0)\n stddev_repeated = jnp.repeat(\n stddev.reshape((1,) + stddev.shape), NUM_SAMPLES, axis=0)\n target_actions = _DIAGONAL_GAUSSIAN_DIST.sample(\n next(key_seq), mean_repeated, stddev_repeated)\n # If the target is advantages then num samples is 1.\n if target_name == 'advantages':\n target_actions = target_actions[0, ...]\n\n # Shape for Q: [NUM_SAMPLES, TIME_DIM, BATCH_DIM]\n # Setting Q = -a_t * tf.transpose(a_t) where a_t = s_t + a.\n # The solution to optimizing this is basically for the policy to output\n # 0 actions thereby minimizing the cost. Since this is a convex\n # optimization problem, the algorithm should get to a good solution quickly.\n\n # First compute a_t = s_t + a with shape: [NUM_SAMPLES, TIME_DIM, BATCH_DIM,\n # ACTION_DIM] since action dim is the same as shape dim here and then compute\n # the quadratic form.\n a_t = target_actions + jnp.expand_dims(s_tm1, 0)\n sample_q_values = -jnp.sum(a_t ** 2, axis=-1)\n # Set the advantage to the same as the q value.\n # Shape for advantages: [TIME_DIM, BATCH_DIM]\n advantages = sample_q_values[0, :, :]\n\n return dict(\n pi_params=policy_params,\n target_pi_params=target_policy_params,\n sample_q_values=sample_q_values,\n advantages=advantages,\n target_actions=target_actions,\n )\n\n\ndef get_common_loss_fn_inputs(params, key, target_name):\n out = _mock_outputs(params['online'], params['target'], key, target_name)\n pi_sample_log_probs = _DIAGONAL_GAUSSIAN_DIST.logprob(\n out['target_actions'], out['pi_params']['mean'],\n out['pi_params']['stddev'])\n\n return out, {\n 'sample_log_probs': pi_sample_log_probs,\n target_name: out[target_name],\n 'temperature_constraint': mpo_ops.LagrangePenalty(\n params['mpo']['temperature'], _EPSILON_BOUND)}\n\n\ndef get_decoupled_kl_constraints(out, params, per_dimension):\n \"\"\"Factorises KL for Gaussian.\"\"\"\n kl_mean, kl_covariance = (\n distributions.decoupled_multivariate_normal_kl_divergence(\n out['target_pi_params']['mean'], out['target_pi_params']['stddev'],\n out['pi_params']['mean'], out['pi_params']['stddev'],\n per_dimension=per_dimension))\n alpha_mean = params['mpo']['alpha_mean'] * jnp.ones_like(kl_mean)\n alpha_covariance = params['mpo']['alpha_covariance'] * jnp.ones_like(\n kl_covariance)\n\n return [\n (kl_mean, mpo_ops.LagrangePenalty(\n alpha=alpha_mean, epsilon=_EPSILON_MEAN_BOUND,\n per_dimension=per_dimension)),\n (kl_covariance, mpo_ops.LagrangePenalty(\n alpha=alpha_covariance, epsilon=_EPSILON_COVARIANCE_BOUND,\n per_dimension=per_dimension)),\n ]\n\n\ndef get_coupled_kl_constraints(out, params, per_dimension):\n kl_mean, kl_covariance = (\n distributions.decoupled_multivariate_normal_kl_divergence(\n out['target_pi_params']['mean'], out['target_pi_params']['stddev'],\n out['pi_params']['mean'], out['pi_params']['stddev'],\n per_dimension=per_dimension))\n alpha_mean = params['mpo']['alpha_mean'] * jnp.ones_like(kl_mean)\n return [\n (kl_mean + kl_covariance, mpo_ops.LagrangePenalty(\n alpha=alpha_mean,\n epsilon=_EPSILON_MEAN_BOUND + _EPSILON_COVARIANCE_BOUND,\n per_dimension=per_dimension))\n ]\n\n\ndef vmpo_e_step_without_restarting_or_importance_weights(advantages, **kwargs):\n restarting_weights = jnp.ones_like(advantages)\n importance_weights = jnp.ones_like(advantages)\n return mpo_ops.vmpo_compute_weights_and_temperature_loss(\n advantages=advantages, restarting_weights=restarting_weights,\n importance_weights=importance_weights, **kwargs)\n\n\nclass MPOTest(parameterized.TestCase):\n \"\"\"Tests for the MPO losses.\"\"\"\n\n @parameterized.parameters(\n {'target_name': 'sample_q_values',\n 'loss_fn': mpo_ops.mpo_loss,\n 'get_kl_constraints': get_decoupled_kl_constraints,\n 'per_dimension': False},\n {'target_name': 'advantages',\n 'loss_fn': mpo_ops.vmpo_loss,\n 'get_kl_constraints': get_decoupled_kl_constraints,\n 'per_dimension': False},\n {'target_name': 'sample_q_values',\n 'loss_fn': mpo_ops.mpo_loss,\n 'get_kl_constraints': get_coupled_kl_constraints,\n 'per_dimension': False},\n {'target_name': 'advantages',\n 'loss_fn': mpo_ops.vmpo_loss,\n 'get_kl_constraints': get_coupled_kl_constraints,\n 'per_dimension': False},\n {'target_name': 'sample_q_values',\n 'loss_fn': mpo_ops.mpo_loss,\n 'get_kl_constraints': get_decoupled_kl_constraints,\n 'per_dimension': True},\n {'target_name': 'advantages',\n 'loss_fn': mpo_ops.vmpo_loss,\n 'get_kl_constraints': get_decoupled_kl_constraints,\n 'per_dimension': True},\n {'target_name': 'sample_q_values',\n 'loss_fn': mpo_ops.mpo_loss,\n 'get_kl_constraints': get_coupled_kl_constraints,\n 'per_dimension': True},\n {'target_name': 'advantages',\n 'loss_fn': mpo_ops.vmpo_loss,\n 'get_kl_constraints': get_coupled_kl_constraints,\n 'per_dimension': True},\n )\n def test_optimization(\n self, target_name, loss_fn, get_kl_constraints, per_dimension):\n \"\"\"Tests that the policy optimization works correctly.\"\"\"\n\n def _loss(params, key):\n out, loss_fn_inputs = get_common_loss_fn_inputs(params, key, target_name)\n kl_constraints = get_kl_constraints(out, params, per_dimension)\n loss_fn_inputs.update({'kl_constraints': kl_constraints})\n loss, mpo_stats = loss_fn(**loss_fn_inputs)\n loss = jnp.mean(loss)\n temperature_bound = jnp.mean(mpo_stats.normalized_weights * jnp.log(\n mpo_stats.num_samples * mpo_stats.normalized_weights + 1e-8))\n return loss, {'outputs': out, 'temperature_bound': temperature_bound}\n\n key = jax.random.PRNGKey(_RANDOM_SEED)\n grad_fn = jax.jit(jax.grad(_loss, has_aux=True))\n optimizer = optax.adam(1e-3)\n key, new_key = jax.random.split(key)\n params = _init_params(new_key)\n opt_state = optimizer.init((params['online'], params['mpo']))\n\n @jax.jit\n def _update(params_, opt_state_, key_):\n next_key, key_ = jax.random.split(key_)\n grad, stats = grad_fn(params_, key_)\n updates, opt_state_ = optimizer.update(\n (grad['online'], grad['mpo']), opt_state_)\n online_params, mpo_params = optax.apply_updates(\n (params_['online'], params_['mpo']), updates)\n params_['online'] = online_params\n params_['mpo'] = mpo_params\n return params_, opt_state_, stats, next_key\n\n for iter_idx in range(_NUM_ITERATIONS):\n params, opt_state, extra, key = _update(params, opt_state, key)\n if iter_idx % _TARGET_UPDATE_PERIOD == 0:\n params['target'] = params['online']\n\n # Test the bounds are within tolerance.\n key, new_key = jax.random.split(key)\n _, extra = _loss(params, new_key)\n action_mean = jnp.mean(extra['outputs']['pi_params']['mean'])\n # Check action mean is close to 0.\n self.assertBetween(action_mean, -_MAX_ACTION_ERROR, _MAX_ACTION_ERROR)\n\n # Check the temperature are within the bounds.\n self.assertLess(extra['temperature_bound'], _EPSILON_BOUND)\n\n @parameterized.parameters(\n {'e_step_fn': mpo_ops.mpo_compute_weights_and_temperature_loss,\n 'additional_inputs': {},\n # dL/dq == 1 and dL/dt == epsilon (for one sample)\n 'expected_deriv_of_target': [[[1]]],\n 'sample_dimension': True},\n {'e_step_fn': vmpo_e_step_without_restarting_or_importance_weights,\n 'additional_inputs': {'top_k_fraction': 1.0},\n 'expected_deriv_of_target': [[1]],\n 'sample_dimension': False},\n )\n def test_e_step_gradient_computation(\n self, e_step_fn, additional_inputs, expected_deriv_of_target,\n sample_dimension):\n \"\"\"Tests the gradients from the E-step against the analytic ones.\"\"\"\n # Target has shape [NUM_SAMPLES, T, B] => [1, 1, 1]\n target = jnp.array([[3]], jnp.float32)\n if sample_dimension:\n target = jnp.expand_dims(target, axis=0)\n temperature = jnp.array(0.1, jnp.float32)\n def fn(target_, temperature_):\n temperature_constraint = mpo_ops.LagrangePenalty(\n temperature_, _EPSILON_BOUND)\n temperature_loss, _, _ = e_step_fn(\n target_, temperature_constraint=temperature_constraint,\n projection_operator=_PROJECTION_OPERATOR,\n **additional_inputs)\n return jnp.mean(temperature_loss)\n grad = jax.grad(fn, argnums=(0, 1))(target, temperature)\n\n np.testing.assert_almost_equal(np.array(grad[0]), np.array(\n expected_deriv_of_target, np.float32), decimal=4)\n self.assertAlmostEqual(grad[1], _EPSILON_BOUND, places=4)\n\n @parameterized.parameters(\n {'e_step_fn': mpo_ops.mpo_compute_weights_and_temperature_loss,\n 'additional_inputs': {},\n 'sample_dimension': True},\n {'e_step_fn': vmpo_e_step_without_restarting_or_importance_weights,\n 'additional_inputs': {'top_k_fraction': 1.0},\n 'sample_dimension': False},\n )\n def test_e_step_stop_gradient(\n self, e_step_fn, additional_inputs, sample_dimension):\n \"\"\"Tests no gradients flow through `weights` in the E-Step.\"\"\"\n # Target has shape [NUM_SAMPLES, T, B] => [1, 1, 1]\n target = jnp.array([[3]], jnp.float32)\n if sample_dimension:\n target = jnp.expand_dims(target, axis=0)\n temperature = 0.1\n # pylint: disable=g-long-lambda\n def mean_weights_fn(target_, temperature_):\n temperature_constraint = mpo_ops.LagrangePenalty(\n temperature_, _EPSILON_BOUND)\n _, weights, _ = e_step_fn(\n target_, temperature_constraint=temperature_constraint,\n projection_operator=_PROJECTION_OPERATOR,\n **additional_inputs)\n return jnp.mean(weights)\n grad = jax.grad(mean_weights_fn, argnums=(0, 1))(target, temperature)\n np.testing.assert_almost_equal(\n np.array(grad[0]), np.zeros_like(grad[0]), decimal=4)\n self.assertAlmostEqual(grad[1], 0., places=4)\n\n def test_kl_constraint_loss_gradients(self):\n \"\"\"Tests the gradients in the `_kl_constraint_loss` method.\"\"\"\n kl = jnp.array(1., jnp.float32)\n alpha = jnp.array(1., jnp.float32)\n _, _, alpha = mpo_ops.kl_constraint_loss(kl, mpo_ops.LagrangePenalty(\n alpha=alpha, epsilon=_EPSILON_MEAN_BOUND, per_dimension=False),\n _PROJECTION_OPERATOR)\n\n def alpha_loss_fn(alpha_):\n penalty = mpo_ops.LagrangePenalty(\n alpha=alpha_, epsilon=_EPSILON_MEAN_BOUND, per_dimension=False)\n _, alpha_loss, _ = mpo_ops.kl_constraint_loss(\n kl, penalty, _PROJECTION_OPERATOR)\n return alpha_loss\n alpha_gradients = jax.grad(alpha_loss_fn)(alpha)\n actual_alpha_gradients = _EPSILON_MEAN_BOUND - kl\n\n def kl_loss_fn(kl_):\n penalty = mpo_ops.LagrangePenalty(\n alpha=alpha, epsilon=_EPSILON_MEAN_BOUND, per_dimension=False)\n kl_loss, _, _ = mpo_ops.kl_constraint_loss(\n kl_, penalty, _PROJECTION_OPERATOR)\n return kl_loss\n kl_gradients = jax.grad(kl_loss_fn)(kl)\n actual_kl_gradients = alpha\n\n self.assertAlmostEqual(kl_gradients, actual_kl_gradients)\n self.assertAlmostEqual(alpha_gradients, actual_alpha_gradients)\n\n def test_kl_constraint_loss_stop_gradients(self):\n \"\"\"Tests the stop gradients in the `kl_constraint_loss` function.\n\n The `alpha_loss` term should not affect the KL and the `kl` term should\n not affect `alpha`.\n \"\"\"\n kl = jnp.array(1., jnp.float32)\n alpha = jnp.array(1., jnp.float32)\n _, _, alpha = mpo_ops.kl_constraint_loss(kl, mpo_ops.LagrangePenalty(\n alpha=alpha, epsilon=_EPSILON_MEAN_BOUND, per_dimension=False),\n _PROJECTION_OPERATOR)\n\n def kl_loss_fn(alpha_):\n penalty = mpo_ops.LagrangePenalty(\n alpha=alpha_, epsilon=_EPSILON_MEAN_BOUND, per_dimension=False)\n kl_loss, _, _ = mpo_ops.kl_constraint_loss(\n kl, penalty, _PROJECTION_OPERATOR)\n return kl_loss\n\n kl_gradients = jax.grad(kl_loss_fn)(alpha)\n\n def alpha_loss_fn(kl_):\n penalty = mpo_ops.LagrangePenalty(\n alpha=alpha, epsilon=_EPSILON_MEAN_BOUND, per_dimension=False)\n _, alpha_loss, _ = mpo_ops.kl_constraint_loss(\n kl_, penalty, _PROJECTION_OPERATOR)\n return alpha_loss\n alpha_gradients = jax.grad(alpha_loss_fn)(kl)\n\n # Test that there are no gradients of KL w.r.t alpha\n self.assertEqual(kl_gradients, 0.)\n\n # Test that there are no gradients of alpha w.r.t kl\n self.assertEqual(alpha_gradients, 0.)\n\n @parameterized.parameters(\n # With restarting weights of 1 (and temperature of 1) the weights should\n # be e^-1, 1, max advantage is 2 and num samples is 2 so temperature loss\n # is log(1 + e^-1) + 2 - log(2) + temperature epsilon\n {'advantages': np.array([[1.0, 2.0]]),\n 'restarting_weights': np.array([[1.0, 1.0]]),\n 'expected_temperature_loss': (math.log(1.0 + math.exp(-1.0)) + 2.0 -\n math.log(2.0) + _EPSILON_BOUND)},\n # With the second restarting weight set to 0 the weights become 1, 0\n # max advantage is 1 and num samples is 1 so temperature loss is\n # log(1) + 1 - log(1) + temperature epsilon\n {'advantages': np.array([[1.0, 2.0]]),\n 'restarting_weights': np.array([[1.0, 0.0]]),\n 'expected_temperature_loss': 1.0 + _EPSILON_BOUND},\n )\n def test_restarting_weights(\n self, advantages, restarting_weights, expected_temperature_loss):\n \"\"\"Test that calculation is correct if restarting weight is set to 0.\"\"\"\n temperature_loss, _, _ = mpo_ops.vmpo_compute_weights_and_temperature_loss(\n advantages, restarting_weights, np.ones_like(restarting_weights),\n mpo_ops.LagrangePenalty(1.0, _EPSILON_BOUND),\n functools.partial(np.clip, a_min=1e-8, a_max=None), 1.0)\n self.assertAlmostEqual(\n temperature_loss, expected_temperature_loss, places=4)\n\n @parameterized.parameters(\n # When the top k fraction is 1.0 all of the weights should be 1\n {'top_k_fraction': 1.0,\n 'scaled_advantages': np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]),\n 'expected_top_k_weights': np.array([[1.0, 1.0, 1.0], [1.0, 1.0, 1.0]])},\n # When the top k fraction is 0.5 it will take the bottom row as these are\n # the highest.\n {'top_k_fraction': 0.5,\n 'scaled_advantages': np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]),\n 'expected_top_k_weights': np.array([[0.0, 0.0, 0.0], [1.0, 1.0, 1.0]])}\n )\n def test_top_k_fraction(\n self, top_k_fraction, scaled_advantages, expected_top_k_weights):\n \"\"\"Test that only the top k fraction are used.\"\"\"\n top_k_weights = mpo_ops.get_top_k_weights(\n top_k_fraction, jnp.ones_like(scaled_advantages), scaled_advantages)\n np.testing.assert_allclose(top_k_weights, expected_top_k_weights)\n\n def test_top_k_fraction_too_low(self):\n \"\"\"Test if the top k fraction returns 0 advantages we raise an error.\"\"\"\n with self.assertRaises(ValueError):\n mpo_ops.get_top_k_weights(0.01, jnp.ones((3, 2)), jnp.ones((3, 2)))\n\n @parameterized.parameters(\n # With importance weights of 1 (and temperature of 1) the weights should\n # be e^-1, 1, max advantage is 2 and num samples is 2 so temperature loss\n # is log(1 + e^-1) + 2 - log(2) + temperature epsilon\n {'advantages': np.array([[1.0, 2.0]]),\n 'importance_weights': np.array([[1.0, 1.0]]),\n 'expected_temperature_loss': (math.log(1.0 + math.exp(-1.0)) + 2.0 -\n math.log(2.0) + _EPSILON_BOUND)},\n # If the second importance weight is 0.5 temperature loss becomes\n # log(0.5 + e^-1) + 2 - log(2) + temperature epsilon\n {'advantages': np.array([[1.0, 2.0]]),\n 'importance_weights': np.array([[1.0, 0.5]]),\n 'expected_temperature_loss': (math.log(0.5 + math.exp(-1.0)) + 2.0 -\n math.log(2.0) + _EPSILON_BOUND)},\n )\n def test_importance_weights(\n self, advantages, importance_weights, expected_temperature_loss):\n \"\"\"Test that importance weights have the correct effect.\"\"\"\n temperature_loss, _, _ = mpo_ops.vmpo_compute_weights_and_temperature_loss(\n advantages, np.ones_like(importance_weights), importance_weights,\n mpo_ops.LagrangePenalty(1.0, _EPSILON_BOUND),\n functools.partial(np.clip, a_min=1e-8, a_max=None), 1.0)\n self.assertAlmostEqual(\n temperature_loss, expected_temperature_loss, places=4)\n\n @parameterized.parameters({'per_dimension': True}, {'per_dimension': False})\n def test_mpo_input_axis_order_equivalence(self, per_dimension):\n \"\"\"Test loss functions are equivalent regardless of axis order.\"\"\"\n key = jax.random.PRNGKey(_RANDOM_SEED)\n key, new_key = jax.random.split(key)\n params = _init_params(new_key)\n out, mpo_inputs = get_common_loss_fn_inputs(params, key, 'sample_q_values')\n kl_constraints = get_coupled_kl_constraints(out, params,\n per_dimension=per_dimension)\n mpo_inputs.update({'kl_constraints': kl_constraints})\n\n # Original loss fn inputs are [S T B],\n stb_loss, stb_outputs = mpo_ops.mpo_loss(**mpo_inputs)\n mean_stb_loss = jnp.mean(stb_loss)\n\n # Swap axes and try [S B T]\n mpo_inputs.update({\n 'sample_log_probs': jnp.swapaxes(mpo_inputs['sample_log_probs'], 1, 2),\n 'sample_q_values': jnp.swapaxes(mpo_inputs['sample_q_values'], 1, 2),\n 'kl_constraints': [(jnp.swapaxes(kl, 0, 1), mpo_ops.LagrangePenalty(\n alpha=jnp.swapaxes(pen.alpha, 0, 1), epsilon=pen.epsilon,\n per_dimension=pen.per_dimension)) for (kl, pen) in kl_constraints],\n })\n sbt_loss, sbt_outputs = mpo_ops.mpo_loss(**mpo_inputs)\n mean_sbt_loss = jnp.mean(sbt_loss)\n\n # Try [T B S] denoting sample_axis at 2 instead of 0.\n mpo_inputs.update({\n 'sample_log_probs': jnp.swapaxes(mpo_inputs['sample_log_probs'], 0, 2),\n 'sample_q_values': jnp.swapaxes(mpo_inputs['sample_q_values'], 0, 2),\n 'kl_constraints': kl_constraints, # T B\n 'sample_axis': 2\n })\n tbs_loss, tbs_outputs = mpo_ops.mpo_loss(**mpo_inputs)\n mean_tbs_loss = jnp.mean(tbs_loss)\n\n self.assertAlmostEqual(mean_stb_loss, mean_sbt_loss, places=4)\n self.assertAlmostEqual(mean_tbs_loss, mean_sbt_loss, places=4)\n self.assertEqual(tbs_outputs.num_samples, sbt_outputs.num_samples)\n self.assertEqual(tbs_outputs.num_samples, stb_outputs.num_samples)\n\n @parameterized.parameters({'per_dimension': True}, {'per_dimension': False})\n def test_vmpo_input_axis_order_equivalence(self, per_dimension):\n \"\"\"Test loss functions are equivalent regardless of axis order.\"\"\"\n key = jax.random.PRNGKey(_RANDOM_SEED)\n key, new_key = jax.random.split(key)\n params = _init_params(new_key)\n out, vmpo_inputs = get_common_loss_fn_inputs(params, key, 'advantages')\n kl_constraints = get_coupled_kl_constraints(out, params,\n per_dimension=per_dimension)\n vmpo_inputs.update({'kl_constraints': kl_constraints})\n\n # Original loss fn inputs are [T B],\n tb_loss, tb_outputs = mpo_ops.vmpo_loss(**vmpo_inputs)\n mean_tb_loss = jnp.mean(tb_loss)\n\n # Swap axes and try [B T]\n vmpo_inputs.update({\n 'sample_log_probs': jnp.swapaxes(vmpo_inputs['sample_log_probs'], 0, 1),\n 'advantages': jnp.swapaxes(vmpo_inputs['advantages'], 0, 1),\n 'kl_constraints': [(jnp.swapaxes(kl, 0, 1), mpo_ops.LagrangePenalty(\n alpha=jnp.swapaxes(pen.alpha, 0, 1), epsilon=pen.epsilon,\n per_dimension=pen.per_dimension)) for (kl, pen) in kl_constraints],\n })\n bt_loss, bt_outputs = mpo_ops.vmpo_loss(**vmpo_inputs)\n mean_bt_loss = jnp.mean(bt_loss)\n\n self.assertAlmostEqual(mean_tb_loss, mean_bt_loss, places=4)\n self.assertEqual(tb_outputs.num_samples, bt_outputs.num_samples)\n\n\nif __name__ == '__main__':\n absltest.main()\n",
"# Copyright 2019 DeepMind Technologies Limited. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"A simple double-DQN agent trained to play BSuite's Catch env.\"\"\"\n\nimport collections\nimport random\nfrom absl import app\nfrom absl import flags\nfrom bsuite.environments import catch\nimport haiku as hk\nfrom haiku import nets\nimport jax\nimport jax.numpy as jnp\nimport numpy as np\nimport optax\nimport rlax\nimport experiment\n\nParams = collections.namedtuple(\"Params\", \"online target\")\nActorState = collections.namedtuple(\"ActorState\", \"count\")\nActorOutput = collections.namedtuple(\"ActorOutput\", \"actions q_values\")\nLearnerState = collections.namedtuple(\"LearnerState\", \"count opt_state\")\nData = collections.namedtuple(\"Data\", \"obs_tm1 a_tm1 r_t discount_t obs_t\")\n\nFLAGS = flags.FLAGS\nflags.DEFINE_integer(\"seed\", 42, \"Random seed.\")\nflags.DEFINE_integer(\"train_episodes\", 301, \"Number of train episodes.\")\nflags.DEFINE_integer(\"batch_size\", 32, \"Size of the training batch\")\nflags.DEFINE_float(\"target_period\", 50, \"How often to update the target net.\")\nflags.DEFINE_integer(\"replay_capacity\", 2000, \"Capacity of the replay buffer.\")\nflags.DEFINE_integer(\"hidden_units\", 50, \"Number of network hidden units.\")\nflags.DEFINE_float(\"epsilon_begin\", 1., \"Initial epsilon-greedy exploration.\")\nflags.DEFINE_float(\"epsilon_end\", 0.01, \"Final epsilon-greedy exploration.\")\nflags.DEFINE_integer(\"epsilon_steps\", 1000, \"Steps over which to anneal eps.\")\nflags.DEFINE_float(\"discount_factor\", 0.99, \"Q-learning discount factor.\")\nflags.DEFINE_float(\"learning_rate\", 0.005, \"Optimizer learning rate.\")\nflags.DEFINE_integer(\"eval_episodes\", 100, \"Number of evaluation episodes.\")\nflags.DEFINE_integer(\"evaluate_every\", 50,\n \"Number of episodes between evaluations.\")\n\n\ndef build_network(num_actions: int) -> hk.Transformed:\n \"\"\"Factory for a simple MLP network for approximating Q-values.\"\"\"\n\n def q(obs):\n network = hk.Sequential(\n [hk.Flatten(),\n nets.MLP([FLAGS.hidden_units, num_actions])])\n return network(obs)\n\n return hk.without_apply_rng(hk.transform(q))\n\n\nclass ReplayBuffer(object):\n \"\"\"A simple Python replay buffer.\"\"\"\n\n def __init__(self, capacity):\n self._prev = None\n self._action = None\n self._latest = None\n self.buffer = collections.deque(maxlen=capacity)\n\n def push(self, env_output, action):\n self._prev = self._latest\n self._action = action\n self._latest = env_output\n\n if action is not None:\n self.buffer.append(\n (self._prev.observation, self._action, self._latest.reward,\n self._latest.discount, self._latest.observation))\n\n def sample(self, batch_size):\n obs_tm1, a_tm1, r_t, discount_t, obs_t = zip(\n *random.sample(self.buffer, batch_size))\n return (np.stack(obs_tm1), np.asarray(a_tm1), np.asarray(r_t),\n np.asarray(discount_t) * FLAGS.discount_factor, np.stack(obs_t))\n\n def is_ready(self, batch_size):\n return batch_size <= len(self.buffer)\n\n\nclass DQN:\n \"\"\"A simple DQN agent.\"\"\"\n\n def __init__(self, observation_spec, action_spec, epsilon_cfg, target_period,\n learning_rate):\n self._observation_spec = observation_spec\n self._action_spec = action_spec\n self._target_period = target_period\n # Neural net and optimiser.\n self._network = build_network(action_spec.num_values)\n self._optimizer = optax.adam(learning_rate)\n self._epsilon_by_frame = optax.polynomial_schedule(**epsilon_cfg)\n # Jitting for speed.\n self.actor_step = jax.jit(self.actor_step)\n self.learner_step = jax.jit(self.learner_step)\n\n def initial_params(self, key):\n sample_input = self._observation_spec.generate_value()\n sample_input = jnp.expand_dims(sample_input, 0)\n online_params = self._network.init(key, sample_input)\n return Params(online_params, online_params)\n\n def initial_actor_state(self):\n actor_count = jnp.zeros((), dtype=jnp.float32)\n return ActorState(actor_count)\n\n def initial_learner_state(self, params):\n learner_count = jnp.zeros((), dtype=jnp.float32)\n opt_state = self._optimizer.init(params.online)\n return LearnerState(learner_count, opt_state)\n\n def actor_step(self, params, env_output, actor_state, key, evaluation):\n obs = jnp.expand_dims(env_output.observation, 0) # add dummy batch\n q = self._network.apply(params.online, obs)[0] # remove dummy batch\n epsilon = self._epsilon_by_frame(actor_state.count)\n train_a = rlax.epsilon_greedy(epsilon).sample(key, q)\n eval_a = rlax.greedy().sample(key, q)\n a = jax.lax.select(evaluation, eval_a, train_a)\n return ActorOutput(actions=a, q_values=q), ActorState(actor_state.count + 1)\n\n def learner_step(self, params, data, learner_state, unused_key):\n target_params = rlax.periodic_update(\n params.online, params.target, learner_state.count, self._target_period)\n dloss_dtheta = jax.grad(self._loss)(params.online, target_params, *data)\n updates, opt_state = self._optimizer.update(\n dloss_dtheta, learner_state.opt_state)\n online_params = optax.apply_updates(params.online, updates)\n return (\n Params(online_params, target_params),\n LearnerState(learner_state.count + 1, opt_state))\n\n def _loss(self, online_params, target_params,\n obs_tm1, a_tm1, r_t, discount_t, obs_t):\n q_tm1 = self._network.apply(online_params, obs_tm1)\n q_t_val = self._network.apply(target_params, obs_t)\n q_t_select = self._network.apply(online_params, obs_t)\n batched_loss = jax.vmap(rlax.double_q_learning)\n td_error = batched_loss(q_tm1, a_tm1, r_t, discount_t, q_t_val, q_t_select)\n return jnp.mean(rlax.l2_loss(td_error))\n\n\ndef main(unused_arg):\n env = catch.Catch(seed=FLAGS.seed)\n epsilon_cfg = dict(\n init_value=FLAGS.epsilon_begin,\n end_value=FLAGS.epsilon_end,\n transition_steps=FLAGS.epsilon_steps,\n power=1.)\n agent = DQN(\n observation_spec=env.observation_spec(),\n action_spec=env.action_spec(),\n epsilon_cfg=epsilon_cfg,\n target_period=FLAGS.target_period,\n learning_rate=FLAGS.learning_rate,\n )\n\n accumulator = ReplayBuffer(FLAGS.replay_capacity)\n experiment.run_loop(\n agent=agent,\n environment=env,\n accumulator=accumulator,\n seed=FLAGS.seed,\n batch_size=FLAGS.batch_size,\n train_episodes=FLAGS.train_episodes,\n evaluate_every=FLAGS.evaluate_every,\n eval_episodes=FLAGS.eval_episodes,\n )\n\n\nif __name__ == \"__main__\":\n app.run(main)\n"
] | [
[
"numpy.ones_like",
"numpy.array",
"numpy.zeros_like",
"numpy.testing.assert_allclose"
],
[
"numpy.asarray",
"numpy.stack"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
wesmith/CSI-Camera | [
"8bcb7c58f3546dbe8c1c81054185d347056b4ff6"
] | [
"modules/ws_dual_camera.py"
] | [
"# ws_dual_camera.py\n# WSmith 12/23/20\n# utilize modified module ws_csi_camera for the camera class\n\nimport cv2\nimport numpy as np\nimport ws_csi_camera as ws\nfrom importlib import reload\n\nreload(ws) # ws is under development\n\ndef display(sensor_mode=ws.S_MODE_3_1280_720_60, \n dispW=ws.DISP_W_M3_M4_one_half, \n dispH=ws.DISP_H_M3_M4_one_half,\n display_fps=True):\n\n # at present, display the picam and a webcam: in the future, display two picams\n\n picam = ws.CSI_Camera(display_fps=display_fps)\n webcam = ws.CSI_Camera(display_fps=display_fps)\n\n # this only needed for the picam\n picam.create_gstreamer_pipeline(sensor_id=0, sensor_mode=sensor_mode, flip_method=0,\n display_height=dispH, display_width=dispW)\n\n picam.open(picam.gstreamer_pipeline)\n webcam.open(1)\n\n picam.start()\n webcam.start()\n\n txt = \"Picam on left: Sensor Mode {}, Display {} x {}\".format(sensor_mode, dispW, dispH)\n cv2.namedWindow(txt, cv2.WINDOW_AUTOSIZE)\n\n while True:\n\n _, imgL = picam.read()\n _, imgR = webcam.read()\n\n imgR = cv2.resize(imgR, (imgL.shape[1], imgL.shape[0]))\n img = np.hstack((imgL, imgR))\n\n cv2.imshow(txt, img)\n\n keyCode = cv2.waitKey(5) & 0xFF\n \n if keyCode == ord('q'):\n break\n\n picam.stop()\n webcam.stop()\n picam.release()\n webcam.release()\n cv2.destroyAllWindows()\n\n\nif __name__ == \"__main__\":\n\n display(sensor_mode=ws.S_MODE_2_1920_1080_30, \n dispW=ws.DISP_W_M2_one_quarter, dispH=ws.DISP_H_M2_one_quarter)\n\n\n"
] | [
[
"numpy.hstack"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
MitchellAcoustics/MoSQITo | [
"15e45888d08b2932909f50fd6af0ef9d5595a588"
] | [
"mosqito/sq_metrics/tonality/tone_to_noise_ecma/_spectrum_smoothing.py"
] | [
"# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Mon Dec 21 16:44:36 2020\n\n@author: wantysal\n\"\"\"\n# Standard library import\nimport numpy as np\n\n# Local import\nfrom mosqito.sound_level_meter.noct_spectrum._getFrequencies import _getFrequencies\n\n\ndef _spectrum_smoothing(freqs_in, spec, noct, low_freq, high_freq, freqs_out):\n \"\"\"\n Compute smoothed spectrum according to the n-th octave band chosen\n\n Parameters\n ----------\n freqs : numpy.array\n frequency axis\n spec : numpy.array\n spectrum in dB\n noct : integer\n n-th octave-band according to which smooth the spectrum\n low_freq : float\n lowest frequency of the n-th octave bands\n high_freq : float\n highest frequency of the n-th octave bands\n freqs_out : numpy.array\n frequency axis along which the smoothed spectrum is given\n\n Returns\n -------\n smoothed-spectrum : numpy.array\n smoothed spectrum along the given frequency axis\n\n \"\"\"\n\n # n-th octave bands filter\n filter_freqs = _getFrequencies(\n low_freq, high_freq, noct, G=10, fr=1000)[\"f\"]\n filter_freqs[len(filter_freqs) - 1, 2] = high_freq\n filter_freqs[0, 0] = low_freq\n\n # Smoothed spectrum creation\n nb_bands = filter_freqs.shape[0]\n smoothed_spectrum = np.zeros((nb_bands))\n i = 0\n # Each band is considered individually until all of them have been treated\n while nb_bands > 0:\n # Find the index of the spectral components within the frequency bin\n bin_index = np.where(\n (freqs_in >= filter_freqs[i, 0]) & (freqs_in <= filter_freqs[i, 2])\n )[0]\n # If the frequency bin is empty, it is deleted from the list\n if len(bin_index) == 0:\n smoothed_spectrum = np.delete(smoothed_spectrum, i, axis=0)\n filter_freqs = np.delete(filter_freqs, i, axis=0)\n nb_bands -= 1\n\n else:\n # The spectral components within the frequency bin are averaged on an energy basis\n spec_sum = 0\n for j in bin_index:\n spec_sum += 10 ** (spec[j] / 10)\n smoothed_spectrum[i] = 10 * np.log10(spec_sum / len(bin_index))\n nb_bands -= 1\n i += 1\n\n # Pose of the smoothed spectrum on the frequency-axis\n cor = []\n low = []\n high = []\n # Index of the lower, center and higher limit of each frequency bin into the original spectrum\n for i in range(len(filter_freqs)):\n cor.append(np.argmin(np.abs(freqs_out - filter_freqs[i, 1])))\n low.append(np.argmin(np.abs(freqs_out - filter_freqs[i, 0])))\n high.append(np.argmin(np.abs(freqs_out - filter_freqs[i, 2])))\n\n smooth_spec = np.zeros((spec.shape))\n for i in range(filter_freqs.shape[0]):\n smooth_spec[low[i]: high[i]] = smoothed_spectrum[i]\n\n return smooth_spec\n"
] | [
[
"numpy.abs",
"numpy.delete",
"numpy.zeros",
"numpy.where"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
maltius/tf_blazeface_training | [
"c4c73590f5084fcac56fa1625d227acf45a918ae",
"c4c73590f5084fcac56fa1625d227acf45a918ae"
] | [
"predictor.py",
"predictor_own.py"
] | [
"import tensorflow as tf\nfrom utils import bbox_utils, data_utils, drawing_utils, io_utils, train_utils, landmark_utils\nimport blazeface\n\nargs = io_utils.handle_args()\nif args.handle_gpu:\n io_utils.handle_gpu_compatibility()\n\nbatch_size = 1\nuse_custom_images = False\ncustom_image_path = \"data/images/\"\nhyper_params = train_utils.get_hyper_params()\nimg_size = hyper_params[\"img_size\"]\n\ndata_types = data_utils.get_data_types()\ndata_shapes = data_utils.get_data_shapes()\npadding_values = data_utils.get_padding_values()\n\nif use_custom_images:\n img_paths = data_utils.get_custom_imgs(custom_image_path)\n total_items = len(img_paths)\n test_data = tf.data.Dataset.from_generator(lambda: data_utils.custom_data_generator(\n img_paths, img_size, img_size), data_types, data_shapes)\nelse:\n test_split = \"train[80%:]\"\n test_data, info = data_utils.get_dataset(\"the300w_lp\", test_split)\n total_items = data_utils.get_total_item_size(info, test_split)\n test_data = test_data.map(lambda x: data_utils.preprocessing(x, img_size, img_size))\n \n# train_split = \"train[:80%]\"\n# val_split = \"train[80%:]\"\n# train_data, info = data_utils.get_dataset(\"the300w_lp\", train_split)\n# val_data, _ = data_utils.get_dataset(\"the300w_lp\", val_split)\n# train_total_items = data_utils.get_total_item_size(info, train_split)\n# val_total_items = data_utils.get_total_item_size(info, val_split)\n# #\n# img_size = hyper_params[\"img_size\"]\n\n# train_data = train_data.map(lambda x : data_utils.preprocessing(x, img_size, img_size, augmentation.apply))\n# val_data = val_data.map(lambda x : data_utils.preprocessing(x, img_size, img_size))\n\n#\n\ntest_data=ds_val\ntest_data = test_data.padded_batch(batch_size, padded_shapes=data_shapes, padding_values=padding_values)\n\n\n\nmodel = blazeface.get_model(hyper_params)\nmodel_path = io_utils.get_model_path()\nmodel.load_weights('D:/Downloads/tf-blazeface-master/trained/blazeface_model_weights_85.h5')\n\n# model.load_weights('C:/Users/altius/Downloads/blazeface80_epochs15_any139.h5')\n\nprior_boxes = bbox_utils.generate_prior_boxes(hyper_params[\"feature_map_shapes\"], hyper_params[\"aspect_ratios\"])\n\nvariances = hyper_params[\"variances\"]\ntotal_landmarks = hyper_params[\"total_landmarks\"]\nlandmark_variances = total_landmarks * variances[0:2]\nvariances += landmark_variances\n\n\nfor image_data in test_data:\n img, lands, coords = image_data\n print(img.shape)\n pass\n \n # ind=0\n # pred_deltas, pred_scores = model.predict_on_batch(img)\n # pred_deltas *= variances\n # #\n # pred_bboxes_and_landmarks = bbox_utils.get_bboxes_and_landmarks_from_deltas(prior_boxes, pred_deltas)\n # pred_bboxes_and_landmarks = tf.clip_by_value(pred_bboxes_and_landmarks, 0, 1)\n # #\n # pred_scores = tf.cast(pred_scores, tf.float32)\n # #\n # weighted_suppressed_data = bbox_utils.weighted_suppression(pred_scores[ind], pred_bboxes_and_landmarks[ind])\n # #\n # weighted_bboxes = weighted_suppressed_data[..., 0:4]\n # weighted_landmarks = weighted_suppressed_data[..., 4:]\n # #\n # denormalized_bboxes = bbox_utils.denormalize_bboxes(weighted_bboxes, img_size, img_size)\n # weighted_landmarks = tf.reshape(weighted_landmarks, (-1, total_landmarks, 2))\n # denormalized_landmarks = landmark_utils.denormalize_landmarks(weighted_landmarks, img_size, img_size)\n # drawing_utils.draw_bboxes_with_landmarks(img[ind], denormalized_bboxes, denormalized_landmarks)\n\n ind=0\n pred_deltas, pred_scores = model.predict_on_batch(img)\n pred_deltas *= variances\n #\n pred_bboxes_and_landmarks = bbox_utils.get_bboxes_and_landmarks_from_deltas(prior_boxes, pred_deltas)\n pred_bboxes_and_landmarks = tf.clip_by_value(pred_bboxes_and_landmarks, 0, 1)\n #\n pred_scores = tf.cast(pred_scores, tf.float32)\n #\n weighted_suppressed_data = bbox_utils.weighted_suppression(pred_scores[ind]*10, pred_bboxes_and_landmarks[ind])\n #\n weighted_bboxes = weighted_suppressed_data[..., 0:4]\n weighted_landmarks = weighted_suppressed_data[..., 4:]\n #\n denormalized_bboxes = bbox_utils.denormalize_bboxes(weighted_bboxes, img_size, img_size)\n weighted_landmarks = tf.reshape(weighted_landmarks, (-1, total_landmarks, 2))\n denormalized_landmarks = landmark_utils.denormalize_landmarks(weighted_landmarks, img_size, img_size)\n drawing_utils.draw_bboxes_with_landmarks(img[ind], denormalized_bboxes, denormalized_landmarks)\n \n# for item in weighted_landmarks:\n# print(item)",
"import tensorflow as tf\nfrom utils import bbox_utils, data_utils, drawing_utils, io_utils, train_utils, landmark_utils\nimport blazeface\nimport time\nimport numpy as np\nimport cv2\nimport matplotlib.pyplot as plt\nimport time\nimport glob\nimport os\nfrom data_preparation_aic_orig_editted_face_test import ds\n\norig_vid=False\n\ndef coco_pck_amp(est_keys,true_keypoints):\n dist=1000\n torso_diam=np.linalg.norm(true_keypoints[-1,0:2] - true_keypoints[-2,0:2])\n est_key=est_keys[-2:,0:2]\n true_keypoint=true_keypoints[-2:,0:2]\n \n dist_all= np.array([ np.linalg.norm(true_keypoint[x,:] - est_key[x,:]) for x in range(est_key.shape[0])])\n \n \n return np.sum(dist_all<torso_diam/5)\n\nargs = io_utils.handle_args()\nif args.handle_gpu:\n io_utils.handle_gpu_compatibility()\n \n\nbatch_size = 1\nuse_custom_images = False\ncustom_image_path = \"data/images/\"\nhyper_params = train_utils.get_hyper_params()\nimg_size = hyper_params[\"img_size\"]\n\ndata_types = data_utils.get_data_types()\ndata_shapes = data_utils.get_data_shapes()\npadding_values = data_utils.get_padding_values()\n\n# if use_custom_images:\n# img_paths = data_utils.get_custom_imgs(custom_image_path)\n# total_items = len(img_paths)\n# test_data = tf.data.Dataset.from_generator(lambda: data_utils.custom_data_generator(\n# img_paths, img_size, img_size), data_types, data_shapes)\n# else:\n# test_split = \"train[80%:]\"\n# test_data, info = data_utils.get_dataset(\"the300w_lp\", test_split)\n# total_items = data_utils.get_total_item_size(info, test_split)\n# test_data = test_data.map(lambda x: data_utils.preprocessing(x, img_size, img_size))\n# #\n\ntest_data=ds\ntest_data = test_data.padded_batch(batch_size, padded_shapes=data_shapes, padding_values=padding_values)\n\nfiles = glob.glob('test/pos/*.jpeg')\nfor f in files:\n os.remove(f)\n \nfiles = glob.glob('test/neg/*.jpeg')\nfor f in files:\n os.remove(f)\n\nmodel = blazeface.get_model(hyper_params)\nmodel_path = io_utils.get_model_path()\n\n# checkpoint_dir = 'training_checkpoints_aligned_batches_cont300/'\n# checkpoint_prefix = os.path.join(checkpoint_dir, \"ckpt_{epoch}\")\n \n# model.load_weights('D:/Downloads/tf-blazeface-master/training_checkpoints_aligned_batches_faces_only_mids/ckpt_2')\n\n\n# model.load_weights('D:/Downloads/tf-blazeface-master/training_checkpoints_aligned_batches_cont300/ckpt_160')\n\n# model.load_weights('D:/Downloads/tf-blazeface-master/training_checkpoints_aligned_test5/ckpt_115')\n# model.load_weights('D:/Downloads/tf-blazeface-master/training_checkpoints_aligned_test4/ckpt_282')\n\n# model.load_weights('D:/Downloads/tf-blazeface-master/training_checkpoints_aligned_batches_face_mids_test5_cont1001e4_rev/ckpt_131')\n\n\n# model.load_weights('D:/Downloads/tf-blazeface-master/training_checkpoints_aligned_batches_test1_rev/ckpt_82')\n\n# model.load_weights('D:/Downloads/tf-blazeface-master/training_checkpoints_aligned_batches_face_mids_test5_cont210_rev/ckpt_400')\n\nmodel.load_weights('D:/Downloads/tf-blazeface-master/training_checkpoints_aligned_batches_face_mids_test5_rev1_rot/ckpt_400')\n\n\n\n# model.load_weights('D:/Downloads/tf-blazeface-master/training_checkpoints_aligned_batches/100/ckpt_1')\n\n# model.load_weights('D:/Downloads/tf-blazeface-master/training_checkpoints_aligned_batches/ckpt_70')\n\n\n# model.load_weights('D:/Downloads/tf-blazeface-master/training_checkpoints_aligned_batches_face_midshipapart/ckpt_243')\n\n\n# model.load_weights('D:/Downloads/tf-blazeface-master/training_checkpoints_aligned_batches_face_mids_ownpriors/ckpt_183')\n\n\n# model.load_weights('D:/Downloads/tf-blazeface-master/training_checkpoints_aligned_batches_face_mids/ckpt_238')\n\n\n# model.load_weights('D:/Downloads/tf-blazeface-master/training_checkpoints_aligned_batches_all3_face_ratios_123/ckpt_182')\n\n\n# model.load_weights('D:/Downloads/tf-blazeface-master/training_checkpoints_aligned_batches_all3_face_prior_aic/ckpt_26')\n\n\n# model.load_weights('D:/Downloads/tf-blazeface-master/training_checkpoints_aligned_batches_all3_face_prior_aic_nonorm/ckpt_36')\n\n\n# model.load_weights('D:/Downloads/tf-blazeface-master/training_checkpoints_aligned_batches_faces_ratios_reverse/ckpt_99')\n\n\n\n# model.load_weights('D:/Downloads/tf-blazeface-master/training_checkpoints_aligned_batches_face_only_cont105/ckpt_24')\n\n# model.load_weights('/mnt/sda1/downloads/tf-blazeface-master/trained/blazeface80_epochs15_any139.h5')\n# \nprior_boxes = bbox_utils.generate_prior_boxes(hyper_params[\"feature_map_shapes\"], hyper_params[\"aspect_ratios\"])\n\n# prior_numpy1=np.load('prior_boxes.npy')\n# prior_numpy=np.zeros((prior_numpy1.shape))\n# prior_numpy[:,0]=(prior_numpy1[:,0]+prior_numpy1[:,2])/2\n# prior_numpy[:,1]=(prior_numpy1[:,1]+prior_numpy1[:,3])/2\n# prior_numpy[:,2]=prior_numpy1[:,2]-prior_numpy1[:,0]\n# prior_numpy[:,3]=prior_numpy1[:,3]-prior_numpy1[:,1]\n# prior_boxes=tf.convert_to_tensor(prior_numpy, dtype=tf.float32)\n \n\n\nvariances = hyper_params[\"variances\"]\ntotal_landmarks = hyper_params[\"total_landmarks\"]\nlandmark_variances = total_landmarks * variances[0:2]\nvariances += landmark_variances\n\n\n \n\ncc=0\nco=0\npck_test=list([])\na=time.time()\nfor image_data in test_data:\n if cc<100:\n cc=cc+1;\n img, coord1, label1 = image_data\n pred_deltas, pred_scores = model.predict_on_batch(img)\n max(pred_scores[0])\n plt.plot(sorted(pred_scores[0]))\n \n pred_scores[0]=pred_scores[0]\n pred_deltas *= variances\n #\n pred_bboxes_and_landmarks = bbox_utils.get_bboxes_and_landmarks_from_deltas(prior_boxes, pred_deltas)\n pred_bboxes_and_landmarks = tf.clip_by_value(pred_bboxes_and_landmarks, 0, 1)\n #\n pred_scores = tf.cast(pred_scores, tf.float32)\n #\n weighted_suppressed_data = bbox_utils.weighted_suppression(pred_scores[0], pred_bboxes_and_landmarks[0])\n #\n weighted_bboxes = weighted_suppressed_data[..., 0:4]\n weighted_landmarks = weighted_suppressed_data[..., 4:]\n #\n if orig_vid:\n denormalized_bboxes = bbox_utils.denormalize_bboxes(weighted_bboxes, sizes_list[cc-1][0], sizes_list[cc-1][1])\n weighted_landmarks = tf.reshape(weighted_landmarks, (-1, total_landmarks, 2))\n denormalized_landmarks = landmark_utils.denormalize_landmarks(weighted_landmarks, sizes_list[cc-1][0], sizes_list[cc-1][1])\n \n else:\n denormalized_bboxes = bbox_utils.denormalize_bboxes(weighted_bboxes, img_size, img_size)\n weighted_landmarks = tf.reshape(weighted_landmarks, (-1, total_landmarks, 2))\n denormalized_landmarks = landmark_utils.denormalize_landmarks(weighted_landmarks, img_size, img_size)\n \n \n \n # b=time.time()\n # print(b-a)\n \n if sum(sum(sum(denormalized_landmarks.numpy())))>0:\n # cc += 1\n \n \n if orig_vid:\n # from utils import bbox_utils, data_utils, drawing_utils, io_utils, train_utils, landmark_utils\n \n # imgt=drawing_utils.draw_bboxes_with_landmarks_orig(img[0], denormalized_bboxes, denormalized_landmarks,sizes_list[cc-1],tf.image.convert_image_dtype(temps_orig[cc-1], tf.float32))\n # img= np.array(imgt)\n img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)\n \n cv2.imwrite('test/pos/'+'img'+str(cc).zfill(4)+'.jpeg',cv2.cvtColor(img, cv2.COLOR_RGB2BGR))\n else:\n \n imgt=drawing_utils.draw_bboxes_with_landmarks(img[0], denormalized_bboxes, denormalized_landmarks)\n img = np.array(imgt)\n img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)\n \n skeleton = (128*label1).numpy().astype(int)\n rec= (128*coord1).numpy().astype(int)[0][0]\n # plt.imshow(img)\n for ii in range(6):\n cv2.circle(img, center=tuple(skeleton[0][0][ii][0:2]), radius=1, color=(0, 255, 0), thickness=2)\n img = cv2.rectangle(img, (rec[1],rec[0]), (rec[3],rec[2]), (0, 255, 0) , 1)\n img = cv2.putText(np.array(img), str(cc),(10,10), cv2.FONT_HERSHEY_SIMPLEX , 0.4, (0,5,255), 1, cv2.LINE_AA) \n # plt.imshow(img)\n \n cv2.imwrite('test/pos/'+'img'+str(cc).zfill(4)+'.jpeg',(img))\n \n \n # time.sleep(5)\n \n # lands_np=denormalized_landmarks.numpy()\n # candidates=lands_np[:,0,0]\n # arg_candidates=np.argsort(candidates)\n # candidates[arg_candidates[0]]\n # stoppage=0\n # max_pck=list([])\n # for ind in range(candidates.shape[0]-1,0,-1):\n # if sum(sum(lands_np[arg_candidates[ind],:,:]))>0:\n # if stoppage==0:\n # max_pck.append(coco_pck_amp(lands_np[arg_candidates[ind],:,:],all_labels[co,0,:,:]*128))\n \n # else:\n # stoppage=1\n \n \n # # plt.imshow(imgt)\n # pck_test.append(max(max_pck))\n # print(max(max_pck))\n \n # time.sleep(3.5)\n else:\n imgt=drawing_utils.draw_bboxes_with_landmarks(img[0], denormalized_bboxes, denormalized_landmarks)\n img = np.array(imgt)\n img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)\n skeleton = (128*label1).numpy().astype(int)\n rec= (128*coord1).numpy().astype(int)[0][0]\n # plt.imshow(img)\n for ii in range(6):\n cv2.circle(img, center=tuple(skeleton[0][0][ii][0:2]), radius=1, color=(0, 0, 255), thickness=2)\n img = cv2.rectangle(np.array(img), (rec[1],rec[0]), (rec[3],rec[2]), (0, 0, 255) , 1)\n \n # plt.imshow(img)\n \n cv2.imwrite('test/neg/'+'img'+str(cc).zfill(4)+'.jpeg',(img))\n\n # co += 1\n \nprint(np.mean(pck_test)/2)\n "
] | [
[
"tensorflow.clip_by_value",
"tensorflow.reshape",
"tensorflow.cast"
],
[
"tensorflow.clip_by_value",
"tensorflow.cast",
"tensorflow.reshape",
"numpy.linalg.norm",
"numpy.mean",
"numpy.array",
"numpy.sum"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"2.8",
"1.10",
"1.12",
"2.7",
"2.6",
"1.4",
"1.13",
"2.3",
"2.4",
"2.9",
"1.5",
"1.7",
"2.5",
"0.12",
"1.0",
"2.2",
"1.2",
"2.10"
]
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"2.8",
"1.10",
"1.12",
"2.7",
"2.6",
"1.4",
"1.13",
"2.3",
"2.4",
"2.9",
"1.5",
"1.7",
"2.5",
"0.12",
"1.0",
"2.2",
"1.2",
"2.10"
]
}
] |
rkiman/astropy | [
"99de28bc0dbfe2ee0bef95b67f5619e03d22cc06"
] | [
"astropy/io/misc/asdf/tags/unit/tests/test_quantity.py"
] | [
"# Licensed under a 3-clause BSD style license - see LICENSE.rst\n# -*- coding: utf-8 -*-\n\nimport io\nimport pytest\n\nfrom astropy import units\n\nasdf = pytest.importorskip('asdf', minversion='2.0.0')\nfrom asdf.tests import helpers\n\n\ndef roundtrip_quantity(yaml, quantity):\n buff = helpers.yaml_to_asdf(yaml)\n with asdf.AsdfFile.open(buff) as ff:\n assert (ff.tree['quantity'] == quantity).all()\n buff2 = io.BytesIO()\n ff.write_to(buff2)\n\n buff2.seek(0)\n with asdf.AsdfFile.open(buff2) as ff:\n assert (ff.tree['quantity'] == quantity).all()\n\ndef test_value_scalar(tmpdir):\n testval = 2.71828\n testunit = units.kpc\n yaml = \"\"\"\nquantity: !unit/quantity-1.1.0\n value: {}\n unit: {}\n\"\"\".format(testval, testunit)\n\n quantity = units.Quantity(testval, unit=testunit)\n roundtrip_quantity(yaml, quantity)\n\ndef test_value_array(tmpdir):\n testval = [3.14159]\n testunit = units.kg\n yaml = \"\"\"\nquantity: !unit/quantity-1.1.0\n value: !core/ndarray-1.0.0 {}\n unit: {}\n\"\"\".format(testval, testunit)\n\n quantity = units.Quantity(testval, unit=testunit)\n roundtrip_quantity(yaml, quantity)\n\ndef test_value_multiarray(tmpdir):\n testval = [x*2.3081 for x in range(10)]\n testunit = units.ampere\n yaml = \"\"\"\nquantity: !unit/quantity-1.1.0\n value: !core/ndarray-1.0.0 {}\n unit: {}\n\"\"\".format(testval, testunit)\n\n quantity = units.Quantity(testval, unit=testunit)\n roundtrip_quantity(yaml, quantity)\n\ndef test_value_ndarray(tmpdir):\n from numpy import array, float64\n testval = [[1,2,3],[4,5,6]]\n testunit = units.km\n yaml = \"\"\"\nquantity: !unit/quantity-1.1.0\n value: !core/ndarray-1.0.0\n datatype: float64\n data:\n {}\n unit: {}\n\"\"\".format(testval, testunit)\n\n data = array(testval, float64)\n quantity = units.Quantity(data, unit=testunit)\n roundtrip_quantity(yaml, quantity)\n"
] | [
[
"numpy.array"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
YannCabanes/geomstats | [
"ce3f4bab6cd59c2f071371a46e336086771d0493",
"ce3f4bab6cd59c2f071371a46e336086771d0493",
"ce3f4bab6cd59c2f071371a46e336086771d0493",
"ce3f4bab6cd59c2f071371a46e336086771d0493"
] | [
"tests/tests_geomstats/test_estimators.py",
"examples/learning_graph_embedding_and_predicting.py",
"geomstats/_backend/numpy/__init__.py",
"examples/plot_knn_s2.py"
] | [
"\"\"\"Template unit tests for scikit-learn estimators.\"\"\"\n\nimport pytest\nfrom sklearn.datasets import load_iris\n\nimport geomstats.backend as gs\nimport geomstats.tests\nfrom geomstats.learning._template import (\n TemplateClassifier,\n TemplateEstimator,\n TemplateTransformer,\n)\n\nESTIMATORS = (TemplateClassifier, TemplateEstimator, TemplateTransformer)\n\n\nclass TestEstimators(geomstats.tests.TestCase):\n _multiprocess_can_split_ = True\n\n def setup_method(self):\n self.data = load_iris(return_X_y=True)\n\n @geomstats.tests.np_and_autograd_only\n def test_template_estimator(self):\n est = TemplateEstimator()\n self.assertEqual(est.demo_param, \"demo_param\")\n\n X, y = self.data\n\n est.fit(X, y)\n self.assertTrue(hasattr(est, \"is_fitted_\"))\n\n y_pred = est.predict(X)\n self.assertAllClose(y_pred, gs.ones(gs.shape(X)[0]))\n\n @geomstats.tests.np_and_autograd_only\n def test_template_transformer_error(self):\n X, _ = self.data\n n_samples = gs.shape(X)[0]\n trans = TemplateTransformer()\n trans.fit(X)\n X_diff_size = gs.ones((n_samples, gs.shape(X)[1] + 1))\n with pytest.raises(ValueError):\n trans.transform(X_diff_size)\n\n def test_template_transformer(self):\n X, _ = self.data\n trans = TemplateTransformer()\n self.assertTrue(trans.demo_param == \"demo\")\n\n trans.fit(X)\n self.assertTrue(trans.n_features_ == X.shape[1])\n\n X_trans = trans.transform(X)\n self.assertAllClose(X_trans, gs.sqrt(X))\n\n X_trans = trans.fit_transform(X)\n self.assertAllClose(X_trans, gs.sqrt(X))\n\n @geomstats.tests.np_autograd_and_tf_only\n def test_template_classifier(self):\n X, y = self.data\n clf = TemplateClassifier()\n self.assertTrue(clf.demo_param == \"demo\")\n\n clf.fit(X, y)\n self.assertTrue(hasattr(clf, \"classes_\"))\n self.assertTrue(hasattr(clf, \"X_\"))\n self.assertTrue(hasattr(clf, \"y_\"))\n\n y_pred = clf.predict(X)\n self.assertTrue(y_pred.shape == (X.shape[0],))\n",
"\"\"\"Learning embedding of graph using Poincare Ball Model.\"\"\"\n\nimport matplotlib.patches as mpatches\nimport matplotlib.pyplot as plt\n\nimport geomstats.backend as gs\nimport geomstats.visualization as visualization\nfrom geomstats.datasets.prepare_graph_data import HyperbolicEmbedding\nfrom geomstats.datasets.utils import load_karate_graph\nfrom geomstats.learning.kmeans import RiemannianKMeans\nfrom geomstats.learning.kmedoids import RiemannianKMedoids\n\n\ndef main():\n \"\"\"Learning Poincaré graph embedding.\n\n Learns Poincaré Ball embedding by using Riemannian\n gradient descent algorithm. Then K-means is applied\n to learn labels of each data sample.\n \"\"\"\n gs.random.seed(1234)\n\n karate_graph = load_karate_graph()\n hyperbolic_embedding = HyperbolicEmbedding(max_epochs=3)\n embeddings = hyperbolic_embedding.embed(karate_graph)\n\n colors = {1: \"b\", 2: \"r\"}\n group_1 = mpatches.Patch(color=colors[1], label=\"Group 1\")\n group_2 = mpatches.Patch(color=colors[2], label=\"Group 2\")\n\n circle = visualization.PoincareDisk(point_type=\"ball\")\n\n _, ax = plt.subplots(figsize=(8, 8))\n ax.axes.xaxis.set_visible(False)\n ax.axes.yaxis.set_visible(False)\n circle.set_ax(ax)\n circle.draw(ax=ax)\n for i_embedding, embedding in enumerate(embeddings):\n x_coords = embedding[0]\n y_coords = embedding[1]\n pt_id = i_embedding\n plt.scatter(x_coords, y_coords, c=colors[karate_graph.labels[pt_id][0]], s=150)\n ax.annotate(pt_id, (x_coords, y_coords))\n\n plt.tick_params(which=\"both\")\n plt.title(\"Poincare Ball Embedding of the Karate Club Network\")\n plt.legend(handles=[group_1, group_2])\n plt.show()\n\n n_clusters = 2\n\n kmeans = RiemannianKMeans(\n metric=hyperbolic_embedding.manifold.metric,\n n_clusters=n_clusters,\n init=\"random\",\n )\n\n centroids = kmeans.fit(X=embeddings)\n labels = kmeans.predict(X=embeddings)\n\n colors = [\"g\", \"c\", \"m\"]\n circle = visualization.PoincareDisk(point_type=\"ball\")\n _, ax2 = plt.subplots(figsize=(8, 8))\n circle.set_ax(ax2)\n circle.draw(ax=ax2)\n ax2.axes.xaxis.set_visible(False)\n ax2.axes.yaxis.set_visible(False)\n group_1_predicted = mpatches.Patch(color=colors[0], label=\"Predicted Group 1\")\n group_2_predicted = mpatches.Patch(color=colors[1], label=\"Predicted Group 2\")\n group_centroids = mpatches.Patch(color=colors[2], label=\"Cluster centroids\")\n\n for _ in range(n_clusters):\n for i_embedding, embedding in enumerate(embeddings):\n x_coords = embedding[0]\n y_coords = embedding[1]\n pt_id = i_embedding\n if labels[i_embedding] == 0:\n color = colors[0]\n else:\n color = colors[1]\n plt.scatter(x_coords, y_coords, c=color, s=150)\n ax2.annotate(pt_id, (x_coords, y_coords))\n\n for _, centroid in enumerate(centroids):\n x_coords = centroid[0]\n y_coords = centroid[1]\n plt.scatter(\n x_coords,\n y_coords,\n c=colors[2],\n marker=\"*\",\n s=150,\n )\n\n plt.title(\"K-means applied to Karate club embedding\")\n plt.legend(handles=[group_1_predicted, group_2_predicted, group_centroids])\n plt.show()\n\n kmedoid = RiemannianKMedoids(\n metric=hyperbolic_embedding.manifold.metric,\n n_clusters=n_clusters,\n init=\"random\",\n n_jobs=2,\n )\n\n centroids = kmedoid.fit(data=embeddings, max_iter=100)\n labels = kmedoid.predict(data=embeddings)\n\n colors = [\"g\", \"c\", \"m\"]\n circle = visualization.PoincareDisk(point_type=\"ball\")\n _, ax2 = plt.subplots(figsize=(8, 8))\n circle.set_ax(ax2)\n circle.draw(ax=ax2)\n ax2.axes.xaxis.set_visible(False)\n ax2.axes.yaxis.set_visible(False)\n group_1_predicted = mpatches.Patch(color=colors[0], label=\"Predicted Group 1\")\n group_2_predicted = mpatches.Patch(color=colors[1], label=\"Predicted Group 2\")\n group_centroids = mpatches.Patch(color=colors[2], label=\"Cluster centroids\")\n\n for _ in range(n_clusters):\n for i_embedding, embedding in enumerate(embeddings):\n x_coords = embedding[0]\n y_coords = embedding[1]\n pt_id = i_embedding\n if labels[i_embedding] == 0:\n color = colors[0]\n else:\n color = colors[1]\n plt.scatter(x_coords, y_coords, c=color, s=150)\n ax2.annotate(pt_id, (x_coords, y_coords))\n\n for _, centroid in enumerate(centroids):\n x_coords = centroid[0]\n y_coords = centroid[1]\n plt.scatter(\n x_coords,\n y_coords,\n c=colors[2],\n marker=\"*\",\n s=150,\n )\n\n plt.title(\"K-Medoids applied to Karate club embedding\")\n plt.legend(handles=[group_1_predicted, group_2_predicted, group_centroids])\n plt.show()\n\n\nif __name__ == \"__main__\":\n main()\n",
"\"\"\"Numpy based computation backend.\"\"\"\n\nimport math\n\nimport numpy as np\nfrom numpy import (\n abs,\n all,\n allclose,\n amax,\n amin,\n any,\n arange,\n arccos,\n arccosh,\n arcsin,\n arctan2,\n arctanh,\n argmax,\n argmin,\n array,\n broadcast_arrays,\n broadcast_to,\n ceil,\n clip,\n concatenate,\n cos,\n cosh,\n cross,\n cumprod,\n cumsum,\n diag_indices,\n diagonal,\n divide,\n dot,\n)\nfrom numpy import dtype as ndtype # NOQA\nfrom numpy import (\n einsum,\n empty,\n empty_like,\n equal,\n exp,\n expand_dims,\n eye,\n flip,\n float32,\n float64,\n floor,\n greater,\n hsplit,\n hstack,\n imag,\n int32,\n int64,\n isclose,\n isnan,\n less,\n less_equal,\n linspace,\n log,\n logical_and,\n logical_or,\n matmul,\n maximum,\n mean,\n meshgrid,\n mod,\n ones,\n ones_like,\n outer,\n power,\n prod,\n real,\n repeat,\n reshape,\n searchsorted,\n shape,\n sign,\n sin,\n sinh,\n sort,\n split,\n sqrt,\n squeeze,\n stack,\n std,\n sum,\n tan,\n tanh,\n tile,\n trace,\n transpose,\n tril,\n tril_indices,\n triu,\n triu_indices,\n uint8,\n unique,\n vstack,\n where,\n zeros,\n zeros_like,\n)\nfrom scipy.sparse import coo_matrix # NOQA\nfrom scipy.special import erf, polygamma # NOQA\n\nfrom ..constants import np_atol, np_rtol\nfrom . import autodiff # NOQA\nfrom . import linalg # NOQA\nfrom . import random # NOQA\nfrom .common import to_ndarray # NOQA\n\nDTYPES = {\n ndtype(\"int32\"): 0,\n ndtype(\"int64\"): 1,\n ndtype(\"float32\"): 2,\n ndtype(\"float64\"): 3,\n ndtype(\"complex64\"): 4,\n ndtype(\"complex128\"): 5,\n}\n\n\natol = np_atol\nrtol = np_rtol\n\n\ndef comb(n, k):\n return math.factorial(n) // math.factorial(k) // math.factorial(n - k)\n\n\ndef to_numpy(x):\n return x\n\n\ndef from_numpy(x):\n return x\n\n\ndef convert_to_wider_dtype(tensor_list):\n dtype_list = [DTYPES[x.dtype] for x in tensor_list]\n wider_dtype_index = max(dtype_list)\n\n wider_dtype = list(DTYPES.keys())[wider_dtype_index]\n\n tensor_list = [cast(x, dtype=wider_dtype) for x in tensor_list]\n return tensor_list\n\n\ndef flatten(x):\n return x.flatten()\n\n\ndef one_hot(labels, num_classes):\n return np.eye(num_classes, dtype=np.dtype(\"uint8\"))[labels]\n\n\ndef get_mask_i_float(i, n):\n \"\"\"Create a 1D array of zeros with one element at one, with floating type.\n\n Parameters\n ----------\n i : int\n Index of the non-zero element.\n n: n\n Length of the created array.\n\n Returns\n -------\n mask_i_float : array-like, shape=[n,]\n 1D array of zeros except at index i, where it is one\n \"\"\"\n range_n = arange(n)\n i_float = cast(array([i]), int32)[0]\n mask_i = equal(range_n, i_float)\n mask_i_float = cast(mask_i, float32)\n return mask_i_float\n\n\ndef _is_boolean(x):\n if isinstance(x, bool):\n return True\n if isinstance(x, (tuple, list)):\n return _is_boolean(x[0])\n if isinstance(x, np.ndarray):\n return x.dtype == bool\n return False\n\n\ndef _is_iterable(x):\n if isinstance(x, (list, tuple)):\n return True\n if isinstance(x, np.ndarray):\n return ndim(x) > 0\n return False\n\n\ndef assignment(x, values, indices, axis=0):\n \"\"\"Assign values at given indices of an array.\n\n Parameters\n ----------\n x: array-like, shape=[dim]\n Initial array.\n values: {float, list(float)}\n Value or list of values to be assigned.\n indices: {int, tuple, list(int), list(tuple)}\n Single int or tuple, or list of ints or tuples of indices where value\n is assigned.\n If the length of the tuples is shorter than ndim(x), values are\n assigned to each copy along axis.\n axis: int, optional\n Axis along which values are assigned, if vectorized.\n\n Returns\n -------\n x_new : array-like, shape=[dim]\n Copy of x with the values assigned at the given indices.\n\n Notes\n -----\n If a single value is provided, it is assigned at all the indices.\n If a list is given, it must have the same length as indices.\n \"\"\"\n x_new = copy(x)\n\n use_vectorization = hasattr(indices, \"__len__\") and len(indices) < ndim(x)\n if _is_boolean(indices):\n x_new[indices] = values\n return x_new\n zip_indices = _is_iterable(indices) and _is_iterable(indices[0])\n len_indices = len(indices) if _is_iterable(indices) else 1\n if zip_indices:\n indices = tuple(zip(*indices))\n if not use_vectorization:\n if not zip_indices:\n len_indices = len(indices) if _is_iterable(indices) else 1\n len_values = len(values) if _is_iterable(values) else 1\n if len_values > 1 and len_values != len_indices:\n raise ValueError(\"Either one value or as many values as indices\")\n x_new[indices] = values\n else:\n indices = tuple(list(indices[:axis]) + [slice(None)] + list(indices[axis:]))\n x_new[indices] = values\n return x_new\n\n\ndef assignment_by_sum(x, values, indices, axis=0):\n \"\"\"Add values at given indices of an array.\n\n Parameters\n ----------\n x : array-like, shape=[dim]\n Initial array.\n values : {float, list(float)}\n Value or list of values to be assigned.\n indices : {int, tuple, list(int), list(tuple)}\n Single int or tuple, or list of ints or tuples of indices where value\n is assigned.\n If the length of the tuples is shorter than ndim(x), values are\n assigned to each copy along axis.\n axis: int, optional\n Axis along which values are assigned, if vectorized.\n\n Returns\n -------\n x_new : array-like, shape=[dim]\n Copy of x with the values assigned at the given indices.\n\n Notes\n -----\n If a single value is provided, it is assigned at all the indices.\n If a list is given, it must have the same length as indices.\n \"\"\"\n x_new = copy(x)\n\n use_vectorization = hasattr(indices, \"__len__\") and len(indices) < ndim(x)\n if _is_boolean(indices):\n x_new[indices] += values\n return x_new\n zip_indices = _is_iterable(indices) and _is_iterable(indices[0])\n if zip_indices:\n indices = tuple(zip(*indices))\n if not use_vectorization:\n len_indices = len(indices) if _is_iterable(indices) else 1\n len_values = len(values) if _is_iterable(values) else 1\n if len_values > 1 and len_values != len_indices:\n raise ValueError(\"Either one value or as many values as indices\")\n x_new[indices] += values\n else:\n indices = tuple(list(indices[:axis]) + [slice(None)] + list(indices[axis:]))\n x_new[indices] += values\n return x_new\n\n\ndef get_slice(x, indices):\n \"\"\"Return a slice of an array, following Numpy's style.\n\n Parameters\n ----------\n x : array-like, shape=[dim]\n Initial array.\n indices : iterable(iterable(int))\n Indices which are kept along each axis, starting from 0.\n\n Returns\n -------\n slice : array-like\n Slice of x given by indices.\n\n Notes\n -----\n This follows Numpy's convention: indices are grouped by axis.\n\n Examples\n --------\n >>> a = np.array(range(30)).reshape(3,10)\n >>> get_slice(a, ((0, 2), (8, 9)))\n array([8, 29])\n \"\"\"\n return x[indices]\n\n\ndef vectorize(x, pyfunc, multiple_args=False, signature=None, **kwargs):\n if multiple_args:\n return np.vectorize(pyfunc, signature=signature)(*x)\n return np.vectorize(pyfunc, signature=signature)(x)\n\n\ndef cast(x, dtype):\n return x.astype(dtype)\n\n\ndef set_diag(x, new_diag):\n \"\"\"Set the diagonal along the last two axis.\n\n Parameters\n ----------\n x : array-like, shape=[dim]\n Initial array.\n new_diag : array-like, shape=[dim[-2]]\n Values to set on the diagonal.\n\n Returns\n -------\n None\n\n Notes\n -----\n This mimics tensorflow.linalg.set_diag(x, new_diag), when new_diag is a\n 1-D array, but modifies x instead of creating a copy.\n \"\"\"\n arr_shape = x.shape\n x[..., range(arr_shape[-2]), range(arr_shape[-1])] = new_diag\n return x\n\n\ndef ndim(x):\n return x.ndim\n\n\ndef copy(x):\n return x.copy()\n\n\ndef array_from_sparse(indices, data, target_shape):\n \"\"\"Create an array of given shape, with values at specific indices.\n\n The rest of the array will be filled with zeros.\n\n Parameters\n ----------\n indices : iterable(tuple(int))\n Index of each element which will be assigned a specific value.\n data : iterable(scalar)\n Value associated at each index.\n target_shape : tuple(int)\n Shape of the output array.\n\n Returns\n -------\n a : array, shape=target_shape\n Array of zeros with specified values assigned to specified indices.\n \"\"\"\n return array(coo_matrix((data, list(zip(*indices))), target_shape).todense())\n\n\ndef vec_to_diag(vec):\n \"\"\"Convert vector to diagonal matrix.\"\"\"\n d = vec.shape[-1]\n return np.squeeze(vec[..., None, :] * np.eye(d)[None, :, :])\n\n\ndef tril_to_vec(x, k=0):\n n = x.shape[-1]\n rows, cols = tril_indices(n, k=k)\n return x[..., rows, cols]\n\n\ndef triu_to_vec(x, k=0):\n n = x.shape[-1]\n rows, cols = triu_indices(n, k=k)\n return x[..., rows, cols]\n\n\ndef mat_from_diag_triu_tril(diag, tri_upp, tri_low):\n \"\"\"Build matrix from given components.\n\n Forms a matrix from diagonal, strictly upper triangular and\n strictly lower traingular parts.\n\n Parameters\n ----------\n diag : array_like, shape=[..., n]\n tri_upp : array_like, shape=[..., (n * (n - 1)) / 2]\n tri_low : array_like, shape=[..., (n * (n - 1)) / 2]\n\n Returns\n -------\n mat : array_like, shape=[..., n, n]\n \"\"\"\n n = diag.shape[-1]\n (i,) = np.diag_indices(n, ndim=1)\n j, k = np.triu_indices(n, k=1)\n mat = np.zeros(diag.shape + (n,))\n mat[..., i, i] = diag\n mat[..., j, k] = tri_upp\n mat[..., k, j] = tri_low\n return mat\n\n\ndef ravel_tril_indices(n, k=0, m=None):\n if m is None:\n size = (n, n)\n else:\n size = (n, m)\n idxs = np.tril_indices(n, k, m)\n return np.ravel_multi_index(idxs, size)\n",
"\"\"\"Plot the result of a KNN classification on the sphere.\"\"\"\n\nimport logging\nimport os\n\nimport matplotlib.pyplot as plt\n\nimport geomstats.backend as gs\nimport geomstats.visualization as visualization\nfrom geomstats.geometry.hypersphere import Hypersphere\nfrom geomstats.learning.knn import KNearestNeighborsClassifier\n\n\ndef main():\n \"\"\"Plot the result of a KNN classification on the sphere.\"\"\"\n sphere = Hypersphere(dim=2)\n sphere_distance = sphere.metric.dist\n\n n_labels = 2\n n_samples_per_dataset = 10\n n_targets = 200\n\n dataset_1 = sphere.random_von_mises_fisher(\n kappa=10, n_samples=n_samples_per_dataset\n )\n dataset_2 = -sphere.random_von_mises_fisher(\n kappa=10, n_samples=n_samples_per_dataset\n )\n training_dataset = gs.concatenate((dataset_1, dataset_2), axis=0)\n labels_dataset_1 = gs.zeros([n_samples_per_dataset], dtype=gs.int64)\n labels_dataset_2 = gs.ones([n_samples_per_dataset], dtype=gs.int64)\n labels = gs.concatenate((labels_dataset_1, labels_dataset_2))\n target = sphere.random_uniform(n_samples=n_targets)\n\n neigh = KNearestNeighborsClassifier(n_neighbors=2, distance=sphere_distance)\n neigh.fit(training_dataset, labels)\n target_labels = neigh.predict(target)\n\n plt.figure(0)\n ax = plt.subplot(111, projection=\"3d\")\n plt.title(\"Training set\")\n sphere_plot = visualization.Sphere()\n sphere_plot.draw(ax=ax)\n for i_label in range(n_labels):\n points_label_i = training_dataset[labels == i_label, ...]\n sphere_plot.draw_points(ax=ax, points=points_label_i)\n\n plt.figure(1)\n ax = plt.subplot(111, projection=\"3d\")\n plt.title(\"Classification\")\n sphere_plot = visualization.Sphere()\n sphere_plot.draw(ax=ax)\n for i_label in range(n_labels):\n target_points_label_i = target[target_labels == i_label, ...]\n sphere_plot.draw_points(ax=ax, points=target_points_label_i)\n\n plt.show()\n\n\nif __name__ == \"__main__\":\n if os.environ[\"GEOMSTATS_BACKEND\"] == \"tensorflow\":\n logging.info(\n \"Examples with visualizations are only implemented \"\n \"with numpy backend.\\n\"\n \"To change backend, write: \"\n \"export GEOMSTATS_BACKEND = 'numpy'.\"\n )\n else:\n main()\n"
] | [
[
"sklearn.datasets.load_iris"
],
[
"matplotlib.pyplot.legend",
"matplotlib.patches.Patch",
"matplotlib.pyplot.title",
"matplotlib.pyplot.scatter",
"matplotlib.pyplot.subplots",
"matplotlib.pyplot.show",
"matplotlib.pyplot.tick_params"
],
[
"numpy.triu_indices",
"numpy.tril_indices",
"numpy.arange",
"numpy.eye",
"numpy.dtype",
"numpy.vectorize",
"numpy.equal",
"numpy.ravel_multi_index",
"numpy.diag_indices",
"numpy.array",
"numpy.zeros"
],
[
"matplotlib.pyplot.subplot",
"matplotlib.pyplot.show",
"matplotlib.pyplot.title",
"matplotlib.pyplot.figure"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
MuhammadEzzatHBK/CyclopeptideSequencing | [
"cd07045169758478b4845a54d5710bd329a836ca"
] | [
"test/testing.py"
] | [
"# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Sun May 16 09:31:53 2021\n\n@author: Muhammad Ayman Ezzat \n Youmna Magdy Abdullah\n\"\"\"\nfrom algorithms import branch_and_bound\nimport timeit\nimport pandas as pd\n\n''' Accuracy Testing '''\nLabSpectrum = [97, 97, 99, 101, 103, 196, 198, 198, 200, 202, 295,\n 297, 299, 299, 301, 394, 396, 398, 400, 400, 497]\n\nLabResults = sorted(['PVCPT', 'PTPVC', 'PTPCV', 'PCVPT', 'VPTPC',\n 'VCPTP', 'TPVCP', 'TPCVP', 'CPTPV', 'CVPTP'])\n\nAssignmentResults = branch_and_bound(LabSpectrum)\n\nprint('Input: ', LabSpectrum)\nprint('Provided Lab Results: ', *LabResults)\nprint('Our Assignment Results: ', *AssignmentResults)\nprint('Are they identical? ', LabResults == AssignmentResults)\n\n''' Perforamnce Testing '''\ntime_taken = []\n\nfor i in range(500):\n start = timeit.timeit()\n branch_and_bound(LabSpectrum)\n end = timeit.timeit()\n time_taken.append(abs(end - start))\n\ndata = {'duration' : time_taken}\nDataFrame = pd.DataFrame(data)\nDataFrame.to_csv('test_data.csv')"
] | [
[
"pandas.DataFrame"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"0.23",
"0.21",
"2.0",
"1.4",
"0.19",
"1.1",
"1.5",
"1.2",
"0.24",
"0.20",
"1.0",
"0.25",
"1.3"
],
"scipy": [],
"tensorflow": []
}
] |
Vizards8/pytorch-spine-segmentation | [
"588b7e7b09c5a370e337e2f12614df69d177ccaa"
] | [
"utils/metrics.py"
] | [
"import torch\nimport torch.nn as nn\nimport numpy as np\nimport math\nimport scipy.spatial\nimport scipy.ndimage.morphology\n\n\"\"\"\nTrue Positive （真正， TP）预测为正的正样本\nTrue Negative（真负 , TN）预测为负的负样本 \nFalse Positive （假正， FP）预测为正的负样本\nFalse Negative（假负 , FN）预测为负的正样本\n\"\"\"\n\n\ndef metrics(predict, label, out_class):\n \"\"\"Calculate the required metrics\n pred = label = [BS, class_num, H, W]\n \"\"\"\n IOU_list = []\n Dice_list = []\n false_positive_rate_list = []\n false_negative_rate_list = []\n acc = []\n for i in range(1, out_class):\n N = label.size(0)\n # indices = []\n # # 根据batch_size筛去全0label，有标签才计算评价指标\n # for j in range(N):\n # gt_true = torch.sum(label[j, i, :, :])\n # if gt_true:\n # indice.append(j)\n #\n # if indices:\n Dice_list.append(diceCoeffv2(predict[:, i, :, :], label[:, i, :, :]))\n IOU_list.append(IOU(predict[:, i, :, :], label[:, i, :, :]))\n FP_FN_rate_list = FP_FN_rate(predict[:, i, :, :], label[:, i, :, :])\n false_positive_rate_list.append(FP_FN_rate_list[0])\n false_negative_rate_list.append(FP_FN_rate_list[1])\n # accu = pixel_accuracy(predict[indices, i, :, :], label[indices, i, :, :])\n # if accu > 0.9:\n # print(f'slice id:{i}, acc:{accu}')\n acc.append(pixel_accuracy(predict[:, i, :, :], label[:, i, :, :]))\n # return mean(IOU_list), mean(Dice_list), mean(acc), mean(false_positive_rate_list), mean(false_negative_rate_list)\n return mean(IOU_list), Dice_list, mean(acc), mean(false_positive_rate_list), mean(false_negative_rate_list)\n\n\ndef mean(list):\n \"\"\"计算平均值\"\"\"\n if not len(list):\n return 0\n return sum(list) / len(list)\n\n\ndef mean_class(list):\n \"\"\"分别计算每个class平均值，返回list\"\"\"\n res = []\n for i in list:\n if not len(i):\n print('Warning class missing!')\n res.append(0)\n else:\n res.append(mean(i).item())\n return res\n\n\ndef batch_pix_accuracy(predict, target):\n \"\"\"Batch Pixel Accuracy\n Args:\n predict: input 4D tensor\n target: label 3D tensor\n \"\"\"\n _, predict = torch.max(predict, 1)\n predict = predict.cpu().numpy() + 1\n target = target.cpu().numpy() + 1\n pixel_labeled = np.sum(target > 0)\n pixel_correct = np.sum((predict == target) * (target > 0))\n assert pixel_correct <= pixel_labeled, \\\n \"Correct area should be smaller than Labeled\"\n return pixel_correct, pixel_labeled\n\n\ndef batch_intersection_union(predict, target, nclass):\n \"\"\"Batch Intersection of Union\n Args:\n predict: input 4D tensor\n target: label 3D tensor\n nclass: number of categories (int)\n \"\"\"\n _, predict = torch.max(predict, 1)\n mini = 1\n maxi = nclass\n nbins = nclass\n predict = predict.cpu().numpy() + 1\n target = target.cpu().numpy() + 1\n\n predict = predict * (target > 0).astype(predict.dtype)\n intersection = predict * (predict == target)\n # areas of intersection and union\n area_inter, _ = np.histogram(intersection, bins=nbins, range=(mini, maxi))\n area_pred, _ = np.histogram(predict, bins=nbins, range=(mini, maxi))\n area_lab, _ = np.histogram(target, bins=nbins, range=(mini, maxi))\n area_union = area_pred + area_lab - area_inter\n assert (area_inter <= area_union).all(), \\\n \"Intersection area should be smaller than Union area\"\n return area_inter, area_union\n\n\ndef intersection_and_union(im_pred, im_lab, num_class):\n im_pred = np.asarray(im_pred)\n im_lab = np.asarray(im_lab)\n # Remove classes from unlabeled pixels in gt image.\n im_pred = im_pred * (im_lab > 0)\n # Compute area intersection:\n intersection = im_pred * (im_pred == im_lab)\n area_inter, _ = np.histogram(intersection, bins=num_class - 1,\n range=(1, num_class - 1))\n # Compute area union:\n area_pred, _ = np.histogram(im_pred, bins=num_class - 1,\n range=(1, num_class - 1))\n area_lab, _ = np.histogram(im_lab, bins=num_class - 1,\n range=(1, num_class - 1))\n area_union = area_pred + area_lab - area_inter\n return area_inter, area_union\n\n\ndef diceCoeff(pred, gt, smooth=1e-5, ):\n r\"\"\" computational formula：\n dice = (2 * (pred ∩ gt)) / |pred| + |gt|\n |pred|:pred中的元素和\n \"\"\"\n\n N = gt.size(0)\n pred_flat = pred.view(N, -1)\n gt_flat = gt.view(N, -1)\n\n intersection = (pred_flat * gt_flat).sum(1)\n unionset = pred_flat.sum(1) + gt_flat.sum(1)\n score = (2 * intersection + smooth) / (unionset + smooth)\n\n return score.sum() / N\n\n\ndef diceFlat(pred, gt, smooth=1e-5):\n intersection = ((pred * gt).sum()).item()\n\n unionset = (pred.sum() + gt.sum()).item()\n score = (2 * intersection + smooth) / (unionset + smooth)\n return score\n\n\ndef diceCoeffv2(pred, gt, eps=1e-5):\n r\"\"\" computational formula：\n dice = (2 * tp) / (2 * tp + fp + fn)\n \"\"\"\n\n N = gt.size(0)\n pred_flat = pred.view(N, -1)\n gt_flat = gt.view(N, -1)\n\n tp = torch.sum(gt_flat * pred_flat, dim=1)\n fp = torch.sum(pred_flat, dim=1) - tp\n fn = torch.sum(gt_flat, dim=1) - tp\n score = (2 * tp + eps) / (2 * tp + fp + fn + eps)\n return score.sum() / N\n\n\ndef IOU(pred, gt, eps=1e-5):\n r\"\"\" computational formula：\n IOU = pred ∩ gt / pred ∪ gt\n IOU = tp / (tp + fp + fn)\n \"\"\"\n\n N = gt.size(0)\n pred_flat = pred.view(N, -1)\n gt_flat = gt.view(N, -1)\n\n tp = torch.sum((pred_flat != 0) * (gt_flat != 0), dim=1)\n fp = torch.sum((pred_flat != 0) * (gt_flat == 0), dim=1)\n tn = torch.sum((pred_flat == 0) * (gt_flat == 0), dim=1)\n fn = torch.sum((pred_flat == 0) * (gt_flat != 0), dim=1)\n score = (tp + eps) / (tp + fp + fn + eps)\n\n return score.sum() / N\n\n\ndef FP_FN_rate(pred, gt, eps=1e-5):\n r\"\"\"computational formula：\n False_Positive_rate = fp / (fp + tn)\n False_Negtive_rate = fn / (fn + tp)\n \"\"\"\n\n N = gt.size(0)\n pred_flat = pred.view(N, -1)\n gt_flat = gt.view(N, -1)\n\n tp = torch.sum((pred_flat != 0) * (gt_flat != 0), dim=1)\n fp = torch.sum((pred_flat != 0) * (gt_flat == 0), dim=1)\n tn = torch.sum((pred_flat == 0) * (gt_flat == 0), dim=1)\n fn = torch.sum((pred_flat == 0) * (gt_flat != 0), dim=1)\n\n false_positive_rate = fp / (fp + tn + eps)\n false_negtive_rate = fn / (fn + tp + eps)\n return false_positive_rate.sum() / N, false_negtive_rate.sum() / N\n\n\ndef pixel_accuracy(pred, gt, eps=1e-5):\n \"\"\"TP / (TP + FN)\"\"\"\n N = gt.size(0)\n pred_flat = pred.view(N, -1)\n gt_flat = gt.view(N, -1)\n\n tp = torch.sum((pred_flat != 0) * (gt_flat != 0), dim=1)\n fn = torch.sum((pred_flat == 0) * (gt_flat != 0), dim=1)\n\n score = (tp.float() + eps) / ((tp + fn).float() + eps)\n # if score < 0.01:\n # print(\n # f'score:{score.item()}, gt:{torch.sum(gt_flat, dim=1).item()}, pred:{torch.sum(pred_flat, dim=1).item()}, tp:{tp.item()}, fn:{fn.item()}')\n return score.sum() / N\n\n\ndef diceCoeffv3(pred, gt, eps=1e-5):\n r\"\"\" computational formula：\n dice = (2 * tp) / (2 * tp + fp + fn)\n \"\"\"\n\n N = gt.size(0)\n pred_flat = pred.view(N, -1)\n gt_flat = gt.view(N, -1)\n\n tp = torch.sum((pred_flat != 0) * (gt_flat != 0), dim=1)\n fp = torch.sum((pred_flat != 0) * (gt_flat == 0), dim=1)\n fn = torch.sum((pred_flat == 0) * (gt_flat != 0), dim=1)\n # 转为float，以防long类型之间相除结果为0\n score = (2 * tp + eps).float() / (2 * tp + fp + fn + eps).float()\n\n return score.sum() / N\n\n\ndef jaccard(pred, gt, eps=1e-5):\n \"\"\"TP / (TP + FP + FN)\"\"\"\n\n N = gt.size(0)\n pred_flat = pred.view(N, -1)\n gt_flat = gt.view(N, -1)\n tp = torch.sum((pred_flat != 0) * (gt_flat != 0))\n fp = torch.sum((pred_flat != 0) * (gt_flat == 0))\n fn = torch.sum((pred_flat == 0) * (gt_flat != 0))\n\n score = (tp.float() + eps) / ((tp + fp + fn).float() + eps)\n return score.sum() / N\n\n\ndef jaccardFlat(pred, gt, eps=1e-5):\n pred_flat = pred.squeeze()\n gt_flat = gt.squeeze()\n tp = torch.sum((pred_flat != 0) * (gt_flat != 0))\n fp = torch.sum((pred_flat != 0) * (gt_flat == 0))\n fn = torch.sum((pred_flat == 0) * (gt_flat != 0))\n score = (tp.float() + eps) / ((tp + fp + fn).float() + eps)\n return score\n\n\ndef jaccardv2(pred, gt, eps=1e-5):\n \"\"\"TP / (TP + FP + FN)\"\"\"\n\n N = gt.size(0)\n pred_flat = pred.view(N, -1)\n gt_flat = gt.view(N, -1)\n\n tp = torch.sum(gt_flat * pred_flat, dim=1)\n fp = torch.sum(pred_flat, dim=1) - tp\n fn = torch.sum(gt_flat, dim=1) - tp\n\n score = (tp + eps).float() / (tp + fp + fn + eps).float()\n return score.sum() / N\n\n\ndef tversky(pred, gt, eps=1e-5, alpha=0.7):\n \"\"\"TP / (TP + (1-alpha) * FP + alpha * FN)\"\"\"\n N = gt.size(0)\n pred_flat = pred.view(N, -1)\n gt_flat = gt.view(N, -1)\n\n tp = torch.sum(gt_flat * pred_flat, dim=1)\n fp = torch.sum(pred_flat, dim=1) - tp\n fn = torch.sum(gt_flat, dim=1) - tp\n score = (tp + eps) / (tp + (1 - alpha) * fp + alpha * fn + eps)\n return score.sum() / N\n\n\ndef accuracy(pred, gt, eps=1e-5):\n \"\"\"(TP + TN) / (TP + FP + FN + TN)\"\"\"\n\n N = gt.size(0)\n pred_flat = pred.view(N, -1)\n gt_flat = gt.view(N, -1)\n\n tp = torch.sum((pred_flat != 0) * (gt_flat != 0), dim=1)\n fp = torch.sum((pred_flat != 0) * (gt_flat == 0), dim=1)\n tn = torch.sum((pred_flat == 0) * (gt_flat == 0), dim=1)\n fn = torch.sum((pred_flat == 0) * (gt_flat != 0), dim=1)\n\n score = ((tp + tn).float() + eps) / ((tp + fp + tn + fn).float() + eps)\n return score.sum() / N\n\n\ndef precision(pred, gt, eps=1e-5):\n \"\"\"TP / (TP + FP)\"\"\"\n\n N = gt.size(0)\n pred_flat = pred.view(N, -1)\n gt_flat = gt.view(N, -1)\n tp = torch.sum((pred_flat != 0) * (gt_flat != 0))\n fp = torch.sum((pred_flat != 0) * (gt_flat == 0))\n\n score = (tp.float() + eps) / ((tp + fp).float() + eps)\n\n return score.sum() / N\n\n\ndef specificity(pred, gt, eps=1e-5):\n \"\"\"TN / (TN + FP)\"\"\"\n\n N = gt.size(0)\n pred_flat = pred.view(N, -1)\n gt_flat = gt.view(N, -1)\n fp = torch.sum((pred_flat != 0) * (gt_flat == 0))\n tn = torch.sum((pred_flat == 0) * (gt_flat == 0))\n\n score = (tn.float() + eps) / ((fp + tn).float() + eps)\n\n return score.sum() / N\n\n\nif __name__ == '__main__':\n # shape = torch.Size([2, 3, 4, 4])\n # 模拟batch_size = 2\n '''\n 1 0 0= bladder\n 0 1 0 = tumor\n 0 0 1= background \n '''\n pred = torch.Tensor([[\n [[0, 1, 0, 0],\n [1, 0, 0, 1],\n [1, 0, 0, 1],\n [0, 1, 1, 0]],\n [[0, 0, 0, 0],\n [0, 0, 0, 0],\n [0, 1, 1, 0],\n [0, 0, 0, 0]],\n [[1, 0, 1, 1],\n [0, 1, 1, 0],\n [0, 0, 0, 0],\n [1, 0, 0, 1]]]\n ])\n\n gt = torch.Tensor([[\n [[0, 1, 1, 0],\n [1, 0, 0, 1],\n [1, 0, 0, 1],\n [0, 1, 1, 0]],\n [[0, 0, 0, 0],\n [0, 0, 0, 0],\n [0, 1, 1, 0],\n [0, 0, 0, 0]],\n [[1, 0, 0, 1],\n [0, 1, 1, 0],\n [0, 0, 0, 0],\n [1, 0, 0, 1]]]\n ])\n\n dice1 = diceCoeff(pred[:, 0:1, :], gt[:, 0:1, :])\n dice2 = jaccard(pred[:, 0:1, :], gt[:, 0:1, :])\n dice3 = diceCoeffv3(pred[:, 0:1, :], gt[:, 0:1, :])\n print(dice1, dice2, dice3)\n"
] | [
[
"torch.max",
"torch.Tensor",
"numpy.asarray",
"torch.sum",
"numpy.histogram",
"numpy.sum"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
AIM3-RUC/VideoIC | [
"ea324938e839a679324f42161d195f5bef3db26f"
] | [
"src/MML-CG/train.py"
] | [
"'''\n Re-organize the MMIG model\n 2021-09-20\n'''\n\nimport os\nimport sys\nimport time\nimport json\nimport logging\nimport argparse\n\nimport torch\nimport torch.optim as Optim\nfrom torch.autograd import Variable\n\nimport utils\nimport modules\nimport dataset\nimport metrics\n\n\n# set gpu\nos.environ[\"CUDA_VISIBLE_DEVICES\"] = '0,1,2,3'\n\nparser = argparse.ArgumentParser(description='train.py')\n# set model parameters\nparser.add_argument('-n_emb', type=int, default=512, help='Embedding size')\nparser.add_argument('-n_hidden', type=int, default=512, help='Hidden size')\nparser.add_argument('-n_head', type=int, default=8, help='Number of head')\nparser.add_argument('-n_block', type=int, default=6, help=\"Number of block\") \n\nparser.add_argument('-max_len', type=int, default=20, help=\"Limited length for text\")\nparser.add_argument('-time_range', type=int, default=5, help='Time range')\nparser.add_argument('-max_cnum', type=int, default=15, help=\"Max comments each second\")\nparser.add_argument('-beam_size', type=int, default=1, help=\"Bean size\") # 1 means greedy search, which is the same with our paper implement\n\n# training setting\nparser.add_argument('-batch_size', type=int, default=32, help='Batch size')\nparser.add_argument('-epoch', type=int, default=100, help='Number of epoch')\nparser.add_argument('-dropout', type=float, default=0.2, help='Dropout rate')\nparser.add_argument('-lr', type=float, default=1e-3, help=\"Learning rate\")\nparser.add_argument('-weight_decay', type=float, default=0.001, help=\"Learning rate\")\nparser.add_argument('-early_stop', type=float, default=20, help=\"Early Stop\")\n\n# data path\nparser.add_argument('-data_path', type=str, default=None, help='dict and image path')\nparser.add_argument('-out_path', type=str, default=None, help='out path')\nparser.add_argument('-outfile', type=str, default='out.json', help='outfile for generation')\nparser.add_argument('-restore', type=str, default=None, help=\"Restoring model path\")\nparser.add_argument('-mode', type=str, default=None)\nargs = parser.parse_args()\n\n# set random seed\ntorch.manual_seed(116)\ntorch.cuda.manual_seed(116)\n\nlogger = logging.getLogger()\nlogger.setLevel(logging.INFO)\n\n# log file\nif args.mode == 'train':\n if not os.path.exists(args.out_path):\n os.mkdir(args.out_path)\n logger.addHandler(logging.FileHandler(os.path.join(args.out_path, 'log'), \"w\"))\n \n# load img\nimages = utils.load_images(args.data_path)\n\n# load vocabs\nvocabs, rev_vocabs = utils.load_vocabs(args.data_path)\n#logger.info('Load vocabs file ' + str(len(vocabs)))\n\ndef get_dataset(data_path, images, is_train, set_name):\n return dataset.Dataset(data_path = data_path,\n vocabs = vocabs,\n rev_vocabs=rev_vocabs,\n images = images,\n left_time_range = args.time_range,\n right_time_range = args.time_range,\n max_len = args.max_len,\n max_cnum = args.max_cnum,\n is_train = is_train,\n set_name = set_name)\n \ndef get_dataloader(dataset, batch_size, is_train):\n return torch.utils.data.DataLoader(dataset = dataset,\n batch_size = batch_size,\n shuffle = is_train)\n \ndef save_model(path, model):\n model_state_dict = model.state_dict()\n torch.save(model_state_dict, path)\n\n\ndef train():\n # load dataset\n train_set = get_dataset(data_path = os.path.join(args.data_path, 'train.json'),\n images = images,\n is_train = True)\n valid_set = get_dataset(data_path = os.path.join(args.data_path, 'dev.json'),\n images = images,\n is_train = False)\n train_batch = get_dataloader(dataset = train_set,\n batch_size = args.batch_size,\n is_train = True)\n \n model = modules.Model(n_embs = args.n_emb,\n n_hidden = args.n_hidden,\n n_head = args.n_head,\n n_block = args.n_block,\n max_len = args.max_len,\n dropout = args.dropout,\n vocab_size = len(vocabs),\n left_range = args.time_range,\n right_range = args.time_range)\n \n if args.restore is not None:\n model_dict = torch.load(args.restore)\n model.load_state_dict(model_dict)\n \n model.cuda()\n optim = Optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), lr = args.lr, weight_decay=args.weight_decay)\n best_score = -100000\n early_stop_count = 0\n \n for i in range(args.epoch):\n model.train()\n report_loss, start_time, n_batches = 0, time.time(), 0\n \n for batch in train_batch:\n model.zero_grad()\n V, S, Y = batch\n \n # V: video feature\n V = Variable(V).cuda()\n # S: Surrounding comments\n S = Variable(S).cuda()\n # Y: Ground truth\n Y = Variable(Y).cuda()\n \n multi_gpu_loss = model(V, S, Y)\n loss = torch.sum(multi_gpu_loss)\n loss.backward()\n optim.step()\n \n report_loss += torch.mean(multi_gpu_loss).item()\n n_batches += 1\n \n # report loss\n print('\\nEpoch: %d, report_loss: %.3f, time: %.2f'\n % (i+1, report_loss / n_batches, time.time() - start_time))\n logger.info('\\nEpoch '+str(i) + ', report_loss: '+str(report_loss/n_batches) + ' , time: ' + str(time.time() - start_time))\n \n # eval\n score = eval(model, valid_set)\n if score > best_score:\n best_score = score\n print('Best score ', best_score)\n save_model(os.path.join(args.out_path, 'best_checkpoint.pt'), model)\n logger.info('Evaluation score ' + str(score) + ', Best score ' + str(best_score))\n early_stop_count = 0\n else:\n early_stop_count += 1\n save_model(os.path.join(args.out_path, 'checkpoint.pt'), model)\n print('Evaluation score ', score, '. Best score ', best_score, '. Early stop count ', early_stop_count)\n if early_stop_count == args.early_stop:\n sys.exit()\n return 0\n\ndef eval(model, valid_set):\n print('Start Evaluation ... ')\n start_time = time.time()\n model.eval()\n valid_batch = get_dataloader(valid_set, args.batch_size, is_train=False)\n loss = 0\n total_batch = 0\n with torch.no_grad():\n for batch in valid_batch:\n V, S, Y = batch\n V = Variable(V).cuda()\n S = Variable(S).cuda()\n Y = Variable(Y).cuda()\n loss += torch.mean(model(V, S, Y)).item()\n total_batch += 1\n loss = loss / total_batch\n print('Loss: ', loss)\n print(\"evaluting time:\", time.time() - start_time)\n return -loss\n\ndef test_generation():\n # build model\n test_set = get_dataset(data_path = os.path.join(args.data_path, 'test.json'),\n images = images,\n is_train = False,\n set_name = 'test')\n \n model = modules.Model(n_embs = args.n_emb,\n n_hidden = args.n_hidden,\n n_head = args.n_head,\n n_block = args.n_block,\n max_len = args.max_len,\n dropout = args.dropout,\n vocab_size = len(vocabs),\n left_range = args.time_range,\n right_range = args.time_range)\n \n if args.restore is not None:\n model_dict = torch.load(args.restore)\n model.load_state_dict({k.replace('module.', ''):v for k,v in model_dict.items()})\n else:\n print('Error! Fail to load model for test mode')\n sys.exit()\n \n model.cuda()\n model.eval()\n \n with torch.no_grad():\n with open(args.outfile, 'w') as fout:\n for i in range(len(test_set)):\n data = test_set.get_data(i)\n V = data['video_feature']\n S = data['context_feature']\n V = Variable(V).cuda()\n S = Variable(S).cuda()\n comment_ids = model.generate(V, S, BOS_token=vocabs['<BOS>'], EOS_token=vocabs['<EOS>'], beam_size=args.beam_size).data.tolist()\n comment = transform(comment_ids[0])\n for key in data:\n print(key)\n sample = {'video_time': data['video_time'],\n 'context': data['context'],\n 'comment': data['comment'],\n 'candidate': data['candidate'],\n 'generation': comment}\n term = json.dumps(sample, ensure_ascii=False)\n fout.write(str(term)+'\\n')\n\ndef transform(ids):\n sentences = []\n for wid in ids:\n if wid == vocabs['<BOS>']:\n continue\n if wid == vocabs['<EOS>']:\n break\n sentences.append(rev_vocabs[wid])\n return sentences\n\ndef test_ranking():\n # build model\n test_set = get_dataset(data_path = os.path.join(args.data_path, 'test.json'),\n images = images,\n is_train = False,\n set_name = 'test')\n \n model = modules.Model(n_embs = args.n_emb,\n n_hidden = args.n_hidden,\n n_head = args.n_head,\n n_block = args.n_block,\n max_len = args.max_len,\n dropout = args.dropout,\n vocab_size = len(vocabs),\n left_range = args.time_range,\n right_range = args.time_range)\n \n if args.restore is not None:\n model_dict = torch.load(args.restore)\n model.load_state_dict({k.replace('module.', ''):v for k,v in model_dict.items()})\n else:\n print('Error! Fail to load model for test mode')\n sys.exit()\n \n model.cuda()\n model.eval()\n \n predictions, references = [], []\n \n with torch.no_grad():\n for i in range(len(test_set)):\n data = test_set.get_data(i)\n V = Variable(data['video_feature']).cuda()\n S = Variable(data['context_feature']).cuda()\n C = Variable(torch.stack(data['candidate_feature'])).cuda()\n comment_ids = model.ranking(V, S, C).data\n \n candidate = []\n comments = list(data['candidate'].keys())\n for id in comment_ids:\n candidate.append(comments[id])\n predictions.append(candidate)\n references.append(data['candidate'])\n\n recall_1 = metrics.recall(predictions, references, 1)\n recall_5 = metrics.recall(predictions, references, 5)\n recall_10 = metrics.recall(predictions, references, 10)\n mr = metrics.mean_rank(predictions, references)\n mrr = metrics.mean_reciprocal_rank(predictions, references)\n print('Report ranking result')\n print('Recall 1: ', recall_1)\n print('Recall 5: ', recall_5)\n print('Recall 10: ', recall_10)\n print('MR: ', mr)\n print('MRR: ', mrr)\n\n\nif __name__ == '__main__':\n if args.mode == 'train':\n print('-----------Train Mode-----------')\n train()\n elif args.mode == 'generate':\n print('-----------Generation Mode-----------')\n test_generation()\n elif args.mode == 'ranking':\n print('-----------Ranking Mode-----------')\n test_ranking()\n else:\n print('Wrong Mode')"
] | [
[
"torch.mean",
"torch.cuda.manual_seed",
"torch.load",
"torch.manual_seed",
"torch.utils.data.DataLoader",
"torch.sum",
"torch.autograd.Variable",
"torch.no_grad",
"torch.stack",
"torch.save"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
Caged/splineworks | [
"0fad1e98ba6928f6ffeef0018a4d52696a38cce2"
] | [
"sandworks/generators/splines.py"
] | [
"from numpy import pi\nfrom numpy import array\nfrom numpy import linspace\nfrom numpy import arange\nfrom numpy import zeros\nfrom numpy import column_stack\nfrom numpy import array\nfrom time import time\nfrom math import radians\n\nimport cairocffi as cairo\nfrom sand import Sand\nfrom ..lib.sand_spline import SandSpline\nfrom ..lib.helpers import hex_to_rgb_decimal, SimpleLinearScale\n\n\ndef guide_iterator(x, y):\n while True:\n yield array([[x, y]])\n\n\ndef make_vertical_surface(sand, gamma, canvas_width, canvas_height, flipped_height):\n \"\"\"\n Make a vertical image\n \"\"\"\n sand.write_to_surface(gamma)\n surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, canvas_width, canvas_height)\n context = cairo.Context(surface)\n context.rotate(radians(90))\n context.translate(0, -flipped_height)\n context.scale(1.0, 1.0)\n context.set_source_surface(sand.sur, 0, 0)\n context.paint()\n\n return surface\n\n\ndef generate(args):\n # Number of lines\n line_count = args.lines\n\n width = args.width\n height = args.height\n\n if args.dir == 'vertical':\n width = args.height\n height = args.width\n\n xscale = SimpleLinearScale(domain=array([0, width]), range=array([0, 1]))\n yscale = SimpleLinearScale(domain=array([0, height]), range=array([0, 1]))\n\n # Margin as a pixel value of total size. Convert that margin to a number between 0..1\n # representing the percentage of total pixel size\n margin = args.margin\n margin_x = xscale(margin)\n margin_y = yscale(margin)\n\n # Output PNG gamma\n gamma = 1.5\n\n # What frame to write out\n save_frame = args.save_every\n\n # TODO: Step. Appears to be jitter multiplier for points along the spline\n # Causes the sand to be more \"windswept\" towards the later points\n step = 0.0000003 * 0.15\n\n # The number of points along the spline. More points means a denser-looking spline.\n point_count = 1000\n\n # Convert colors to RGB decimal\n sand_color = hex_to_rgb_decimal(args.color)\n bg_color = hex_to_rgb_decimal(args.bg_color)\n\n # Set alpha\n sand_color.append(0.001)\n bg_color.append(1)\n\n sand = Sand(width, height)\n sand.set_rgba(sand_color)\n sand.set_bg(bg_color)\n\n splines = []\n\n # For each y column\n for index, ypos in enumerate(linspace(margin_y, 1.0 - margin_y, line_count)):\n # TODO: point_number? Appears to affect the tightness of the wave noise. That is, higher\n # values like 500 appear to produce more nodes in each spline, resulting in more noise\n # detail.\n pnum = 4 + index\n guide = guide_iterator(0.5, ypos)\n\n x = linspace(-1, 1.0, pnum) * (1.0 - 2 * margin_x) * 0.5\n y = zeros(pnum, 'float')\n path = column_stack([x, y])\n scale = arange(pnum).astype('float') * step\n\n spline = SandSpline(guide, path, point_count, scale)\n splines.append(spline)\n\n j = 0\n while True:\n for s in splines:\n start = time()\n xy = next(s)\n sand.paint_dots(xy)\n if j is not 0 and not j % (save_frame * line_count):\n frame_number = int(j / save_frame)\n file_name = '{}/{}-{}.png'.format(\n args.out_dir,\n int(time()),\n frame_number)\n\n if args.dir == 'vertical':\n surface = make_vertical_surface(sand, gamma, args.width, args.height, height)\n surface.write_to_png(file_name)\n else:\n sand.write_to_png(file_name, gamma)\n\n print('Saved frame {} in {}'.format(frame_number, time() - start))\n\n j += 1\n"
] | [
[
"numpy.linspace",
"numpy.arange",
"numpy.column_stack",
"numpy.array",
"numpy.zeros"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
devchai123/Paddle-Lite | [
"eea59b66f61bb2acad471010c9526eeec43a15ca",
"442d6996a59c3498eae27610d49a0d5b2c320f24"
] | [
"lite/tests/unittest_py/op/test_layer_norm_op.py",
"lite/tests/unittest_py/op/common/test_elementwise_pow_op_base.py"
] | [
"# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport sys\nsys.path.append('../')\n\nfrom auto_scan_test import AutoScanTest, IgnoreReasons\nfrom program_config import TensorConfig, ProgramConfig, OpConfig, CxxConfig, TargetType, PrecisionType, DataLayoutType, Place\nimport unittest\n\nimport hypothesis\nfrom hypothesis import given, settings, seed, example, assume\nimport hypothesis.strategies as st\nimport argparse\nimport numpy as np\nfrom functools import partial\n\n\nclass TestLayerNormOp(AutoScanTest):\n def __init__(self, *args, **kwargs):\n AutoScanTest.__init__(self, *args, **kwargs)\n self.enable_testing_on_place(\n TargetType.X86,\n PrecisionType.FP32,\n DataLayoutType.NCHW,\n thread=[1, 2])\n self.enable_testing_on_place(\n TargetType.ARM,\n PrecisionType.FP32,\n DataLayoutType.NCHW,\n thread=[1, 2, 4])\n\n def is_program_valid(self,\n program_config: ProgramConfig,\n predictor_config: CxxConfig) -> bool:\n return True\n\n def sample_program_configs(self, draw):\n in_shape = draw(\n st.lists(\n st.integers(\n min_value=1, max_value=64), min_size=4, max_size=4))\n epsilon = draw(st.floats(min_value=0.0001, max_value=0.0005))\n begin_norm_axis = draw(st.sampled_from([1, 2]))\n\n def generate_input(*args, **kwargs):\n return np.random.random(in_shape).astype(np.float32)\n\n channel_dim = 1\n for dim in range(begin_norm_axis, 4):\n channel_dim = channel_dim * in_shape[dim]\n\n def generate_scale(*args, **kwargs):\n return np.random.random([channel_dim]).astype(np.float32)\n\n def generate_bias(*args, **kwargs):\n return np.random.random([channel_dim]).astype(np.float32)\n\n run_op = OpConfig(\n type=\"layer_norm\",\n inputs={\n \"X\": [\"input_data\"],\n \"Scale\": [\"scale_data\"],\n \"Bias\": [\"bias_data\"]\n },\n outputs={\n \"Y\": [\"output_data\"],\n \"Mean\": [\"mean_data\"],\n \"Variance\": [\"var_data\"],\n },\n attrs={\"epsilon\": epsilon,\n \"begin_norm_axis\": begin_norm_axis})\n program_config = ProgramConfig(\n ops=[run_op],\n weights={},\n inputs={\n \"input_data\": TensorConfig(data_gen=partial(generate_input)),\n \"scale_data\": TensorConfig(data_gen=partial(generate_scale)),\n \"bias_data\": TensorConfig(data_gen=partial(generate_bias)),\n },\n outputs=[\"output_data\", \"mean_data\", \"var_data\"])\n return program_config\n\n def sample_predictor_configs(self):\n return self.get_predictor_configs(), [\"layer_norm\"], (5e-5, 5e-5)\n\n def add_ignore_pass_case(self):\n pass\n\n def test(self, *args, **kwargs):\n self.run_and_statis(quant=False, max_examples=25)\n\n\nif __name__ == \"__main__\":\n unittest.main(argv=[''])\n",
"# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport sys\nsys.path.append('..')\n\nfrom program_config import TensorConfig, ProgramConfig, OpConfig, CxxConfig, TargetType, PrecisionType, DataLayoutType, Place\nimport numpy as np\nfrom functools import partial\nfrom typing import Optional, List, Callable, Dict, Any, Set\nimport unittest\nimport hypothesis\nimport hypothesis.strategies as st\n\n\ndef sample_program_configs(draw):\n input_data_x_shape = draw(\n st.lists(\n st.integers(\n min_value=1, max_value=8), min_size=1, max_size=8))\n axis = draw(\n st.integers(\n min_value=-1, max_value=(len(input_data_x_shape) - 1)))\n input_data_y_shape = input_data_x_shape[axis:]\n\n def gen_input_data_x():\n return np.random.randint(\n 1, 3, size=(input_data_x_shape)).astype(np.int64)\n\n def gen_input_data_y():\n return np.random.randint(\n 1, 3, size=(input_data_y_shape)).astype(np.int64)\n\n elementwise_pow_op = OpConfig(\n type=\"elementwise_pow\",\n inputs={\"X\": [\"input_data_x\"],\n \"Y\": [\"input_data_y\"]},\n outputs={\"Out\": [\"output_data\"]},\n attrs={\"axis\": axis})\n program_config = ProgramConfig(\n ops=[elementwise_pow_op],\n weights={},\n inputs={\n \"input_data_x\": TensorConfig(data_gen=gen_input_data_x),\n \"input_data_y\": TensorConfig(data_gen=gen_input_data_y)\n },\n outputs=[\"output_data\"])\n return program_config\n"
] | [
[
"numpy.random.random"
],
[
"numpy.random.randint"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
camponogaraviera/qutip | [
"1b1f6dffcb3ab97f11b8c6114293e09f378d2e8f",
"1b1f6dffcb3ab97f11b8c6114293e09f378d2e8f"
] | [
"qutip/cy/br_codegen.py",
"doc/guide/scripts/ex_steady.py"
] | [
"import os\nimport numpy as np\nimport qutip.settings as qset\nfrom qutip.interpolate import Cubic_Spline\n_cython_path = os.path.dirname(os.path.abspath(__file__)).replace(\"\\\\\", \"/\")\n_include_string = \"'\"+_cython_path+\"/complex_math.pxi'\"\n__all__ = ['BR_Codegen']\n\n\nclass BR_Codegen(object):\n \"\"\"\n Class for generating Bloch-Redfield time-dependent code\n at runtime.\n \"\"\"\n def __init__(self, h_terms=None, h_td_terms=None, h_obj=None,\n c_terms=None, c_td_terms=None, c_obj=None,\n a_terms=None, a_td_terms=None,\n spline_count=[0,0],\n coupled_ops=[],\n coupled_lengths=[],\n coupled_spectra=[],\n config=None, sparse=False,\n use_secular=None,\n sec_cutoff=0.1,\n args=None,\n use_openmp=False,\n omp_thresh=None,\n omp_threads=None,\n atol=None):\n try:\n import cython\n except (ImportError, ModuleNotFoundError):\n raise ModuleNotFoundError(\"Cython is needed for \"\n \"time-depdendent brmesolve\")\n import sys\n import os\n sys.path.append(os.getcwd())\n\n # Hamiltonian time-depdendent pieces\n self.h_terms = h_terms # number of H pieces\n self.h_td_terms = h_td_terms\n self.h_obj = h_obj\n # Collapse operator time-depdendent pieces\n self.c_terms = c_terms # number of C pieces\n self.c_td_terms = c_td_terms\n self.c_obj = c_obj\n # BR operator time-depdendent pieces\n self.a_terms = a_terms # number of A pieces\n self.a_td_terms = a_td_terms\n self.spline_count = spline_count\n self.use_secular = int(use_secular)\n self.sec_cutoff = sec_cutoff\n self.args = args\n self.sparse = sparse\n self.spline = 0\n # Code generator properties\n self.code = [] # strings to be written to file\n self.level = 0 # indent level\n self.config = config\n if atol is None:\n self.atol = qset.atol\n else:\n self.atol = atol\n\n self.use_openmp = use_openmp\n self.omp_thresh = omp_thresh\n self.omp_threads = omp_threads\n\n self.coupled_ops = coupled_ops\n self.coupled_lengths = coupled_lengths\n self.coupled_spectra = coupled_spectra\n\n def write(self, string):\n \"\"\"write lines of code to self.code\"\"\"\n self.code.append(\" \" * self.level + string + \"\\n\")\n\n def file(self, filename):\n \"\"\"open file called filename for writing\"\"\"\n self.file = open(filename, \"w\")\n\n def generate(self, filename=\"rhs.pyx\"):\n \"\"\"generate the file\"\"\"\n for line in cython_preamble(self.use_openmp)+self.aop_td_funcs():\n self.write(line)\n\n # write function for Hamiltonian terms (there is always\n # be at least one term)\n for line in cython_checks() + self.ODE_func_header():\n self.write(line)\n self.indent()\n #Reset spline count\n self.spline = 0\n for line in self.func_vars()+self.ham_add_and_eigsolve()+ \\\n self.br_matvec_terms()+[\"\\n\"]:\n self.write(line)\n\n for line in self.func_end():\n self.write(line)\n self.dedent()\n\n self.file(filename)\n self.file.writelines(self.code)\n self.file.close()\n self.config.cgen_num += 1\n\n def indent(self):\n \"\"\"increase indention level by one\"\"\"\n self.level += 1\n\n def dedent(self):\n \"\"\"decrease indention level by one\"\"\"\n if self.level == 0:\n raise SyntaxError(\"Error in code generator\")\n self.level -= 1\n\n\n def _get_arg_str(self, args):\n if len(args) == 0:\n return ''\n\n ret = ''\n for name, value in self.args.items():\n if isinstance(value, np.ndarray):\n ret += \",\\n np.ndarray[np.%s_t, ndim=1] %s\" % \\\n (value.dtype.name, name)\n else:\n if isinstance(value, (int, np.int32, np.int64)):\n kind = 'int'\n elif isinstance(value, (float, np.float32, np.float64)):\n kind = 'float'\n elif isinstance(value, (complex, np.complex128)):\n kind = 'complex'\n #kind = type(value).__name__\n ret += \",\\n \" + kind + \" \" + name\n return ret\n\n\n def ODE_func_header(self):\n \"\"\"Creates function header for time-dependent ODE RHS.\"\"\"\n func_name = \"def cy_td_ode_rhs(\"\n # strings for time and vector variables\n input_vars = (\"\\n double t\" +\n \",\\n complex[::1] vec\")\n for k in range(self.h_terms):\n input_vars += (\",\\n \" +\n \"complex[::1,:] H%d\" % k)\n\n #Add array for each Cubic_Spline H term\n for htd in self.h_td_terms:\n if isinstance(htd, Cubic_Spline):\n if not htd.is_complex:\n input_vars += (\",\\n \" +\n \"double[::1] spline%d\" % self.spline)\n else:\n input_vars += (\",\\n \" +\n \"complex[::1] spline%d\" % self.spline)\n self.spline += 1\n\n\n for k in range(self.c_terms):\n input_vars += (\",\\n \" +\n \"complex[::1,:] C%d\" % k)\n\n #Add array for each Cubic_Spline c_op term\n for ctd in self.c_td_terms:\n if isinstance(ctd, Cubic_Spline):\n if not ctd.is_complex:\n input_vars += (\",\\n \" +\n \"double[::1] spline%d\" % self.spline)\n else:\n input_vars += (\",\\n \" +\n \"complex[::1] spline%d\" % self.spline)\n self.spline += 1\n\n\n #Add coupled a_op terms\n for _a in self.a_td_terms:\n if isinstance(_a, Cubic_Spline):\n if not _a.is_complex:\n input_vars += (\",\\n \" +\n \"double[::1] spline%d\" % self.spline)\n else:\n input_vars += (\",\\n \" +\n \"complex[::1] spline%d\" % self.spline)\n self.spline += 1\n\n\n #Add a_op terms\n for k in range(self.a_terms):\n input_vars += (\",\\n \" +\n \"complex[::1,:] A%d\" % k)\n\n\n input_vars += (\",\\n unsigned int nrows\")\n input_vars += self._get_arg_str(self.args)\n\n func_end = \"):\"\n return [func_name + input_vars + func_end]\n\n def func_vars(self):\n \"\"\"Writes the variables and their types & spmv parts\"\"\"\n func_vars = [\"\", \"cdef double complex * \" +\n 'out = <complex *>PyDataMem_NEW_ZEROED(nrows**2,sizeof(complex))']\n func_vars.append(\" \")\n return func_vars\n\n\n def aop_td_funcs(self):\n aop_func_str=[]\n spline_val = self.spline_count[0]\n coupled_val = 0\n kk = 0\n while kk < self.a_terms:\n if kk not in self.coupled_ops:\n aa = self.a_td_terms[kk]\n if isinstance(aa, str):\n aop_func_str += [\"cdef complex spectral{0}(double w, double t): return {1}\".format(kk, aa)]\n elif isinstance(aa, tuple):\n if isinstance(aa[0],str):\n str0 = aa[0]\n elif isinstance(aa[0],Cubic_Spline):\n if not aa[0].is_complex:\n aop_func_str += [\"cdef double[::1] spline{0} = np.array(\".format(spline_val)+np.array2string(aa[0].coeffs,separator=',',precision=16)+\",dtype=float)\"]\n str0 = \"interp(w, %s, %s, spline%s)\" % (aa[0].a, aa[0].b, spline_val)\n else:\n aop_func_str += [\"cdef complex[::1] spline{0} = np.array(\".format(spline_val)+np.array2string(aa[0].coeffs,separator=',',precision=16)+\",dtype=complex)\"]\n str0 = \"zinterp(w, %s, %s, spline%s)\" % (aa[0].a, aa[0].b, spline_val)\n spline_val += 1\n else:\n raise Exception('Error parsing tuple.')\n\n if isinstance(aa[1],str):\n str1 = aa[1]\n elif isinstance(aa[1],Cubic_Spline):\n if not aa[1].is_complex:\n aop_func_str += [\"cdef double[::1] spline{0} = np.array(\".format(spline_val)+np.array2string(aa[1].coeffs,separator=',',precision=16)+\",dtype=float)\"]\n str1 = \"interp(t, %s, %s, spline%s)\" % (aa[1].a, aa[1].b, spline_val)\n else:\n aop_func_str += [\"cdef complex[::1] spline{0} = np.array(\".format(spline_val)+np.array2string(aa[1].coeffs,separator=',',precision=16)+\",dtype=complex)\"]\n str1 = \"zinterp(t, %s, %s, spline%s)\" % (aa[1].a, aa[1].b, spline_val)\n spline_val += 1\n else:\n raise Exception('Error parsing tuple.')\n\n aop_func_str += [\"cdef complex spectral{0}(double w, double t): return ({1})*({2})\".format(kk, str0, str1)]\n else:\n raise Exception('Invalid a_td_term.')\n kk += 1\n else:\n aa = self.coupled_spectra[coupled_val]\n if isinstance(aa, str):\n aop_func_str += [\"cdef complex spectral{0}(double w, double t): return {1}\".format(kk, aa)]\n elif isinstance(aa, Cubic_Spline):\n if not aa[1].is_complex:\n aop_func_str += [\"cdef double[::1] spline{0} = np.array(\".format(spline_val)+np.array2string(aa[1].coeffs,separator=',',precision=16)+\",dtype=float)\"]\n str1 = \"interp(t, %s, %s, spline%s)\" % (aa[1].a, aa[1].b, spline_val)\n else:\n aop_func_str += [\"cdef complex[::1] spline{0} = np.array(\".format(spline_val)+np.array2string(aa[1].coeffs,separator=',',precision=16)+\",dtype=complex)\"]\n str1 = \"zinterp(t, %s, %s, spline%s)\" % (aa[1].a, aa[1].b, spline_val)\n spline_val += 1\n aop_func_str += [\"cdef complex spectral{0}(double w, double t): return {1}\".format(kk, str1)]\n kk += self.coupled_lengths[coupled_val]\n coupled_val += 1\n\n return aop_func_str\n\n\n def ham_add_and_eigsolve(self):\n ham_str = []\n #allocate initial zero-Hamiltonian and eigenvector array in Fortran-order\n ham_str += ['cdef complex[::1, :] H = farray_alloc(nrows)']\n ham_str += ['cdef complex[::1, :] evecs = farray_alloc(nrows)']\n #allocate double array for eigenvalues\n ham_str += ['cdef double * eigvals = <double *>PyDataMem_NEW_ZEROED(nrows,sizeof(double))']\n for kk in range(self.h_terms):\n if isinstance(self.h_td_terms[kk], Cubic_Spline):\n S = self.h_td_terms[kk]\n if not S.is_complex:\n td_str = \"interp(t, %s, %s, spline%s)\" % (S.a, S.b, self.spline)\n else:\n td_str = \"zinterp(t, %s, %s, spline%s)\" % (S.a, S.b, self.spline)\n ham_str += [\"dense_add_mult(H, H{0}, {1})\".format(kk,td_str)]\n self.spline += 1\n else:\n ham_str += [\"dense_add_mult(H, H{0}, {1})\".format(kk,self.h_td_terms[kk])]\n #Do the eigensolving\n ham_str += [\"ZHEEVR(H, eigvals, evecs, nrows)\"]\n #Free H as it is no longer needed\n ham_str += [\"PyDataMem_FREE(&H[0,0])\"]\n\n return ham_str\n\n def br_matvec_terms(self):\n br_str = []\n # Transform vector eigenbasis\n br_str += [\"cdef double complex * eig_vec = vec_to_eigbasis(vec, evecs, nrows)\"]\n # Do the diagonal liouvillian matvec\n br_str += [\"diag_liou_mult(eigvals, eig_vec, out, nrows)\"]\n # Do the cop_term matvec for each c_term\n for kk in range(self.c_terms):\n if isinstance(self.c_td_terms[kk], Cubic_Spline):\n S = self.c_td_terms[kk]\n if not S.is_complex:\n td_str = \"interp(t, %s, %s, spline%s)\" % (S.a, S.b, self.spline)\n else:\n td_str = \"zinterp(t, %s, %s, spline%s)\" % (S.a, S.b, self.spline)\n if self.use_openmp:\n\n br_str += [\"cop_super_mult_openmp(C{0}, evecs, eig_vec, {1}, out, nrows, {2}, {3}, {4})\".format(kk,\n td_str, self.omp_thresh, self.omp_threads, self.atol)]\n else:\n br_str += [\"cop_super_mult(C{0}, evecs, eig_vec, {1}, out, nrows, {2})\".format(kk, td_str, self.atol)]\n self.spline += 1\n else:\n if self.use_openmp:\n br_str += [\"cop_super_mult_openmp(C{0}, evecs, eig_vec, {1}, out, nrows, {2}, {3}, {4})\".format(kk,\n self.c_td_terms[kk], self.omp_thresh, self.omp_threads, self.atol)]\n else:\n br_str += [\"cop_super_mult(C{0}, evecs, eig_vec, {1}, out, nrows, {2})\".format(kk, self.c_td_terms[kk], self.atol)]\n\n if self.a_terms != 0:\n #Calculate skew and dw_min terms\n br_str += [\"cdef double[:,::1] skew = <double[:nrows,:nrows]><double *>PyDataMem_NEW_ZEROED(nrows**2,sizeof(double))\"]\n br_str += [\"cdef double dw_min = skew_and_dwmin(eigvals, skew, nrows)\"]\n\n #Compute BR term matvec\n kk = 0\n coupled_val = 0\n while kk < self.a_terms:\n if kk not in self.coupled_ops:\n if self.use_openmp:\n br_str += [\"br_term_mult_openmp(t, A{0}, evecs, skew, dw_min, spectral{0}, eig_vec, out, nrows, {1}, {2}, {3}, {4}, {5})\".format(kk,\n self.use_secular, self.sec_cutoff, self.omp_thresh, self.omp_threads, self.atol)]\n else:\n br_str += [\"br_term_mult(t, A{0}, evecs, skew, dw_min, spectral{0}, eig_vec, out, nrows, {1}, {2}, {3})\".format(kk, self.use_secular, self.sec_cutoff, self.atol)]\n kk += 1\n else:\n br_str += ['cdef complex[::1, :] Ac{0} = farray_alloc(nrows)'.format(kk)]\n for nn in range(self.coupled_lengths[coupled_val]):\n if isinstance(self.a_td_terms[kk+nn], str):\n br_str += [\"dense_add_mult(Ac{0}, A{1}, {2})\".format(kk,kk+nn,self.a_td_terms[kk+nn])]\n elif isinstance(self.a_td_terms[kk+nn], Cubic_Spline):\n S = self.a_td_terms[kk+nn]\n if not S.is_complex:\n td_str = \"interp(t, %s, %s, spline%s)\" % (S.a, S.b, self.spline)\n else:\n td_str = \"zinterp(t, %s, %s, spline%s)\" % (S.a, S.b, self.spline)\n br_str += [\"dense_add_mult(Ac{0}, A{1}, {2})\".format(kk,kk+nn,td_str)]\n else:\n raise Exception('Invalid time-dependence fot a_op.')\n\n if self.use_openmp:\n br_str += [\"br_term_mult_openmp(t, Ac{0}, evecs, skew, dw_min, spectral{0}, eig_vec, out, nrows, {1}, {2}, {3}, {4}, {5})\".format(kk,\n self.use_secular, self.sec_cutoff, self.omp_thresh, self.omp_threads, self.atol)]\n else:\n br_str += [\"br_term_mult(t, Ac{0}, evecs, skew, dw_min, spectral{0}, eig_vec, out, nrows, {1}, {2}, {3})\".format(kk, self.use_secular, self.sec_cutoff, self.atol)]\n\n br_str += [\"PyDataMem_FREE(&Ac{0}[0,0])\".format(kk)]\n kk += self.coupled_lengths[coupled_val]\n coupled_val += 1\n return br_str\n\n\n def func_end(self):\n end_str = []\n #Transform out vector back to fock basis\n end_str += [\"cdef np.ndarray[complex, ndim=1, mode='c'] arr_out = vec_to_fockbasis(out, evecs, nrows)\"]\n #Free everything at end\n if self.a_terms != 0:\n end_str += [\"PyDataMem_FREE(&skew[0,0])\"]\n end_str += [\"PyDataMem_FREE(&evecs[0,0])\"]\n end_str += [\"PyDataMem_FREE(eigvals)\"]\n end_str += [\"PyDataMem_FREE(eig_vec)\"]\n end_str += [\"PyDataMem_FREE(out)\"]\n end_str += [\"return arr_out\"]\n return end_str\n\n\n\ndef cython_preamble(use_omp=False):\n if use_omp:\n call_str = \"from qutip.cy.openmp.br_omp cimport (cop_super_mult_openmp, br_term_mult_openmp)\"\n else:\n call_str = \"from qutip.cy.brtools cimport (cop_super_mult, br_term_mult)\"\n \"\"\"\n Returns list of code segments for Cython preamble.\n \"\"\"\n return [\"\"\"#!python\n#cython: language_level=3\n# This file is generated automatically by QuTiP.\n# (C) 2011 and later, QuSTaR\nimport numpy as np\ncimport numpy as np\ncimport cython\nnp.import_array()\ncdef extern from \"numpy/arrayobject.h\" nogil:\n void PyDataMem_NEW_ZEROED(size_t size, size_t elsize)\n void PyArray_ENABLEFLAGS(np.ndarray arr, int flags)\n void PyDataMem_FREE(void * ptr)\nfrom qutip.cy.interpolate cimport interp, zinterp\nfrom qutip.cy.math cimport erf, zerf\ncdef double pi = 3.14159265358979323\nfrom qutip.cy.brtools cimport (dense_add_mult, ZHEEVR, dense_to_eigbasis,\n vec_to_eigbasis, vec_to_fockbasis, skew_and_dwmin,\n diag_liou_mult, spec_func, farray_alloc)\n\"\"\"\n+call_str+\n\"\"\"\ninclude \"\"\"+_include_string+\"\"\"\n\"\"\"]\n\n\n\ndef cython_checks():\n \"\"\"\n List of strings that turn off Cython checks.\n \"\"\"\n return [\"\"\"\[email protected](True)\[email protected](False)\[email protected](False)\"\"\"]\n",
"import numpy as np\nimport matplotlib.pyplot as plt\n\nimport qutip\n\n# Define paramters\nN = 20 # number of basis states to consider\na = qutip.destroy(N)\nH = a.dag() * a\npsi0 = qutip.basis(N, 10) # initial state\nkappa = 0.1 # coupling to oscillator\n\n# collapse operators\nc_op_list = []\nn_th_a = 2 # temperature with average of 2 excitations\nrate = kappa * (1 + n_th_a)\nif rate > 0.0:\n c_op_list.append(np.sqrt(rate) * a) # decay operators\nrate = kappa * n_th_a\nif rate > 0.0:\n c_op_list.append(np.sqrt(rate) * a.dag()) # excitation operators\n\n# find steady-state solution\nfinal_state = qutip.steadystate(H, c_op_list)\n# find expectation value for particle number in steady state\nfexpt = qutip.expect(a.dag() * a, final_state)\n\ntlist = np.linspace(0, 50, 100)\n# monte-carlo\nmcdata = qutip.mcsolve(H, psi0, tlist, c_op_list, [a.dag() * a], ntraj=100)\n# master eq.\nmedata = qutip.mesolve(H, psi0, tlist, c_op_list, [a.dag() * a])\n\nplt.plot(tlist, mcdata.expect[0], tlist, medata.expect[0], lw=2)\n# plot steady-state expt. value as horizontal line (should be = 2)\nplt.axhline(y=fexpt, color='r', lw=1.5)\nplt.ylim([0, 10])\nplt.xlabel('Time', fontsize=14)\nplt.ylabel('Number of excitations', fontsize=14)\nplt.legend(('Monte-Carlo', 'Master Equation', 'Steady State'))\nplt.title(\n r'Decay of Fock state $\\left|10\\rangle\\right.$'\n r' in a thermal environment with $\\langle n\\rangle=2$'\n)\nplt.show()\n"
] | [
[
"numpy.array2string"
],
[
"matplotlib.pyplot.legend",
"matplotlib.pyplot.axhline",
"numpy.sqrt",
"numpy.linspace",
"matplotlib.pyplot.title",
"matplotlib.pyplot.ylim",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.show",
"matplotlib.pyplot.ylabel"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
yarikoptic/fitlins | [
"ee7e06330b9cdd5a9b812d51eb545daa84b0d066"
] | [
"fitlins/interfaces/bids.py"
] | [
"import os\nfrom functools import reduce\nfrom pathlib import Path\nfrom gzip import GzipFile\nimport json\nimport shutil\nimport numpy as np\nimport nibabel as nb\n\nfrom collections import defaultdict\n\nfrom nipype import logging\nfrom nipype.utils.filemanip import makedirs, copyfile\nfrom nipype.interfaces.base import (\n BaseInterfaceInputSpec, TraitedSpec, SimpleInterface,\n InputMultiPath, OutputMultiPath, File, Directory,\n traits, isdefined\n )\nfrom nipype.interfaces.io import IOBase\n\nfrom ..utils import dict_intersection, snake_to_camel\n\niflogger = logging.getLogger('nipype.interface')\n\n\ndef bids_split_filename(fname):\n \"\"\"Split a filename into parts: path, base filename, and extension\n\n Respects multi-part file types used in BIDS standard and draft extensions\n\n Largely copied from nipype.utils.filemanip.split_filename\n\n Parameters\n ----------\n fname : str\n file or path name\n\n Returns\n -------\n pth : str\n path of fname\n fname : str\n basename of filename, without extension\n ext : str\n file extension of fname\n \"\"\"\n special_extensions = [\n \".R.surf.gii\", \".L.surf.gii\",\n \".R.func.gii\", \".L.func.gii\",\n \".nii.gz\", \".tsv.gz\",\n ]\n\n pth = os.path.dirname(fname)\n fname = os.path.basename(fname)\n\n for special_ext in special_extensions:\n if fname.lower().endswith(special_ext.lower()):\n ext_len = len(special_ext)\n ext = fname[-ext_len:]\n fname = fname[:-ext_len]\n break\n else:\n fname, ext = os.path.splitext(fname)\n\n return pth, fname, ext\n\n\ndef _ensure_model(model):\n model = getattr(model, 'filename', model)\n\n if isinstance(model, str):\n if os.path.exists(model):\n with open(model) as fobj:\n model = json.load(fobj)\n else:\n model = json.loads(model)\n return model\n\n\nclass ModelSpecLoaderInputSpec(BaseInterfaceInputSpec):\n bids_dir = Directory(exists=True,\n mandatory=True,\n desc='BIDS dataset root directory')\n model = traits.Either('default', InputMultiPath(File(exists=True)),\n desc='Model filename')\n selectors = traits.Dict(desc='Limit models to those with matching inputs')\n\n\nclass ModelSpecLoaderOutputSpec(TraitedSpec):\n model_spec = OutputMultiPath(traits.Dict())\n\n\nclass ModelSpecLoader(SimpleInterface):\n input_spec = ModelSpecLoaderInputSpec\n output_spec = ModelSpecLoaderOutputSpec\n\n def _run_interface(self, runtime):\n import bids\n from bids.analysis import auto_model\n models = self.inputs.model\n if not isinstance(models, list):\n layout = bids.BIDSLayout(self.inputs.bids_dir)\n\n if not isdefined(models):\n models = layout.get(type='model')\n if not models:\n raise ValueError(\"No models found\")\n elif models == 'default':\n models = auto_model(layout)\n\n models = [_ensure_model(m) for m in models]\n\n if self.inputs.selectors:\n # This is almost certainly incorrect\n models = [model for model in models\n if all(val in model['input'].get(key, [val])\n for key, val in self.inputs.selectors.items())]\n\n self._results['model_spec'] = models\n\n return runtime\n\n\nIMPUTATION_SNIPPET = \"\"\"\\\n<div class=\"warning\">\n The following confounds had NaN values for the first volume: {}.\n The mean of non-zero values for the remaining entries was imputed.\n If another strategy is desired, it must be explicitly specified in\n the model.\n</div>\n\"\"\"\n\n\nclass LoadBIDSModelInputSpec(BaseInterfaceInputSpec):\n bids_dir = Directory(exists=True,\n mandatory=True,\n desc='BIDS dataset root directory')\n preproc_dir = Directory(exists=True,\n desc='Optional preprocessed files directory')\n model = traits.Dict(desc='Model specification', mandatory=True)\n selectors = traits.Dict(desc='Limit collected sessions', usedefault=True)\n include_pattern = InputMultiPath(\n traits.Str, xor=['exclude_pattern'],\n desc='Patterns to select sub-directories of BIDS root')\n exclude_pattern = InputMultiPath(\n traits.Str, xor=['include_pattern'],\n desc='Patterns to ignore sub-directories of BIDS root')\n\n\nclass LoadBIDSModelOutputSpec(TraitedSpec):\n session_info = traits.List(traits.Dict())\n contrast_info = traits.List(traits.List(File()))\n contrast_indices = traits.List(traits.List(traits.List(traits.Dict)))\n entities = traits.List(traits.List(traits.Dict()))\n warnings = traits.List(File)\n\n\nclass LoadBIDSModel(SimpleInterface):\n input_spec = LoadBIDSModelInputSpec\n output_spec = LoadBIDSModelOutputSpec\n\n def _run_interface(self, runtime):\n import bids\n bids.config.set_options(loop_preproc=True)\n include = self.inputs.include_pattern\n exclude = self.inputs.exclude_pattern\n if not isdefined(include):\n include = None\n if not isdefined(exclude):\n exclude = None\n\n paths = [(self.inputs.bids_dir, 'bids')]\n if isdefined(self.inputs.preproc_dir):\n paths.append((self.inputs.preproc_dir, ['bids', 'derivatives']))\n layout = bids.BIDSLayout(paths, include=include, exclude=exclude)\n\n selectors = self.inputs.selectors\n\n analysis = bids.Analysis(model=self.inputs.model, layout=layout)\n analysis.setup(drop_na=False, **selectors)\n self._load_level1(runtime, analysis)\n self._load_higher_level(runtime, analysis)\n\n # Debug - remove, eventually\n runtime.analysis = analysis\n\n return runtime\n\n def _load_level1(self, runtime, analysis):\n block = analysis.blocks[0]\n block_subdir = Path(runtime.cwd) / block.level\n block_subdir.mkdir(parents=True, exist_ok=True)\n\n entities = []\n session_info = []\n contrast_indices = []\n contrast_info = []\n warnings = []\n for paradigm, _, ents in block.get_design_matrix(\n block.model['HRF_variables'], mode='sparse', force=True):\n info = {}\n\n space = analysis.layout.get_spaces(type='preproc',\n extensions=['.nii', '.nii.gz'])[0]\n preproc_files = analysis.layout.get(type='preproc',\n extensions=['.nii', '.nii.gz'],\n space=space,\n **ents)\n if len(preproc_files) != 1:\n raise ValueError('Too many BOLD files found')\n\n fname = preproc_files[0].filename\n\n # Required field in seconds\n TR = analysis.layout.get_metadata(fname, type='bold',\n full_search=True)['RepetitionTime']\n dense_vars = set(block.model['variables']) - set(block.model['HRF_variables'])\n\n _, confounds, _ = block.get_design_matrix(dense_vars,\n mode='dense',\n force=True,\n sampling_rate=1/TR,\n **ents)[0]\n\n ent_string = '_'.join('{}-{}'.format(key, val)\n for key, val in ents.items())\n\n events_file = block_subdir / '{}_events.h5'.format(ent_string)\n paradigm.to_hdf(events_file, key='events')\n\n imputed = []\n if confounds is not None:\n # Note that FMRIPREP includes CosineXX columns to accompany\n # t/aCompCor\n # We may want to add criteria to include HPF columns that are not\n # explicitly listed in the model\n names = [col for col in confounds.columns\n if col.startswith('NonSteadyStateOutlier') or\n col in block.model['variables']]\n confounds = confounds[names]\n\n # These confounds are defined pairwise with the current volume\n # and its predecessor, and thus may be undefined (have value\n # NaN) at the first volume.\n # In these cases, we impute the mean non-zero value, for the\n # expected NaN only.\n # Any other NaNs must be handled by an explicit transform in\n # the BIDS model.\n for imputable in ('FramewiseDisplacement',\n 'stdDVARS', 'non-stdDVARS',\n 'vx-wisestdDVARS'):\n if imputable in confounds.columns:\n vals = confounds[imputable].values\n if not np.isnan(vals[0]):\n continue\n\n # Impute the mean non-zero, non-NaN value\n confounds[imputable][0] = np.nanmean(vals[vals != 0])\n imputed.append(imputable)\n\n if np.isnan(confounds.values).any():\n iflogger.warning('Unexpected NaNs found in confounds; '\n 'regression may fail.')\n\n confounds_file = block_subdir / '{}_confounds.h5'.format(ent_string)\n confounds.to_hdf(confounds_file, key='confounds')\n\n else:\n confounds_file = None\n\n info['events'] = str(events_file)\n info['confounds'] = str(confounds_file)\n info['repetition_time'] = TR\n\n # Transpose so each contrast gets a row of data instead of column\n contrasts, index, _ = block.get_contrasts(**ents)[0]\n\n contrast_type_map = defaultdict(lambda: 'T')\n contrast_type_map.update({contrast['name']: contrast['type']\n for contrast in block.contrasts})\n contrast_type_list = [contrast_type_map[contrast]\n for contrast in contrasts.columns]\n\n contrasts = contrasts.T\n # Add test indicator column\n contrasts['type'] = contrast_type_list\n\n contrasts_file = block_subdir / '{}_contrasts.h5'.format(ent_string)\n contrasts_file.parent.mkdir(parents=True, exist_ok=True)\n contrasts.to_hdf(contrasts_file, key='contrasts')\n\n warning_file = block_subdir / '{}_warning.html'.format(ent_string)\n with warning_file.open('w') as fobj:\n if imputed:\n fobj.write(IMPUTATION_SNIPPET.format(', '.join(imputed)))\n\n entities.append(ents)\n session_info.append(info)\n contrast_indices.append(index.to_dict('records'))\n contrast_info.append(str(contrasts_file))\n warnings.append(str(warning_file))\n\n self._results['session_info'] = session_info\n self._results['warnings'] = warnings\n self._results.setdefault('entities', []).append(entities)\n self._results.setdefault('contrast_indices', []).append(contrast_indices)\n self._results.setdefault('contrast_info', []).append(contrast_info)\n\n def _load_higher_level(self, runtime, analysis):\n cwd = Path(runtime.cwd)\n for block in analysis.blocks[1:]:\n block_subdir = cwd / block.level\n block_subdir.mkdir(parents=True, exist_ok=True)\n\n entities = []\n contrast_indices = []\n contrast_info = []\n for contrasts, index, ents in block.get_contrasts():\n if contrasts.empty:\n continue\n\n # The contrast index is the name of the input contrasts,\n # which will very frequently be non-unique\n # Hence, add the contrast to the index (table of entities)\n # and switch to a matching numeric index\n index['contrast'] = contrasts.index\n contrasts.index = index.index\n\n contrast_type_map = defaultdict(lambda: 'T')\n contrast_type_map.update({contrast['name']: contrast['type']\n for contrast in block.contrasts})\n contrast_type_list = [contrast_type_map[contrast]\n for contrast in contrasts.columns]\n\n indices = index.to_dict('records')\n\n # Entities for a given contrast matrix include the intersection of\n # entities of inputs, e.g., if this level is within-subject, the\n # subject should persist\n out_ents = reduce(dict_intersection, indices)\n # Explicit entities take precedence over derived\n out_ents.update(ents)\n # Input-level contrasts will be overridden by the current level\n out_ents.pop('contrast', None)\n\n ent_string = '_'.join('{}-{}'.format(key, val)\n for key, val in out_ents.items())\n\n # Transpose so each contrast gets a row of data instead of column\n contrasts = contrasts.T\n # Add test indicator column\n contrasts['type'] = contrast_type_list\n\n contrasts_file = block_subdir / '{}_contrasts.h5'.format(ent_string)\n contrasts_file.parent.mkdir(parents=True, exist_ok=True)\n contrasts.to_hdf(contrasts_file, key='contrasts')\n\n entities.append(out_ents)\n contrast_indices.append(indices)\n contrast_info.append(str(contrasts_file))\n\n self._results['entities'].append(entities)\n self._results['contrast_info'].append(contrast_info)\n self._results['contrast_indices'].append(contrast_indices)\n\n\nclass BIDSSelectInputSpec(BaseInterfaceInputSpec):\n bids_dir = Directory(exists=True,\n mandatory=True,\n desc='BIDS dataset root directories')\n preproc_dir = Directory(exists=True,\n desc='Optional preprocessed files directory')\n entities = InputMultiPath(traits.Dict(), mandatory=True)\n selectors = traits.Dict(desc='Additional selectors to be applied',\n usedefault=True)\n\n\nclass BIDSSelectOutputSpec(TraitedSpec):\n bold_files = OutputMultiPath(File)\n mask_files = OutputMultiPath(traits.Either(File, None))\n entities = OutputMultiPath(traits.Dict)\n\n\nclass BIDSSelect(SimpleInterface):\n input_spec = BIDSSelectInputSpec\n output_spec = BIDSSelectOutputSpec\n\n def _run_interface(self, runtime):\n import bids\n paths = [(self.inputs.bids_dir, 'bids')]\n if isdefined(self.inputs.preproc_dir):\n paths.append((self.inputs.preproc_dir, ['bids', 'derivatives']))\n layout = bids.BIDSLayout(paths)\n\n bold_files = []\n mask_files = []\n entities = []\n for ents in self.inputs.entities:\n selectors = {**self.inputs.selectors, **ents}\n bold_file = layout.get(extensions=['.nii', '.nii.gz'], **selectors)\n\n if len(bold_file) == 0:\n raise FileNotFoundError(\n \"Could not find BOLD file in {} with entities {}\"\n \"\".format(self.inputs.bids_dir, selectors))\n elif len(bold_file) > 1:\n raise ValueError(\n \"Non-unique BOLD file in {} with entities {}.\\n\"\n \"Matches:\\n\\t{}\"\n \"\".format(self.inputs.bids_dir, selectors,\n \"\\n\\t\".join(\n '{} ({})'.format(\n f.filename,\n layout.files[f.filename].entities)\n for f in bold_file)))\n\n # Select exactly matching mask file (may be over-cautious)\n bold_ents = layout.parse_file_entities(\n bold_file[0].filename)\n bold_ents['type'] = 'brainmask'\n mask_file = layout.get(extensions=['.nii', '.nii.gz'], **bold_ents)\n bold_ents.pop('type')\n\n bold_files.append(bold_file[0].filename)\n mask_files.append(mask_file[0].filename if mask_file else None)\n entities.append(bold_ents)\n\n self._results['bold_files'] = bold_files\n self._results['mask_files'] = mask_files\n self._results['entities'] = entities\n\n return runtime\n\n\ndef _copy_or_convert(in_file, out_file):\n in_ext = bids_split_filename(in_file)[2]\n out_ext = bids_split_filename(out_file)[2]\n\n # Copy if filename matches\n if in_ext == out_ext:\n copyfile(in_file, out_file, copy=True, use_hardlink=True)\n return\n\n # gzip/gunzip if it's easy\n if in_ext == out_ext + '.gz' or in_ext + '.gz' == out_ext:\n read_open = GzipFile if in_ext.endswith('.gz') else open\n write_open = GzipFile if out_ext.endswith('.gz') else open\n with read_open(in_file, mode='rb') as in_fobj:\n with write_open(out_file, mode='wb') as out_fobj:\n shutil.copyfileobj(in_fobj, out_fobj)\n return\n\n # Let nibabel take a shot\n try:\n nb.save(nb.load(in_file), out_file)\n except Exception:\n pass\n else:\n return\n\n raise RuntimeError(\"Cannot convert {} to {}\".format(in_ext, out_ext))\n\n\nclass BIDSDataSinkInputSpec(BaseInterfaceInputSpec):\n base_directory = Directory(\n mandatory=True,\n desc='Path to BIDS (or derivatives) root directory')\n in_file = InputMultiPath(File(exists=True), mandatory=True)\n entities = InputMultiPath(traits.Dict, usedefault=True,\n desc='Per-file entities to include in filename')\n fixed_entities = traits.Dict(usedefault=True,\n desc='Entities to include in all filenames')\n path_patterns = InputMultiPath(\n traits.Str, desc='BIDS path patterns describing format of file names')\n\n\nclass BIDSDataSinkOutputSpec(TraitedSpec):\n out_file = OutputMultiPath(File, desc='output file')\n\n\nclass BIDSDataSink(IOBase):\n input_spec = BIDSDataSinkInputSpec\n output_spec = BIDSDataSinkOutputSpec\n\n _always_run = True\n\n def _list_outputs(self):\n import bids\n base_dir = self.inputs.base_directory\n\n os.makedirs(base_dir, exist_ok=True)\n\n layout = bids.BIDSLayout(base_dir)\n path_patterns = self.inputs.path_patterns\n if not isdefined(path_patterns):\n path_patterns = None\n\n out_files = []\n for entities, in_file in zip(self.inputs.entities,\n self.inputs.in_file):\n ents = {**self.inputs.fixed_entities}\n ents.update(entities)\n\n ents = {k: snake_to_camel(str(v)) for k, v in ents.items()}\n\n out_fname = os.path.join(\n base_dir, layout.build_path(ents, path_patterns))\n makedirs(os.path.dirname(out_fname), exist_ok=True)\n\n _copy_or_convert(in_file, out_fname)\n out_files.append(out_fname)\n\n return {'out_file': out_files}\n"
] | [
[
"numpy.isnan",
"numpy.nanmean"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
jtchilders/deephyper | [
"06f9653599757a69fa5720820f4de3a1f154b081",
"06f9653599757a69fa5720820f4de3a1f154b081"
] | [
"deephyper/search/nas/model/space/keras_search_space.py",
"deephyper/search/nas/baselines/her/ddpg.py"
] | [
"from collections.abc import Iterable\nfrom functools import reduce\n\nimport networkx as nx\nfrom tensorflow import keras\nfrom tensorflow.python.keras.utils.vis_utils import model_to_dot\n\nfrom deephyper.core.exceptions.nas.space import (InputShapeOfWrongType,\n NodeAlreadyAdded,\n StructureHasACycle,\n WrongOutputShape,\n WrongSequenceToSetOperations)\nfrom deephyper.search.nas.model.space import NxSearchSpace\nfrom deephyper.search.nas.model.space.node import (ConstantNode, Node,\n VariableNode)\nfrom deephyper.search.nas.model.space.op.basic import Tensor\nfrom deephyper.search.nas.model.space.op.merge import Concatenate\nfrom deephyper.search.nas.model.space.op.op1d import Identity\n\n\nclass KSearchSpace(NxSearchSpace):\n \"\"\"A KSearchSpace represents a search space of neural networks.\n\n >>> from tensorflow.keras.utils import plot_model\n >>> from deephyper.search.nas.model.space import KSearchSpace\n >>> from deephyper.search.nas.model.space.node import VariableNode, ConstantNode\n >>> from deephyper.search.nas.model.space.op.op1d import Dense\n >>> struct = KSearchSpace((5, ), (1, ))\n >>> vnode = VariableNode()\n >>> struct.connect(struct.input_nodes[0], vnode)\n >>> vnode.add_op(Dense(10))\n >>> vnode.add_op(Dense(20))\n >>> output_node = ConstantNode(op=Dense(1))\n >>> struct.connect(vnode, output_node)\n >>> struct.set_ops([0])\n >>> model = struct.create_model()\n\n Args:\n input_shape (list(tuple(int))): list of shapes of all inputs.\n output_shape (tuple(int)): shape of output.\n\n Raises:\n InputShapeOfWrongType: [description]\n \"\"\"\n\n def __init__(self, input_shape, output_shape, *args, **kwargs):\n\n super().__init__()\n\n if type(input_shape) is tuple:\n # we have only one input tensor here\n op = Tensor(keras.layers.Input(input_shape, name=\"input_0\"))\n self.input_nodes = [ConstantNode(op=op, name='Input_0')]\n\n elif type(input_shape) is list and all(map(lambda x: type(x) is tuple, input_shape)):\n # we have a list of input tensors here\n self.input_nodes = list()\n for i in range(len(input_shape)):\n op = Tensor(keras.layers.Input(\n input_shape[i], name=f\"input_{i}\"))\n inode = ConstantNode(op=op, name=f'Input_{i}')\n self.input_nodes.append(inode)\n else:\n raise InputShapeOfWrongType(input_shape)\n\n for node in self.input_nodes:\n self.graph.add_node(node)\n\n self.output_shape = output_shape\n self.output_node = None\n\n self._model = None\n\n @property\n def depth(self):\n if self._model is None:\n raise RuntimeError(\n \"Can't compute depth of model without creating a model.\")\n return len(self.longest_path)\n\n @property\n def longest_path(self):\n if self._model is None:\n raise RuntimeError(\n \"Can't compute longest path of model without creating a model.\")\n nx_graph = nx.drawing.nx_pydot.from_pydot(model_to_dot(self._model))\n return nx.algorithms.dag.dag_longest_path(nx_graph)\n\n\n def set_ops(self, indexes):\n \"\"\"Set the operations for each node of each cell of the search_space.\n\n Args:\n indexes (list): element of list can be float in [0, 1] or int.\n\n Raises:\n WrongSequenceToSetOperations: raised when 'indexes' is of a wrong length.\n \"\"\"\n if len(indexes) != len(list(self.variable_nodes)):\n raise WrongSequenceToSetOperations(\n indexes, list(self.variable_nodes))\n\n for op_i, node in zip(indexes, self.variable_nodes):\n node.set_op(op_i)\n\n output_nodes = self.get_output_nodes()\n\n self.output_node = self.set_output_node(self.graph, output_nodes)\n\n def set_output_node(self, graph, output_nodes):\n \"\"\"Set the output node of the search_space.\n\n Args:\n graph (nx.DiGraph): graph of the search_space.\n output_nodes (Node): nodes of the current search_space without successors.\n\n Returns:\n Node: output node of the search_space.\n \"\"\"\n if len(output_nodes) == 1:\n node = ConstantNode(op=Identity(), name='Structure_Output')\n graph.add_node(node)\n graph.add_edge(output_nodes[0], node)\n else:\n node = ConstantNode(name='Structure_Output')\n op = Concatenate(self, output_nodes)\n node.set_op(op=op)\n return node\n\n def create_model(self):\n \"\"\"Create the tensors corresponding to the search_space.\n\n Returns:\n A keras.Model for the current search_space with the corresponding set of operations.\n \"\"\"\n\n output_tensor = self.create_tensor_aux(self.graph, self.output_node)\n if output_tensor.get_shape()[1:] != self.output_shape:\n raise WrongOutputShape(output_tensor, self.output_shape)\n\n input_tensors = [inode._tensor for inode in self.input_nodes]\n\n self._model = keras.Model(inputs=input_tensors, outputs=output_tensor)\n\n return keras.Model(inputs=input_tensors, outputs=output_tensor)\n",
"from collections import OrderedDict\n\nimport numpy as np\nimport tensorflow as tf\nfrom tensorflow.contrib.staging import StagingArea\n\nfrom deephyper.search.nas.baselines import logger\nfrom deephyper.search.nas.baselines.her.util import (\n import_function, store_args, flatten_grads, transitions_in_episode_batch, convert_episode_to_batch_major)\nfrom deephyper.search.nas.baselines.her.normalizer import Normalizer\nfrom deephyper.search.nas.baselines.her.replay_buffer import ReplayBuffer\nfrom deephyper.search.nas.baselines.common.mpi_adam import MpiAdam\nfrom deephyper.search.nas.baselines.common import tf_util\n\n\ndef dims_to_shapes(input_dims):\n return {key: tuple([val]) if val > 0 else tuple() for key, val in input_dims.items()}\n\n\nglobal DEMO_BUFFER #buffer for demonstrations\n\nclass DDPG(object):\n @store_args\n def __init__(self, input_dims, buffer_size, hidden, layers, network_class, polyak, batch_size,\n Q_lr, pi_lr, norm_eps, norm_clip, max_u, action_l2, clip_obs, scope, T,\n rollout_batch_size, subtract_goals, relative_goals, clip_pos_returns, clip_return,\n bc_loss, q_filter, num_demo, demo_batch_size, prm_loss_weight, aux_loss_weight,\n sample_transitions, gamma, reuse=False, **kwargs):\n \"\"\"Implementation of DDPG that is used in combination with Hindsight Experience Replay (HER).\n Added functionality to use demonstrations for training to Overcome exploration problem.\n\n Args:\n input_dims (dict of ints): dimensions for the observation (o), the goal (g), and the\n actions (u)\n buffer_size (int): number of transitions that are stored in the replay buffer\n hidden (int): number of units in the hidden layers\n layers (int): number of hidden layers\n network_class (str): the network class that should be used (e.g. 'baselines.her.ActorCritic')\n polyak (float): coefficient for Polyak-averaging of the target network\n batch_size (int): batch size for training\n Q_lr (float): learning rate for the Q (critic) network\n pi_lr (float): learning rate for the pi (actor) network\n norm_eps (float): a small value used in the normalizer to avoid numerical instabilities\n norm_clip (float): normalized inputs are clipped to be in [-norm_clip, norm_clip]\n max_u (float): maximum action magnitude, i.e. actions are in [-max_u, max_u]\n action_l2 (float): coefficient for L2 penalty on the actions\n clip_obs (float): clip observations before normalization to be in [-clip_obs, clip_obs]\n scope (str): the scope used for the TensorFlow graph\n T (int): the time horizon for rollouts\n rollout_batch_size (int): number of parallel rollouts per DDPG agent\n subtract_goals (function): function that subtracts goals from each other\n relative_goals (boolean): whether or not relative goals should be fed into the network\n clip_pos_returns (boolean): whether or not positive returns should be clipped\n clip_return (float): clip returns to be in [-clip_return, clip_return]\n sample_transitions (function) function that samples from the replay buffer\n gamma (float): gamma used for Q learning updates\n reuse (boolean): whether or not the networks should be reused\n bc_loss: whether or not the behavior cloning loss should be used as an auxilliary loss\n q_filter: whether or not a filter on the q value update should be used when training with demonstartions\n num_demo: Number of episodes in to be used in the demonstration buffer\n demo_batch_size: number of samples to be used from the demonstrations buffer, per mpi thread\n prm_loss_weight: Weight corresponding to the primary loss\n aux_loss_weight: Weight corresponding to the auxilliary loss also called the cloning loss\n \"\"\"\n if self.clip_return is None:\n self.clip_return = np.inf\n\n self.create_actor_critic = import_function(self.network_class)\n\n input_shapes = dims_to_shapes(self.input_dims)\n self.dimo = self.input_dims['o']\n self.dimg = self.input_dims['g']\n self.dimu = self.input_dims['u']\n\n # Prepare staging area for feeding data to the model.\n stage_shapes = OrderedDict()\n for key in sorted(self.input_dims.keys()):\n if key.startswith('info_'):\n continue\n stage_shapes[key] = (None, *input_shapes[key])\n for key in ['o', 'g']:\n stage_shapes[key + '_2'] = stage_shapes[key]\n stage_shapes['r'] = (None,)\n self.stage_shapes = stage_shapes\n\n # Create network.\n with tf.variable_scope(self.scope):\n self.staging_tf = StagingArea(\n dtypes=[tf.float32 for _ in self.stage_shapes.keys()],\n shapes=list(self.stage_shapes.values()))\n self.buffer_ph_tf = [\n tf.placeholder(tf.float32, shape=shape) for shape in self.stage_shapes.values()]\n self.stage_op = self.staging_tf.put(self.buffer_ph_tf)\n\n self._create_network(reuse=reuse)\n\n # Configure the replay buffer.\n buffer_shapes = {key: (self.T-1 if key != 'o' else self.T, *input_shapes[key])\n for key, val in input_shapes.items()}\n buffer_shapes['g'] = (buffer_shapes['g'][0], self.dimg)\n buffer_shapes['ag'] = (self.T, self.dimg)\n\n buffer_size = (self.buffer_size // self.rollout_batch_size) * self.rollout_batch_size\n self.buffer = ReplayBuffer(buffer_shapes, buffer_size, self.T, self.sample_transitions)\n\n global DEMO_BUFFER\n DEMO_BUFFER = ReplayBuffer(buffer_shapes, buffer_size, self.T, self.sample_transitions) #initialize the demo buffer; in the same way as the primary data buffer\n\n def _random_action(self, n):\n return np.random.uniform(low=-self.max_u, high=self.max_u, size=(n, self.dimu))\n\n def _preprocess_og(self, o, ag, g):\n if self.relative_goals:\n g_shape = g.shape\n g = g.reshape(-1, self.dimg)\n ag = ag.reshape(-1, self.dimg)\n g = self.subtract_goals(g, ag)\n g = g.reshape(*g_shape)\n o = np.clip(o, -self.clip_obs, self.clip_obs)\n g = np.clip(g, -self.clip_obs, self.clip_obs)\n return o, g\n\n def step(self, obs):\n actions = self.get_actions(obs['observation'], obs['achieved_goal'], obs['desired_goal'])\n return actions, None, None, None\n\n\n def get_actions(self, o, ag, g, noise_eps=0., random_eps=0., use_target_net=False,\n compute_Q=False):\n o, g = self._preprocess_og(o, ag, g)\n policy = self.target if use_target_net else self.main\n # values to compute\n vals = [policy.pi_tf]\n if compute_Q:\n vals += [policy.Q_pi_tf]\n # feed\n feed = {\n policy.o_tf: o.reshape(-1, self.dimo),\n policy.g_tf: g.reshape(-1, self.dimg),\n policy.u_tf: np.zeros((o.size // self.dimo, self.dimu), dtype=np.float32)\n }\n\n ret = self.sess.run(vals, feed_dict=feed)\n # action postprocessing\n u = ret[0]\n noise = noise_eps * self.max_u * np.random.randn(*u.shape) # gaussian noise\n u += noise\n u = np.clip(u, -self.max_u, self.max_u)\n u += np.random.binomial(1, random_eps, u.shape[0]).reshape(-1, 1) * (self._random_action(u.shape[0]) - u) # eps-greedy\n if u.shape[0] == 1:\n u = u[0]\n u = u.copy()\n ret[0] = u\n\n if len(ret) == 1:\n return ret[0]\n else:\n return ret\n\n def init_demo_buffer(self, demoDataFile, update_stats=True): #function that initializes the demo buffer\n\n demoData = np.load(demoDataFile) #load the demonstration data from data file\n info_keys = [key.replace('info_', '') for key in self.input_dims.keys() if key.startswith('info_')]\n info_values = [np.empty((self.T - 1, 1, self.input_dims['info_' + key]), np.float32) for key in info_keys]\n\n demo_data_obs = demoData['obs']\n demo_data_acs = demoData['acs']\n demo_data_info = demoData['info']\n\n for epsd in range(self.num_demo): # we initialize the whole demo buffer at the start of the training\n obs, acts, goals, achieved_goals = [], [] ,[] ,[]\n i = 0\n for transition in range(self.T - 1):\n obs.append([demo_data_obs[epsd][transition].get('observation')])\n acts.append([demo_data_acs[epsd][transition]])\n goals.append([demo_data_obs[epsd][transition].get('desired_goal')])\n achieved_goals.append([demo_data_obs[epsd][transition].get('achieved_goal')])\n for idx, key in enumerate(info_keys):\n info_values[idx][transition, i] = demo_data_info[epsd][transition][key]\n\n\n obs.append([demo_data_obs[epsd][self.T - 1].get('observation')])\n achieved_goals.append([demo_data_obs[epsd][self.T - 1].get('achieved_goal')])\n\n episode = dict(o=obs,\n u=acts,\n g=goals,\n ag=achieved_goals)\n for key, value in zip(info_keys, info_values):\n episode['info_{}'.format(key)] = value\n\n episode = convert_episode_to_batch_major(episode)\n global DEMO_BUFFER\n DEMO_BUFFER.store_episode(episode) # create the observation dict and append them into the demonstration buffer\n logger.debug(\"Demo buffer size currently \", DEMO_BUFFER.get_current_size()) #print out the demonstration buffer size\n\n if update_stats:\n # add transitions to normalizer to normalize the demo data as well\n episode['o_2'] = episode['o'][:, 1:, :]\n episode['ag_2'] = episode['ag'][:, 1:, :]\n num_normalizing_transitions = transitions_in_episode_batch(episode)\n transitions = self.sample_transitions(episode, num_normalizing_transitions)\n\n o, g, ag = transitions['o'], transitions['g'], transitions['ag']\n transitions['o'], transitions['g'] = self._preprocess_og(o, ag, g)\n # No need to preprocess the o_2 and g_2 since this is only used for stats\n\n self.o_stats.update(transitions['o'])\n self.g_stats.update(transitions['g'])\n\n self.o_stats.recompute_stats()\n self.g_stats.recompute_stats()\n episode.clear()\n\n logger.info(\"Demo buffer size: \", DEMO_BUFFER.get_current_size()) #print out the demonstration buffer size\n\n def store_episode(self, episode_batch, update_stats=True):\n \"\"\"\n episode_batch: array of batch_size x (T or T+1) x dim_key\n 'o' is of size T+1, others are of size T\n \"\"\"\n\n self.buffer.store_episode(episode_batch)\n\n if update_stats:\n # add transitions to normalizer\n episode_batch['o_2'] = episode_batch['o'][:, 1:, :]\n episode_batch['ag_2'] = episode_batch['ag'][:, 1:, :]\n num_normalizing_transitions = transitions_in_episode_batch(episode_batch)\n transitions = self.sample_transitions(episode_batch, num_normalizing_transitions)\n\n o, g, ag = transitions['o'], transitions['g'], transitions['ag']\n transitions['o'], transitions['g'] = self._preprocess_og(o, ag, g)\n # No need to preprocess the o_2 and g_2 since this is only used for stats\n\n self.o_stats.update(transitions['o'])\n self.g_stats.update(transitions['g'])\n\n self.o_stats.recompute_stats()\n self.g_stats.recompute_stats()\n\n def get_current_buffer_size(self):\n return self.buffer.get_current_size()\n\n def _sync_optimizers(self):\n self.Q_adam.sync()\n self.pi_adam.sync()\n\n def _grads(self):\n # Avoid feed_dict here for performance!\n critic_loss, actor_loss, Q_grad, pi_grad = self.sess.run([\n self.Q_loss_tf,\n self.main.Q_pi_tf,\n self.Q_grad_tf,\n self.pi_grad_tf\n ])\n return critic_loss, actor_loss, Q_grad, pi_grad\n\n def _update(self, Q_grad, pi_grad):\n self.Q_adam.update(Q_grad, self.Q_lr)\n self.pi_adam.update(pi_grad, self.pi_lr)\n\n def sample_batch(self):\n if self.bc_loss: #use demonstration buffer to sample as well if bc_loss flag is set TRUE\n transitions = self.buffer.sample(self.batch_size - self.demo_batch_size)\n global DEMO_BUFFER\n transitions_demo = DEMO_BUFFER.sample(self.demo_batch_size) #sample from the demo buffer\n for k, values in transitions_demo.items():\n rolloutV = transitions[k].tolist()\n for v in values:\n rolloutV.append(v.tolist())\n transitions[k] = np.array(rolloutV)\n else:\n transitions = self.buffer.sample(self.batch_size) #otherwise only sample from primary buffer\n\n o, o_2, g = transitions['o'], transitions['o_2'], transitions['g']\n ag, ag_2 = transitions['ag'], transitions['ag_2']\n transitions['o'], transitions['g'] = self._preprocess_og(o, ag, g)\n transitions['o_2'], transitions['g_2'] = self._preprocess_og(o_2, ag_2, g)\n\n transitions_batch = [transitions[key] for key in self.stage_shapes.keys()]\n return transitions_batch\n\n def stage_batch(self, batch=None):\n if batch is None:\n batch = self.sample_batch()\n assert len(self.buffer_ph_tf) == len(batch)\n self.sess.run(self.stage_op, feed_dict=dict(zip(self.buffer_ph_tf, batch)))\n\n def train(self, stage=True):\n if stage:\n self.stage_batch()\n critic_loss, actor_loss, Q_grad, pi_grad = self._grads()\n self._update(Q_grad, pi_grad)\n return critic_loss, actor_loss\n\n def _init_target_net(self):\n self.sess.run(self.init_target_net_op)\n\n def update_target_net(self):\n self.sess.run(self.update_target_net_op)\n\n def clear_buffer(self):\n self.buffer.clear_buffer()\n\n def _vars(self, scope):\n res = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope=self.scope + '/' + scope)\n assert len(res) > 0\n return res\n\n def _global_vars(self, scope):\n res = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope=self.scope + '/' + scope)\n return res\n\n def _create_network(self, reuse=False):\n logger.info(\"Creating a DDPG agent with action space %d x %s...\" % (self.dimu, self.max_u))\n self.sess = tf_util.get_session()\n\n # running averages\n with tf.variable_scope('o_stats') as vs:\n if reuse:\n vs.reuse_variables()\n self.o_stats = Normalizer(self.dimo, self.norm_eps, self.norm_clip, sess=self.sess)\n with tf.variable_scope('g_stats') as vs:\n if reuse:\n vs.reuse_variables()\n self.g_stats = Normalizer(self.dimg, self.norm_eps, self.norm_clip, sess=self.sess)\n\n # mini-batch sampling.\n batch = self.staging_tf.get()\n batch_tf = OrderedDict([(key, batch[i])\n for i, key in enumerate(self.stage_shapes.keys())])\n batch_tf['r'] = tf.reshape(batch_tf['r'], [-1, 1])\n\n #choose only the demo buffer samples\n mask = np.concatenate((np.zeros(self.batch_size - self.demo_batch_size), np.ones(self.demo_batch_size)), axis = 0)\n\n # networks\n with tf.variable_scope('main') as vs:\n if reuse:\n vs.reuse_variables()\n self.main = self.create_actor_critic(batch_tf, net_type='main', **self.__dict__)\n vs.reuse_variables()\n with tf.variable_scope('target') as vs:\n if reuse:\n vs.reuse_variables()\n target_batch_tf = batch_tf.copy()\n target_batch_tf['o'] = batch_tf['o_2']\n target_batch_tf['g'] = batch_tf['g_2']\n self.target = self.create_actor_critic(\n target_batch_tf, net_type='target', **self.__dict__)\n vs.reuse_variables()\n assert len(self._vars(\"main\")) == len(self._vars(\"target\"))\n\n # loss functions\n target_Q_pi_tf = self.target.Q_pi_tf\n clip_range = (-self.clip_return, 0. if self.clip_pos_returns else np.inf)\n target_tf = tf.clip_by_value(batch_tf['r'] + self.gamma * target_Q_pi_tf, *clip_range)\n self.Q_loss_tf = tf.reduce_mean(tf.square(tf.stop_gradient(target_tf) - self.main.Q_tf))\n\n if self.bc_loss ==1 and self.q_filter == 1 : # train with demonstrations and use bc_loss and q_filter both\n maskMain = tf.reshape(tf.boolean_mask(self.main.Q_tf > self.main.Q_pi_tf, mask), [-1]) #where is the demonstrator action better than actor action according to the critic? choose those samples only\n #define the cloning loss on the actor's actions only on the samples which adhere to the above masks\n self.cloning_loss_tf = tf.reduce_sum(tf.square(tf.boolean_mask(tf.boolean_mask((self.main.pi_tf), mask), maskMain, axis=0) - tf.boolean_mask(tf.boolean_mask((batch_tf['u']), mask), maskMain, axis=0)))\n self.pi_loss_tf = -self.prm_loss_weight * tf.reduce_mean(self.main.Q_pi_tf) #primary loss scaled by it's respective weight prm_loss_weight\n self.pi_loss_tf += self.prm_loss_weight * self.action_l2 * tf.reduce_mean(tf.square(self.main.pi_tf / self.max_u)) #L2 loss on action values scaled by the same weight prm_loss_weight\n self.pi_loss_tf += self.aux_loss_weight * self.cloning_loss_tf #adding the cloning loss to the actor loss as an auxilliary loss scaled by its weight aux_loss_weight\n\n elif self.bc_loss == 1 and self.q_filter == 0: # train with demonstrations without q_filter\n self.cloning_loss_tf = tf.reduce_sum(tf.square(tf.boolean_mask((self.main.pi_tf), mask) - tf.boolean_mask((batch_tf['u']), mask)))\n self.pi_loss_tf = -self.prm_loss_weight * tf.reduce_mean(self.main.Q_pi_tf)\n self.pi_loss_tf += self.prm_loss_weight * self.action_l2 * tf.reduce_mean(tf.square(self.main.pi_tf / self.max_u))\n self.pi_loss_tf += self.aux_loss_weight * self.cloning_loss_tf\n\n else: #If not training with demonstrations\n self.pi_loss_tf = -tf.reduce_mean(self.main.Q_pi_tf)\n self.pi_loss_tf += self.action_l2 * tf.reduce_mean(tf.square(self.main.pi_tf / self.max_u))\n\n Q_grads_tf = tf.gradients(self.Q_loss_tf, self._vars('main/Q'))\n pi_grads_tf = tf.gradients(self.pi_loss_tf, self._vars('main/pi'))\n assert len(self._vars('main/Q')) == len(Q_grads_tf)\n assert len(self._vars('main/pi')) == len(pi_grads_tf)\n self.Q_grads_vars_tf = zip(Q_grads_tf, self._vars('main/Q'))\n self.pi_grads_vars_tf = zip(pi_grads_tf, self._vars('main/pi'))\n self.Q_grad_tf = flatten_grads(grads=Q_grads_tf, var_list=self._vars('main/Q'))\n self.pi_grad_tf = flatten_grads(grads=pi_grads_tf, var_list=self._vars('main/pi'))\n\n # optimizers\n self.Q_adam = MpiAdam(self._vars('main/Q'), scale_grad_by_procs=False)\n self.pi_adam = MpiAdam(self._vars('main/pi'), scale_grad_by_procs=False)\n\n # polyak averaging\n self.main_vars = self._vars('main/Q') + self._vars('main/pi')\n self.target_vars = self._vars('target/Q') + self._vars('target/pi')\n self.stats_vars = self._global_vars('o_stats') + self._global_vars('g_stats')\n self.init_target_net_op = list(\n map(lambda v: v[0].assign(v[1]), zip(self.target_vars, self.main_vars)))\n self.update_target_net_op = list(\n map(lambda v: v[0].assign(self.polyak * v[0] + (1. - self.polyak) * v[1]), zip(self.target_vars, self.main_vars)))\n\n # initialize all variables\n tf.variables_initializer(self._global_vars('')).run()\n self._sync_optimizers()\n self._init_target_net()\n\n def logs(self, prefix=''):\n logs = []\n logs += [('stats_o/mean', np.mean(self.sess.run([self.o_stats.mean])))]\n logs += [('stats_o/std', np.mean(self.sess.run([self.o_stats.std])))]\n logs += [('stats_g/mean', np.mean(self.sess.run([self.g_stats.mean])))]\n logs += [('stats_g/std', np.mean(self.sess.run([self.g_stats.std])))]\n\n if prefix != '' and not prefix.endswith('/'):\n return [(prefix + '/' + key, val) for key, val in logs]\n else:\n return logs\n\n def __getstate__(self):\n \"\"\"Our policies can be loaded from pkl, but after unpickling you cannot continue training.\n \"\"\"\n excluded_subnames = ['_tf', '_op', '_vars', '_adam', 'buffer', 'sess', '_stats',\n 'main', 'target', 'lock', 'env', 'sample_transitions',\n 'stage_shapes', 'create_actor_critic']\n\n state = {k: v for k, v in self.__dict__.items() if all([not subname in k for subname in excluded_subnames])}\n state['buffer_size'] = self.buffer_size\n state['tf'] = self.sess.run([x for x in self._global_vars('') if 'buffer' not in x.name])\n return state\n\n def __setstate__(self, state):\n if 'sample_transitions' not in state:\n # We don't need this for playing the policy.\n state['sample_transitions'] = None\n\n self.__init__(**state)\n # set up stats (they are overwritten in __init__)\n for k, v in state.items():\n if k[-6:] == '_stats':\n self.__dict__[k] = v\n # load TF variables\n vars = [x for x in self._global_vars('') if 'buffer' not in x.name]\n assert(len(vars) == len(state[\"tf\"]))\n node = [tf.assign(var, val) for var, val in zip(vars, state[\"tf\"])]\n self.sess.run(node)\n\n def save(self, save_path):\n tf_util.save_variables(save_path)\n\n"
] | [
[
"tensorflow.python.keras.utils.vis_utils.model_to_dot",
"tensorflow.keras.Model",
"tensorflow.keras.layers.Input"
],
[
"numpy.random.randn",
"tensorflow.boolean_mask",
"numpy.clip",
"tensorflow.get_collection",
"tensorflow.stop_gradient",
"tensorflow.square",
"numpy.load",
"numpy.zeros",
"tensorflow.placeholder",
"numpy.random.binomial",
"numpy.array",
"tensorflow.clip_by_value",
"tensorflow.reduce_mean",
"tensorflow.reshape",
"tensorflow.assign",
"numpy.ones",
"tensorflow.variable_scope",
"numpy.random.uniform",
"numpy.empty"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"2.7",
"2.2",
"2.3",
"2.4",
"2.5",
"2.6"
]
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"1.10",
"1.12",
"1.4",
"1.5",
"1.7",
"0.12",
"1.0",
"1.2"
]
}
] |
leon-liangwu/PillarsRNN | [
"b6e7d64af4e2819098ae9a87a9dd676ee8288874"
] | [
"display3d/msic.py"
] | [
"from __future__ import division, print_function\nimport numpy as np\n\nfrom shapely.geometry import Polygon\nimport cv2\n\nfrom collections import defaultdict\n\nfrom kitti import Calibration\n\n\ndef camera_to_lidar(points, r_rect, velo2cam):\n points_shape = list(points.shape[0:-1])\n if points.shape[-1] == 3:\n points = np.concatenate([points, np.ones(points_shape + [1])], axis=-1)\n lidar_points = np.dot(points, np.linalg.inv(np.dot(r_rect, velo2cam).T))\n return lidar_points[..., :3]\n\n\ndef lidar_to_camera(points, r_rect, velo2cam):\n points_shape = list(points.shape[:-1])\n if points.shape[-1] == 3:\n points = np.concatenate([points, np.ones(points_shape + [1])], axis=-1)\n camera_points = np.dot(points, np.dot(r_rect, velo2cam).T)\n return camera_points[..., :3]\n\n\ndef box_lidar_to_camera(data, r_rect, velo2cam):\n xyz_lidar = data[:, 0:3]\n w, l, h = data[:, 3:4], data[:, 4:5], data[:, 5:6]\n r = data[:, 6:7]\n xyz = lidar_to_camera(xyz_lidar, r_rect, velo2cam)\n return np.concatenate([xyz, l, h, w, r], axis=1)\n\n\ndef box_camera_to_lidar(data, r_rect, velo2cam):\n xyz = data[:, 0:3]\n l, h, w = data[:, 3:4], data[:, 4:5], data[:, 5:6]\n r = data[:, 6:7]\n xyz_lidar = camera_to_lidar(xyz, r_rect, velo2cam)\n return np.concatenate([xyz_lidar, w, l, h, r], axis=1)\n\n\ndef cuboid_to_corners(cuboid):\n (cls_id, x, y, z, w, l, h, theta) = cuboid\n theta = (theta + np.pi / 2) # (theta + np.pi / 2)\n cos_t = np.cos(theta)\n sin_t = np.sin(theta)\n centre_x = x\n centre_y = y\n\n rear_left_x = centre_x - l / 2 * cos_t - w / 2 * sin_t\n rear_left_y = centre_y - l / 2 * sin_t + w / 2 * cos_t\n rear_right_x = centre_x - l / 2 * cos_t + w / 2 * sin_t\n rear_right_y = centre_y - l / 2 * sin_t - w / 2 * cos_t\n front_right_x = centre_x + l / 2 * cos_t + w / 2 * sin_t\n front_right_y = centre_y + l / 2 * sin_t - w / 2 * cos_t\n front_left_x = centre_x + l / 2 * cos_t - w / 2 * sin_t\n front_left_y = centre_y + l / 2 * sin_t + w / 2 * cos_t\n corners = np.array([rear_left_x, rear_left_y, rear_right_x, rear_right_y,\n front_right_x, front_right_y, front_left_x, front_left_y]).reshape((4, 2))\n return corners\n\n\ndef get_corners_list(reg_list):\n corners_list = []\n for reg in reg_list:\n (prob, w, l, h, centre_x, centre_y, z, theta) = reg\n\n cos_t = np.cos(theta)\n sin_t = np.sin(theta)\n\n rear_left_x = centre_x - l / 2 * cos_t - w / 2 * sin_t\n rear_left_y = centre_y - l / 2 * sin_t + w / 2 * cos_t\n rear_right_x = centre_x - l / 2 * cos_t + w / 2 * sin_t\n rear_right_y = centre_y - l / 2 * sin_t - w / 2 * cos_t\n front_right_x = centre_x + l / 2 * cos_t + w / 2 * sin_t\n front_right_y = centre_y + l / 2 * sin_t - w / 2 * cos_t\n front_left_x = centre_x + l / 2 * cos_t - w / 2 * sin_t\n front_left_y = centre_y + l / 2 * sin_t + w / 2 * cos_t\n corners = np.array([rear_left_x, rear_left_y, rear_right_x, rear_right_y,\n front_right_x, front_right_y, front_left_x, front_left_y]).reshape((4, 2))\n\n corners_list.append(corners)\n\n return corners_list\n\n\n\ndef roty(t):\n ''' Rotation about the y-axis. '''\n c = np.cos(t)\n s = np.sin(t)\n return np.array([[c, 0, s],\n [0, 1, 0],\n [-s, 0, c]])\n\n\ndef rotz(t):\n ''' Rotation about the z-axis. '''\n c = np.cos(t)\n s = np.sin(t)\n return np.array([[c, -s, 0],\n [s, c, 0],\n [0, 0, 1]])\n\n\ndef get_corners_3d(reg_list):\n corners_list = []\n for reg in reg_list:\n (prob, w, l, h, centre_x, centre_y, z, theta) = reg\n\n R = rotz(-theta-np.pi/2)\n\n x_corners = [l / 2, l / 2, -l / 2, -l / 2, l / 2, l / 2, -l / 2, -l / 2]\n y_corners = [w / 2, -w / 2, -w / 2, w / 2, w / 2, -w / 2, -w / 2, w / 2]\n z_corners = [0, 0, 0, 0, h, h, h, h]\n # z_corners = [-h/2, -h/2, -h/2, -h/2, h/2, h/2, h/2, h/2]\n\n corners_3d = np.dot(R, np.vstack([x_corners, y_corners, z_corners]))\n # print corners_3d.shape\n corners_3d[0, :] = corners_3d[0, :] + centre_x\n corners_3d[1, :] = corners_3d[1, :] + centre_y\n corners_3d[2, :] = corners_3d[2, :] + z\n\n corners_3d = corners_3d.transpose(1, 0)\n\n corners_list.append(corners_3d)\n\n corners_list = np.array(corners_list)\n\n return corners_list\n\n\ndef decode_output_box3d(prediction, rpn_mode=False, anchors=None):\n reg_list, cls_list = get_reg_list_rpn(prediction, anchors)\n corners_3d = get_corners_3d(reg_list)\n # corners_list = get_corners_list(reg_list)\n return corners_3d, reg_list, cls_list\n\n\ndef get_det_info(prediction, bev_data, img_path, rpn_mode=False, anchors=None):\n if not rpn_mode:\n reg_list, cls_list = get_reg_list(prediction)\n else:\n reg_list, cls_list = get_reg_list_rpn(prediction, anchors)\n\n calib_path = img_path.replace('velodyne', 'calib')\n calib_path = calib_path.replace('.bin', '.txt')\n calib = Calibration(calib_path)\n\n reg_list[:, [5, 6, 4]] = calib.project_velo_to_rect(reg_list[:, 4:7])\n reg_list[:, 5] *= -1\n\n corners_list = get_corners_list(reg_list)\n prob_list = []\n\n for i in range(len(reg_list)):\n prob_list.append(reg_list[i][0])\n return corners_list, reg_list, prob_list, cls_list\n\n\n\ndef convert_format(boxes_array):\n \"\"\"\n\n :param array: an array of shape [# bboxs, 4, 2]\n :return: a shapely.geometry.Polygon object\n \"\"\"\n\n polygons = [Polygon([(box[i, 0], box[i, 1]) for i in range(4)]) for box in boxes_array]\n return np.array(polygons)\n\n\ndef compute_iou(box1, box2):\n \"\"\"Calculates IoU of the given box with the array of the given boxes.\n box: a polygon\n boxes: a vector of polygons\n Note: the areas are passed in rather than calculated here for\n efficiency. Calculate once in the caller to avoid duplicate work.\n \"\"\"\n # Calculate intersection areas\n iou = box1.intersection(box2).area / box1.union(box2).area\n\n return iou\n\n\n\n\ndef merge_mini_batch(batch_list, _unused=False):\n batch_size = len(batch_list)\n example_merged = defaultdict(list)\n for example in batch_list:\n for k, v in example.items():\n example_merged[k].append(v)\n ret = {}\n for key, elems in example_merged.items():\n if key in ['pillar']:\n print('pillar shape', elems[0].shape)\n ret[key] = np.concatenate(elems, axis=0)\n elif key == 'coords':\n coors = []\n for i, coor in enumerate(elems):\n print('coor shape', coor.shape)\n coor_pad = np.pad(\n coor, ((0, 0), (1, 0)),\n mode='constant',\n constant_values=i)\n coors.append(coor_pad)\n ret[key] = np.concatenate(coors, axis=0)\n else:\n ret[key] = np.stack(elems, axis=0)\n\n return ret\n"
] | [
[
"numpy.dot",
"numpy.pad",
"numpy.cos",
"numpy.stack",
"numpy.sin",
"numpy.concatenate",
"numpy.ones",
"numpy.array",
"numpy.vstack"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
cregouby/FARM | [
"552bc07acffbce4f1f84d926c040fdd17b4ddeb3"
] | [
"farm/file_utils.py"
] | [
"\"\"\"\nUtilities for working with the local dataset cache.\nThis file is adapted from the AllenNLP library at https://github.com/allenai/allennlp\nCopyright by the AllenNLP authors.\n\"\"\"\nfrom __future__ import absolute_import, division, print_function, unicode_literals\n\nimport fnmatch\nimport json\nimport logging\nimport os\nimport shutil\nimport sys\nimport tempfile\nfrom functools import wraps\nfrom hashlib import sha256\nfrom io import open\n\nimport boto3\nimport numpy as np\nimport requests\nfrom botocore.exceptions import ClientError\nfrom dotmap import DotMap\nfrom tqdm import tqdm\n\ntry:\n from torch.hub import _get_torch_home\n\n torch_cache_home = _get_torch_home()\nexcept ImportError:\n torch_cache_home = os.path.expanduser(\n os.getenv(\n \"TORCH_HOME\", os.path.join(os.getenv(\"XDG_CACHE_HOME\", \"~/.cache\"), \"torch\")\n )\n )\ndefault_cache_path = os.path.join(torch_cache_home, \"farm\")\n\ntry:\n from urllib.parse import urlparse\nexcept ImportError:\n from urlparse import urlparse\n\ntry:\n from pathlib import Path\n\n FARM_CACHE = Path(os.getenv(\"FARM_CACHE\", default_cache_path))\nexcept (AttributeError, ImportError):\n FARM_CACHE = os.getenv(\"FARM_CACHE\", default_cache_path)\n\n\nlogger = logging.getLogger(__name__) # pylint: disable=invalid-name\n\n\ndef url_to_filename(url, etag=None):\n \"\"\"\n Convert `url` into a hashed filename in a repeatable way.\n If `etag` is specified, append its hash to the url's, delimited\n by a period.\n \"\"\"\n url_bytes = url.encode(\"utf-8\")\n url_hash = sha256(url_bytes)\n filename = url_hash.hexdigest()\n\n if etag:\n etag_bytes = etag.encode(\"utf-8\")\n etag_hash = sha256(etag_bytes)\n filename += \".\" + etag_hash.hexdigest()\n\n return filename\n\n\ndef filename_to_url(filename, cache_dir=None):\n \"\"\"\n Return the url and etag (which may be ``None``) stored for `filename`.\n Raise ``EnvironmentError`` if `filename` or its stored metadata do not exist.\n \"\"\"\n if cache_dir is None:\n cache_dir = FARM_CACHE\n if sys.version_info[0] == 3 and isinstance(cache_dir, Path):\n cache_dir = str(cache_dir)\n\n cache_path = os.path.join(cache_dir, filename)\n if not os.path.exists(cache_path):\n raise EnvironmentError(\"file {} not found\".format(cache_path))\n\n meta_path = cache_path + \".json\"\n if not os.path.exists(meta_path):\n raise EnvironmentError(\"file {} not found\".format(meta_path))\n\n with open(meta_path, encoding=\"utf-8\") as meta_file:\n metadata = json.load(meta_file)\n url = metadata[\"url\"]\n etag = metadata[\"etag\"]\n\n return url, etag\n\n\ndef cached_path(url_or_filename, cache_dir=None):\n \"\"\"\n Given something that might be a URL (or might be a local path),\n determine which. If it's a URL, download the file and cache it, and\n return the path to the cached file. If it's already a local path,\n make sure the file exists and then return the path.\n \"\"\"\n if cache_dir is None:\n cache_dir = FARM_CACHE\n if sys.version_info[0] == 3 and isinstance(url_or_filename, Path):\n url_or_filename = str(url_or_filename)\n if sys.version_info[0] == 3 and isinstance(cache_dir, Path):\n cache_dir = str(cache_dir)\n\n parsed = urlparse(url_or_filename)\n\n if parsed.scheme in (\"http\", \"https\", \"s3\"):\n # URL, so get it from the cache (downloading if necessary)\n return get_from_cache(url_or_filename, cache_dir)\n elif os.path.exists(url_or_filename):\n # File, and it exists.\n return url_or_filename\n elif parsed.scheme == \"\":\n # File, but it doesn't exist.\n raise EnvironmentError(\"file {} not found\".format(url_or_filename))\n else:\n # Something unknown\n raise ValueError(\n \"unable to parse {} as a URL or as a local path\".format(url_or_filename)\n )\n\n\ndef split_s3_path(url):\n \"\"\"Split a full s3 path into the bucket name and path.\"\"\"\n parsed = urlparse(url)\n if not parsed.netloc or not parsed.path:\n raise ValueError(\"bad s3 path {}\".format(url))\n bucket_name = parsed.netloc\n s3_path = parsed.path\n # Remove '/' at beginning of path.\n if s3_path.startswith(\"/\"):\n s3_path = s3_path[1:]\n return bucket_name, s3_path\n\n\ndef s3_request(func):\n \"\"\"\n Wrapper function for s3 requests in order to create more helpful error\n messages.\n \"\"\"\n\n @wraps(func)\n def wrapper(url, *args, **kwargs):\n try:\n return func(url, *args, **kwargs)\n except ClientError as exc:\n if int(exc.response[\"Error\"][\"Code\"]) == 404:\n raise EnvironmentError(\"file {} not found\".format(url))\n else:\n raise\n\n return wrapper\n\n\n@s3_request\ndef s3_etag(url):\n \"\"\"Check ETag on S3 object.\"\"\"\n s3_resource = boto3.resource(\"s3\")\n bucket_name, s3_path = split_s3_path(url)\n s3_object = s3_resource.Object(bucket_name, s3_path)\n return s3_object.e_tag\n\n\n@s3_request\ndef s3_get(url, temp_file):\n \"\"\"Pull a file directly from S3.\"\"\"\n s3_resource = boto3.resource(\"s3\")\n bucket_name, s3_path = split_s3_path(url)\n s3_resource.Bucket(bucket_name).download_fileobj(s3_path, temp_file)\n\n\ndef http_get(url, temp_file, proxies=None):\n req = requests.get(url, stream=True, proxies=proxies)\n content_length = req.headers.get(\"Content-Length\")\n total = int(content_length) if content_length is not None else None\n progress = tqdm(unit=\"B\", total=total)\n for chunk in req.iter_content(chunk_size=1024):\n if chunk: # filter out keep-alive new chunks\n progress.update(len(chunk))\n temp_file.write(chunk)\n progress.close()\n\n\ndef get_from_cache(url, cache_dir=None):\n \"\"\"\n Given a URL, look for the corresponding dataset in the local cache.\n If it's not there, download it. Then return the path to the cached file.\n \"\"\"\n if cache_dir is None:\n cache_dir = FARM_CACHE\n if sys.version_info[0] == 3 and isinstance(cache_dir, Path):\n cache_dir = str(cache_dir)\n\n if not os.path.exists(cache_dir):\n os.makedirs(cache_dir)\n\n # Get eTag to add to filename, if it exists.\n if url.startswith(\"s3://\"):\n etag = s3_etag(url)\n else:\n try:\n response = requests.head(url, allow_redirects=True)\n if response.status_code != 200:\n etag = None\n else:\n etag = response.headers.get(\"ETag\")\n except EnvironmentError:\n etag = None\n\n if sys.version_info[0] == 2 and etag is not None:\n etag = etag.decode(\"utf-8\")\n filename = url_to_filename(url, etag)\n\n # get cache path to put the file\n cache_path = os.path.join(cache_dir, filename)\n\n # If we don't have a connection (etag is None) and can't identify the file\n # try to get the last downloaded one\n if not os.path.exists(cache_path) and etag is None:\n matching_files = fnmatch.filter(os.listdir(cache_dir), filename + \".*\")\n matching_files = list(filter(lambda s: not s.endswith(\".json\"), matching_files))\n if matching_files:\n cache_path = os.path.join(cache_dir, matching_files[-1])\n\n if not os.path.exists(cache_path):\n # Download to temporary file, then copy to cache dir once finished.\n # Otherwise you get corrupt cache entries if the download gets interrupted.\n with tempfile.NamedTemporaryFile() as temp_file:\n logger.info(\"%s not found in cache, downloading to %s\", url, temp_file.name)\n\n # GET file object\n if url.startswith(\"s3://\"):\n s3_get(url, temp_file)\n else:\n http_get(url, temp_file)\n\n # we are copying the file before closing it, so flush to avoid truncation\n temp_file.flush()\n # shutil.copyfileobj() starts at the current position, so go to the start\n temp_file.seek(0)\n\n logger.info(\"copying %s to cache at %s\", temp_file.name, cache_path)\n with open(cache_path, \"wb\") as cache_file:\n shutil.copyfileobj(temp_file, cache_file)\n\n logger.info(\"creating metadata file for %s\", cache_path)\n meta = {\"url\": url, \"etag\": etag}\n meta_path = cache_path + \".json\"\n with open(meta_path, \"w\") as meta_file:\n output_string = json.dumps(meta)\n if sys.version_info[0] == 2 and isinstance(output_string, str):\n output_string = unicode(\n output_string, \"utf-8\"\n ) # The beauty of python 2\n meta_file.write(output_string)\n\n logger.info(\"removing temp file %s\", temp_file.name)\n\n return cache_path\n\n\ndef read_set_from_file(filename):\n \"\"\"\n Extract a de-duped collection (set) of text from a file.\n Expected file format is one item per line.\n \"\"\"\n collection = set()\n with open(filename, \"r\", encoding=\"utf-8\") as file_:\n for line in file_:\n collection.add(line.rstrip())\n return collection\n\n\ndef get_file_extension(path, dot=True, lower=True):\n ext = os.path.splitext(path)[1]\n ext = ext if dot else ext[1:]\n return ext.lower() if lower else ext\n\n\ndef read_config(path, flattend=False):\n if path:\n with open(path) as json_data_file:\n conf_args = json.load(json_data_file)\n else:\n raise ValueError(\"No config provided for classifier\")\n\n def getArgValue(arg):\n if \"value\" not in arg:\n logger.error(\n \"Only depth 2 config files supported. Failed to convert: %s\" % str(arg)\n )\n return arg[\"value\"] if (arg[\"value\"] is not None) else arg[\"default\"]\n\n # flatten last part of config, take either value or default as value\n for gk, gv in conf_args.items():\n for k, v in gv.items():\n if isinstance(getArgValue(v), dict):\n logger.error(\"Config is too deeply nested, at %s\" % str(v))\n conf_args[gk][k] = getArgValue(v)\n\n # DotMap for making nested dictionary accessible through dot notation\n flat_args = dict(\n conf_args[\"general\"],\n **conf_args[\"task\"],\n **conf_args[\"parameter\"],\n **conf_args[\"logging\"],\n )\n if flattend:\n args = DotMap(flat_args, _dynamic=False)\n else:\n args = DotMap(conf_args, _dynamic=False)\n\n return args\n\n\ndef unnestConfig(config, flattened=False):\n \"\"\"\n This function creates a list of config files for evaluating parameters with different values. If a config parameter\n is of type list this list is iterated over and a config object without lists is returned. Can handle lists inside any\n number of parameters.\n\n Can handle shallow or nested (one level) configs\n \"\"\"\n nestedKeys = []\n nestedVals = []\n if flattened:\n for k, v in config.items():\n if isinstance(v, list):\n if k != \"layer_dims\": # exclude layer dims, since it is already a list\n nestedKeys.append(k)\n nestedVals.append(v)\n else:\n for gk, gv in config.items():\n if(gk != \"task\"):\n for k, v in gv.items():\n if isinstance(v, list):\n if isinstance(v, list):\n if (\n k != \"layer_dims\"\n ): # exclude layer dims, since it is already a list\n nestedKeys.append([gk, k])\n nestedVals.append(v)\n elif isinstance(v, dict):\n logger.error(\"Config too deep!\")\n\n if len(nestedKeys) == 0:\n unnestedConfig = [config]\n else:\n if flattened:\n logger.info(\"Nested config at parameters: %s\" % (\", \".join(nestedKeys)))\n else:\n logger.info(\n \"Nested config at parameters: %s\"\n % (\", \".join(\".\".join(x) for x in nestedKeys))\n )\n unnestedConfig = []\n mesh = np.meshgrid(\n *nestedVals\n ) # get all combinations, each dimension corresponds to one parameter type\n # flatten mesh into shape: [num_parameters, num_combinations] so we can iterate in 2d over any paramter combinations\n mesh = [x.flatten() for x in mesh]\n\n # loop over all combinations\n for i in range(len(mesh[0])):\n tempconfig = config.copy()\n for j, k in enumerate(nestedKeys):\n if isinstance(k, str):\n tempconfig[k] = mesh[j][\n i\n ] # get ith val of correct param value and overwrite original config\n elif len(k) == 2:\n tempconfig[k[0]][k[1]] = mesh[j][i] # set nested dictionary keys\n else:\n logger.error(\"Config too deep!\")\n unnestedConfig.append(tempconfig)\n\n return unnestedConfig\n"
] | [
[
"torch.hub._get_torch_home",
"numpy.meshgrid"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
rubenrtorrado/NLP | [
"2ba6f153e428227fcf6f27080bdd0183d395ef64"
] | [
"alpha-zero-general_one_step/MCTS_Bleu.py"
] | [
"import math\nimport numpy as np\nEPS = 1e-8\n\nclass MCTS():\n \"\"\"\n This class handles the MCTS tree.\n \"\"\"\n\n def __init__(self, game, nnet, args):\n self.game = game\n self.nnet = nnet\n self.args = args\n self.Qsa = {} # stores Q values for s,a (as defined in the paper)\n self.Nsa = {} # stores #times edge s,a was visited\n self.Ns = {} # stores #times board s was visited\n self.Ps = {} # stores initial policy (returned by neural net)\n\n self.Es = {} # stores game.getGameEnded ended for board s\n self.Vs = {} # stores game.getValidMoves for board s\n\n def getActionProb(self, canonicalBoard, temp=1):\n \"\"\"\n This function performs numMCTSSims simulations of MCTS starting from\n canonicalBoard.\n\n Returns:\n probs: a policy vector where the probability of the ith action is\n proportional to Nsa[(s,a)]**(1./temp)\n \"\"\"\n for i in range(self.args.numMCTSSims):\n self.search(canonicalBoard)\n\n s = self.game.stringRepresentation(canonicalBoard)\n counts = [self.Nsa[(s,a)] if (s,a) in self.Nsa else 0 for a in range(self.game.getActionSize())]\n\n if temp==0:\n bestA = np.argmax(counts)\n probs = [0]*len(counts)\n probs[bestA]=1\n return probs\n\n counts = [x**(1./temp) for x in counts]\n probs = [x/float(sum(counts)) for x in counts]\n return probs\n\n\n def search(self, canonicalBoard):\n \"\"\"\n This function performs one iteration of MCTS. It is recursively called\n till a leaf node is found. The action chosen at each node is one that\n has the maximum upper confidence bound as in the paper.\n\n Once a leaf node is found, the neural network is called to return an\n initial policy P and a value v for the state. This value is propogated\n up the search path. In case the leaf node is a terminal state, the\n outcome is propogated up the search path. The values of Ns, Nsa, Qsa are\n updated.\n\n NOTE: the return values are the negative of the value of the current\n state. This is done since v is in [-1,1] and if v is the value of a\n state for the current player, then its value is -v for the other player.\n\n Returns:\n v: the negative of the value of the current canonicalBoard\n \"\"\"\n\n s = self.game.stringRepresentation(canonicalBoard)\n\n if s not in self.Es:\n self.Es[s] = self.game.getGameEnded_BLEU(canonicalBoard, 1)\n if self.Es[s]!=0:\n # terminal node\n\n #test=self.Es[s]\n\n return self.Es[s]\n\n if s not in self.Ps:\n # leaf node\n self.Ps[s], v = self.nnet.predict(canonicalBoard)\n valids = self.game.getValidMoves(canonicalBoard, 1)\n self.Ps[s] = self.Ps[s]*valids # masking invalid moves\n #Ruben\n self.Ps[s]=self.Ps[s].T\n sum_Ps_s = np.sum(self.Ps[s])\n if sum_Ps_s > 0:\n self.Ps[s] /= sum_Ps_s # renormalize\n else:\n # if all valid moves were masked make all valid moves equally probable\n \n # NB! All valid moves may be masked if either your NNet architecture is insufficient or you've get overfitting or something else.\n # If you have got dozens or hundreds of these messages you should pay attention to your NNet and/or training process. \n print(\"All valid moves were masked, do workaround.\")\n self.Ps[s] = self.Ps[s] + valids\n self.Ps[s] /= np.sum(self.Ps[s])\n\n self.Vs[s] = valids\n self.Ns[s] = 0\n return v#-v\n\n valids = self.Vs[s]\n cur_best = -float('inf')\n best_act = -1\n\n # pick the action with the highest upper confidence bound\n for a in range(self.game.getActionSize()):\n if valids[a]:\n if (s,a) in self.Qsa:\n\n u = self.Qsa[(s,a)] + self.args.cpuct*self.Ps[s][a]*math.sqrt(self.Ns[s])/(1+self.Nsa[(s,a)])\n\n\n else:\n u = self.args.cpuct*self.Ps[s][a]*math.sqrt(self.Ns[s] + EPS) # Q = 0 ?\n\n if u > cur_best:\n cur_best = u\n best_act = a\n\n a = best_act\n next_s, next_player = self.game.getNextState(canonicalBoard, 1, a)\n next_s = self.game.getCanonicalForm(next_s, next_player)\n\n v = self.search(next_s)\n\n if (s,a) in self.Qsa:\n self.Qsa[(s,a)] = (self.Nsa[(s,a)]*self.Qsa[(s,a)] + v)/(self.Nsa[(s,a)]+1)\n self.Nsa[(s,a)] += 1\n\n else:\n self.Qsa[(s,a)] = v\n self.Nsa[(s,a)] = 1\n\n self.Ns[s] += 1\n return v#-v\n"
] | [
[
"numpy.argmax",
"numpy.sum"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
schr476/EXARL | [
"7f4596bd8b3d7960aaf52bc677ceac4f37029834",
"7f4596bd8b3d7960aaf52bc677ceac4f37029834"
] | [
"exarl/candlelib/uq_utils.py",
"exarl/agents/agent_vault/dqn.py"
] | [
"from __future__ import absolute_import\n\nimport numpy as np\nfrom scipy.stats import pearsonr, spearmanr\nfrom scipy import signal\nfrom scipy.interpolate import InterpolatedUnivariateSpline\n\n\ndef generate_index_distribution(numTrain, numTest, numValidation, params):\n \"\"\" Generates a vector of indices to partition the data for training.\n NO CHECKING IS DONE: it is assumed that the data could be partitioned\n in the specified blocks and that the block indices describe a coherent\n partition.\n\n Parameters\n ----------\n numTrain : int\n Number of training data points\n numTest : int\n Number of testing data points\n numValidation : int\n Number of validation data points (may be zero)\n params : dictionary with parameters\n Contains the keywords that control the behavior of the function\n (uq_train_fr, uq_valid_fr, uq_test_fr for fraction specification,\n uq_train_vec, uq_valid_vec, uq_test_vec for block list specification, and\n uq_train_bks, uq_valid_bks, uq_test_bks for block number specification)\n\n Return\n ----------\n indexTrain : int numpy array\n Indices for data in training\n indexValidation : int numpy array\n Indices for data in validation (if any)\n indexTest : int numpy array\n Indices for data in testing (if merging)\n \"\"\"\n if all(k in params for k in ('uq_train_fr', 'uq_valid_fr', 'uq_test_fr')):\n # specification by fraction\n print(\"Computing UQ cross-validation - Distributing by FRACTION\")\n return generate_index_distribution_from_fraction(numTrain, numTest, numValidation, params)\n elif all(k in params for k in ('uq_train_vec', 'uq_valid_vec', 'uq_test_vec')):\n # specification by block list\n print(\"Computing UQ cross-validation - Distributing by BLOCK LIST\")\n return generate_index_distribution_from_block_list(numTrain, numTest, numValidation, params)\n elif all(k in params for k in ('uq_train_bks', 'uq_valid_bks', 'uq_test_bks')):\n # specification by block size\n print(\"Computing UQ cross-validation - Distributing by BLOCK NUMBER\")\n return generate_index_distribution_from_blocks(numTrain, numTest, numValidation, params)\n else:\n print(\"ERROR !! No consistent UQ parameter specification found !! ... exiting \")\n raise KeyError(\"No valid triplet of ('uq_train_*', 'uq_valid_*', 'uq_test_*') found. (* is any of fr, vec or bks)\")\n\n\ndef generate_index_distribution_from_fraction(numTrain, numTest, numValidation, params):\n \"\"\" Generates a vector of indices to partition the data for training.\n It checks that the fractions provided are (0, 1) and add up to 1.\n\n Parameters\n ----------\n numTrain : int\n Number of training data points\n numTest : int\n Number of testing data points\n numValidation : int\n Number of validation data points (may be zero)\n params : dictionary with parameters\n Contains the keywords that control the behavior of the function\n (uq_train_fr, uq_valid_fr, uq_test_fr)\n\n Return\n ----------\n indexTrain : int numpy array\n Indices for data in training\n indexValidation : int numpy array\n Indices for data in validation (if any)\n indexTest : int numpy array\n Indices for data in testing (if merging)\n \"\"\"\n\n tol = 1e-7\n\n # Extract required parameters\n fractionTrain = params['uq_train_fr']\n fractionValidation = params['uq_valid_fr']\n fractionTest = params['uq_test_fr']\n\n if (fractionTrain < 0.) or (fractionTrain > 1.):\n raise ValueError('uq_train_fr is not in (0, 1) range. uq_train_fr: ', fractionTrain)\n if (fractionValidation < 0.) or (fractionValidation > 1.):\n raise ValueError('uq_valid_fr is not in (0, 1) range. uq_valid_fr: ', fractionValidation)\n if (fractionTest < 0.) or (fractionTest > 1.):\n raise ValueError('uq_test_fr is not in (0, 1) range. uq_test_fr: ', fractionTest)\n\n fractionSum = fractionTrain + fractionValidation + fractionTest\n # if (fractionSum > 1.) or (fractionSum < 1.):\n if abs(fractionSum - 1.) > tol:\n raise ValueError(\n 'Specified UQ fractions (uq_train_fr, uq_valid_fr, uq_test_fr) do not add up to 1. No cross-validation partition is computed ! sum:',\n fractionSum)\n\n # Determine data size and block size\n if fractionTest > 0:\n # Use all data and re-distribute the partitions\n numData = numTrain + numValidation + numTest\n else:\n # Preserve test partition\n numData = numTrain + numValidation\n\n sizeTraining = int(np.round(numData * fractionTrain))\n sizeValidation = int(np.round(numData * fractionValidation))\n\n # Fill partition indices\n # Fill train partition\n Folds = np.arange(numData)\n np.random.shuffle(Folds)\n indexTrain = Folds[:sizeTraining]\n # Fill validation partition\n indexValidation = None\n if fractionValidation > 0:\n indexValidation = Folds[sizeTraining:sizeTraining + sizeValidation]\n # Fill test partition\n indexTest = None\n if fractionTest > 0:\n indexTest = Folds[sizeTraining + sizeValidation:]\n\n return indexTrain, indexValidation, indexTest\n\n\ndef generate_index_distribution_from_blocks(numTrain, numTest, numValidation, params):\n \"\"\" Generates a vector of indices to partition the data for training.\n NO CHECKING IS DONE: it is assumed that the data could be partitioned\n in the specified block quantities and that the block quantities describe a\n coherent partition.\n\n Parameters\n ----------\n numTrain : int\n Number of training data points\n numTest : int\n Number of testing data points\n numValidation : int\n Number of validation data points (may be zero)\n params : dictionary with parameters\n Contains the keywords that control the behavior of the function\n (uq_train_bks, uq_valid_bks, uq_test_bks)\n\n Return\n ----------\n indexTrain : int numpy array\n Indices for data in training\n indexValidation : int numpy array\n Indices for data in validation (if any)\n indexTest : int numpy array\n Indices for data in testing (if merging)\n \"\"\"\n\n # Extract required parameters\n numBlocksTrain = params['uq_train_bks']\n numBlocksValidation = params['uq_valid_bks']\n numBlocksTest = params['uq_test_bks']\n numBlocksTotal = numBlocksTrain + numBlocksValidation + numBlocksTest\n\n # Determine data size and block size\n if numBlocksTest > 0:\n # Use all data and re-distribute the partitions\n numData = numTrain + numValidation + numTest\n else:\n # Preserve test partition\n numData = numTrain + numValidation\n\n blockSize = (numData + numBlocksTotal // 2) // numBlocksTotal # integer division with rounding\n remainder = numData - blockSize * numBlocksTotal\n if remainder != 0:\n print(\"Warning ! Requested partition does not distribute data evenly between blocks. \"\n \"Testing (if specified) or Validation (if specified) will use different block size.\")\n\n sizeTraining = numBlocksTrain * blockSize\n sizeValidation = numBlocksValidation * blockSize\n\n # Fill partition indices\n # Fill train partition\n Folds = np.arange(numData)\n np.random.shuffle(Folds)\n indexTrain = Folds[:sizeTraining]\n # Fill validation partition\n indexValidation = None\n if numBlocksValidation > 0:\n indexValidation = Folds[sizeTraining:sizeTraining + sizeValidation]\n # Fill test partition\n indexTest = None\n if numBlocksTest > 0:\n indexTest = Folds[sizeTraining + sizeValidation:]\n\n return indexTrain, indexValidation, indexTest\n\n\ndef generate_index_distribution_from_block_list(numTrain, numTest, numValidation, params):\n \"\"\" Generates a vector of indices to partition the data for training.\n NO CHECKING IS DONE: it is assumed that the data could be partitioned\n in the specified list of blocks and that the block indices describe a\n coherent partition.\n\n Parameters\n ----------\n numTrain : int\n Number of training data points\n numTest : int\n Number of testing data points\n numValidation : int\n Number of validation data points (may be zero)\n params : dictionary with parameters\n Contains the keywords that control the behavior of the function\n (uq_train_vec, uq_valid_vec, uq_test_vec)\n\n Return\n ----------\n indexTrain : int numpy array\n Indices for data in training\n indexValidation : int numpy array\n Indices for data in validation (if any)\n indexTest : int numpy array\n Indices for data in testing (if merging)\n \"\"\"\n\n # Extract required parameters\n blocksTrain = params['uq_train_vec']\n blocksValidation = params['uq_valid_vec']\n blocksTest = params['uq_test_vec']\n\n # Determine data size and block size\n numBlocksTrain = len(blocksTrain)\n numBlocksValidation = len(blocksValidation)\n numBlocksTest = len(blocksTest)\n numBlocksTotal = numBlocksTrain + numBlocksValidation + numBlocksTest\n\n if numBlocksTest > 0:\n # Use all data and re-distribute the partitions\n numData = numTrain + numValidation + numTest\n else:\n # Preserve test partition\n numData = numTrain + numValidation\n\n blockSize = (numData + numBlocksTotal // 2) // numBlocksTotal # integer division with rounding\n remainder = numData - blockSize * numBlocksTotal\n if remainder != 0:\n print(\"Warning ! Requested partition does not distribute data evenly between blocks. \"\n \"Last block will have different size.\")\n if remainder < 0:\n remainder = 0\n\n # Fill partition indices\n # Fill train partition\n maxSizeTrain = blockSize * numBlocksTrain + remainder\n indexTrain = fill_array(blocksTrain, maxSizeTrain, numData, numBlocksTotal, blockSize)\n # Fill validation partition\n indexValidation = None\n if numBlocksValidation > 0:\n maxSizeValidation = blockSize * numBlocksValidation + remainder\n indexValidation = fill_array(blocksValidation, maxSizeValidation, numData, numBlocksTotal, blockSize)\n # Fill test partition\n indexTest = None\n if numBlocksTest > 0:\n maxSizeTest = blockSize * numBlocksTest + remainder\n indexTest = fill_array(blocksTest, maxSizeTest, numData, numBlocksTotal, blockSize)\n\n return indexTrain, indexValidation, indexTest\n\n\ndef compute_limits(numdata, numblocks, blocksize, blockn):\n \"\"\" Generates the limit of indices corresponding to a\n specific block. It takes into account the non-exact\n divisibility of numdata into numblocks letting the\n last block to take the extra chunk.\n\n Parameters\n ----------\n numdata : int\n Total number of data points to distribute\n numblocks : int\n Total number of blocks to distribute into\n blocksize : int\n Size of data per block\n blockn : int\n Index of block, from 0 to numblocks-1\n\n Return\n ----------\n start : int\n Position to start assigning indices\n end : int\n One beyond position to stop assigning indices\n \"\"\"\n start = blockn * blocksize\n end = start + blocksize\n if blockn == (numblocks - 1): # last block gets the extra\n end = numdata\n\n return start, end\n\n\ndef fill_array(blocklist, maxsize, numdata, numblocks, blocksize):\n \"\"\" Fills a new array of integers with the indices corresponding\n to the specified block structure.\n\n Parameters\n ----------\n blocklist : list\n List of integers describes the block indices that\n go into the array\n maxsize : int\n Maximum possible length for the partition (the size of the\n common block size plus the remainder, if any).\n numdata : int\n Total number of data points to distribute\n numblocks : int\n Total number of blocks to distribute into\n blocksize : int\n Size of data per block\n\n Return\n ----------\n indexArray : int numpy array\n Indices for specific data partition. Resizes the array\n to the correct length.\n \"\"\"\n\n indexArray = np.zeros(maxsize, np.int)\n\n offset = 0\n for i in blocklist:\n start, end = compute_limits(numdata, numblocks, blocksize, i)\n length = end - start\n indexArray[offset:offset + length] = np.arange(start, end)\n offset += length\n\n return indexArray[:offset]\n\n\n# UTILS for COMPUTATION OF EMPIRICAL CALIBRATION\n\ndef compute_statistics_homoscedastic(df_data,\n col_true=0,\n col_pred=6,\n col_std_pred=7,\n ):\n \"\"\" Extracts ground truth, mean prediction, error and\n standard deviation of prediction from inference\n data frame. The latter includes the statistics\n over all the inference realizations.\n\n Parameters\n ----------\n df_data : pandas data frame\n Data frame generated by current CANDLE inference\n experiments. Indices are hard coded to agree with\n current CANDLE version. (The inference file usually\n has the name: <model>_pred.tsv).\n col_true : integer\n Index of the column in the data frame where the true\n value is stored (Default: 0, index in current CANDLE format).\n col_pred : integer\n Index of the column in the data frame where the predicted\n value is stored (Default: 6, index in current CANDLE format).\n col_std_pred : integer\n Index of the column in the data frame where the standard\n deviation of the predicted values is stored (Default: 7,\n index in current CANDLE format).\n\n Return\n ----------\n Ytrue : numpy array\n Array with true (observed) values\n Ypred : numpy array\n Array with predicted values.\n yerror : numpy array\n Array with errors computed (observed - predicted).\n sigma : numpy array\n Array with standard deviations learned with deep learning\n model. For homoscedastic inference this corresponds to the\n std value computed from prediction (and is equal to the\n following returned variable).\n Ypred_std : numpy array\n Array with standard deviations computed from regular\n (homoscedastic) inference.\n pred_name : string\n Name of data column or quantity predicted (as extracted\n from the data frame using the col_true index).\n \"\"\"\n\n Ytrue = df_data.iloc[:, col_true].values\n print('Ytrue shape: ', Ytrue.shape)\n pred_name = df_data.columns[col_true]\n Ypred = df_data.iloc[:, col_pred].values\n print('Ypred shape: ', Ypred.shape)\n Ypred_std = df_data.iloc[:, col_std_pred].values\n print('Ypred_std shape: ', Ypred_std.shape)\n yerror = Ytrue - Ypred\n print('yerror shape: ', yerror.shape)\n sigma = Ypred_std # std\n MSE = np.mean((Ytrue - Ypred)**2)\n print('MSE: ', MSE)\n MSE_STD = np.std((Ytrue - Ypred)**2)\n print('MSE_STD: ', MSE_STD)\n # p-value 'not entirely reliable, reasonable for datasets > 500'\n spearman_cc, pval = spearmanr(Ytrue, Ypred)\n print('Spearman CC: %f, p-value: %e' % (spearman_cc, pval))\n\n return Ytrue, Ypred, yerror, sigma, Ypred_std, pred_name\n\n\ndef compute_statistics_homoscedastic_all(df_data,\n col_true=4,\n col_pred_start=6\n ):\n \"\"\" Extracts ground truth, mean prediction, error and\n standard deviation of prediction from inference\n data frame. The latter includes all the individual\n inference realizations.\n\n Parameters\n ----------\n df_data : pandas data frame\n Data frame generated by current CANDLE inference\n experiments. Indices are hard coded to agree with\n current CANDLE version. (The inference file usually\n has the name: <model>.predicted_INFER.tsv).\n col_true : integer\n Index of the column in the data frame where the true\n value is stored (Default: 4, index in current HOM format).\n col_pred_start : integer\n Index of the column in the data frame where the first predicted\n value is stored. All the predicted values during inference\n are stored (Default: 6 index, in current HOM format).\n\n Return\n ----------\n Ytrue : numpy array\n Array with true (observed) values\n Ypred : numpy array\n Array with predicted values.\n yerror : numpy array\n Array with errors computed (observed - predicted).\n sigma : numpy array\n Array with standard deviations learned with deep learning\n model. For homoscedastic inference this corresponds to the\n std value computed from prediction (and is equal to the\n following returned variable).\n Ypred_std : numpy array\n Array with standard deviations computed from regular\n (homoscedastic) inference.\n pred_name : string\n Name of data column or quantity predicted (as extracted\n from the data frame using the col_true index).\n \"\"\"\n\n Ytrue = df_data.iloc[:, col_true].values\n print('Ytrue shape: ', Ytrue.shape)\n pred_name = df_data.columns[col_true]\n Ypred_mean_ = np.mean(df_data.iloc[:, col_pred_start:], axis=1)\n Ypred_mean = Ypred_mean_.values\n print('Ypred_mean shape: ', Ypred_mean.shape)\n Ypred_std_ = np.std(df_data.iloc[:, col_pred_start:], axis=1)\n Ypred_std = Ypred_std_.values\n print('Ypred_std shape: ', Ypred_std.shape)\n yerror = Ytrue - Ypred_mean\n print('yerror shape: ', yerror.shape)\n sigma = Ypred_std # std\n MSE = np.mean((Ytrue - Ypred_mean)**2)\n print('MSE: ', MSE)\n MSE_STD = np.std((Ytrue - Ypred_mean)**2)\n print('MSE_STD: ', MSE_STD)\n # p-value 'not entirely reliable, reasonable for datasets > 500'\n spearman_cc, pval = spearmanr(Ytrue, Ypred_mean)\n print('Spearman CC: %f, p-value: %e' % (spearman_cc, pval))\n\n return Ytrue, Ypred_mean, yerror, sigma, Ypred_std, pred_name\n\n\ndef compute_statistics_heteroscedastic(df_data,\n col_true=4,\n col_pred_start=6,\n col_std_pred_start=7,\n ):\n \"\"\" Extracts ground truth, mean prediction, error, standard\n deviation of prediction and predicted (learned) standard\n deviation from inference data frame. The latter includes\n all the individual inference realizations.\n\n Parameters\n ----------\n df_data : pandas data frame\n Data frame generated by current heteroscedastic inference\n experiments. Indices are hard coded to agree with\n current version. (The inference file usually\n has the name: <model>.predicted_INFER_HET.tsv).\n col_true : integer\n Index of the column in the data frame where the true\n value is stored (Default: 4, index in current HET format).\n col_pred_start : integer\n Index of the column in the data frame where the first predicted\n value is stored. All the predicted values during inference\n are stored and are interspaced with standard deviation\n predictions (Default: 6 index, step 2, in current HET format).\n col_std_pred_start : integer\n Index of the column in the data frame where the first predicted\n standard deviation value is stored. All the predicted values\n during inference are stored and are interspaced with predictions\n (Default: 7 index, step 2, in current HET format).\n\n Return\n ----------\n Ytrue : numpy array\n Array with true (observed) values\n Ypred : numpy array\n Array with predicted values.\n yerror : numpy array\n Array with errors computed (observed - predicted).\n sigma : numpy array\n Array with standard deviations learned with deep learning\n model. For homoscedastic inference this corresponds to the\n std value computed from prediction (and is equal to the\n following returned variable).\n Ypred_std : numpy array\n Array with standard deviations computed from regular\n (homoscedastic) inference.\n pred_name : string\n Name of data column or quantity predicted (as extracted\n from the data frame using the col_true index).\n \"\"\"\n\n Ytrue = df_data.iloc[:, col_true].values\n print('Ytrue shape: ', Ytrue.shape)\n pred_name = df_data.columns[col_true]\n Ypred_mean_ = np.mean(df_data.iloc[:, col_pred_start::2], axis=1)\n Ypred_mean = Ypred_mean_.values\n print('Ypred shape: ', Ypred_mean.shape)\n Ypred_std_ = np.std(df_data.iloc[:, col_pred_start::2], axis=1)\n Ypred_std = Ypred_std_.values\n print('Ypred_std shape: ', Ypred_std.shape)\n yerror = Ytrue - Ypred_mean\n print('yerror shape: ', yerror.shape)\n s_ = df_data.iloc[:, col_std_pred_start::2]\n s_mean = np.mean(s_, axis=1)\n var = np.exp(s_mean.values) # variance\n sigma = np.sqrt(var) # std\n print('sigma shape: ', sigma.shape)\n MSE = np.mean((Ytrue - Ypred_mean)**2)\n print('MSE: ', MSE)\n MSE_STD = np.std((Ytrue - Ypred_mean)**2)\n print('MSE_STD: ', MSE_STD)\n # p-value 'not entirely reliable, reasonable for datasets > 500'\n spearman_cc, pval = spearmanr(Ytrue, Ypred_mean)\n print('Spearman CC: %f, p-value: %e' % (spearman_cc, pval))\n\n return Ytrue, Ypred_mean, yerror, sigma, Ypred_std, pred_name\n\n\ndef compute_statistics_quantile(df_data,\n sigma_divisor=2.56,\n col_true=4,\n col_pred_start=6\n ):\n \"\"\" Extracts ground truth, 50th percentile mean prediction,\n low percentile and high percentile mean prediction\n (usually 10th percentile and 90th percentile respectively),\n error (using 50th percentile), standard deviation of\n prediction (using 50th percentile) and predicted (learned)\n standard deviation from interdecile range in inference data frame.\n The latter includes all the individual inference realizations.\n\n Parameters\n ----------\n df_data : pandas data frame\n Data frame generated by current quantile inference\n experiments. Indices are hard coded to agree with\n current version. (The inference file usually\n has the name: <model>.predicted_INFER_QTL.tsv).\n sigma_divisor : float\n Divisor to convert from the intercedile range to the corresponding\n standard deviation for a Gaussian distribution.\n (Default: 2.56, consistent with an interdecile range computed from\n the difference between the 90th and 10th percentiles).\n col_true : integer\n Index of the column in the data frame where the true\n value is stored (Default: 4, index in current QTL format).\n col_pred_start : integer\n Index of the column in the data frame where the first predicted\n value is stored. All the predicted values during inference\n are stored and are interspaced with other percentile\n predictions (Default: 6 index, step 3, in current QTL format).\n\n Return\n ----------\n Ytrue : numpy array\n Array with true (observed) values\n Ypred : numpy array\n Array with predicted values (based on the 50th percentile).\n yerror : numpy array\n Array with errors computed (observed - predicted).\n sigma : numpy array\n Array with standard deviations learned with deep learning\n model. This corresponds to the interdecile range divided\n by the sigma divisor.\n Ypred_std : numpy array\n Array with standard deviations computed from regular\n (homoscedastic) inference.\n pred_name : string\n Name of data column or quantity predicted (as extracted\n from the data frame using the col_true index).\n Ypred_Lp_mean : numpy array\n Array with predicted values of the lower percentile\n (usually the 10th percentile).\n Ypred_Hp_mean : numpy array\n Array with predicted values of the higher percentile\n (usually the 90th percentile).\n \"\"\"\n\n Ytrue = df_data.iloc[:, col_true].values\n print('Ytrue shape: ', Ytrue.shape)\n pred_name = df_data.columns[col_true]\n Ypred_50q_mean = np.mean(df_data.iloc[:, col_pred_start::3], axis=1)\n Ypred_mean = Ypred_50q_mean.values\n print('Ypred shape: ', Ypred_mean.shape)\n Ypred_Lp_mean_ = np.mean(df_data.iloc[:, col_pred_start + 1::3], axis=1)\n Ypred_Hp_mean_ = np.mean(df_data.iloc[:, col_pred_start + 2::3], axis=1)\n Ypred_Lp_mean = Ypred_Lp_mean_.values\n Ypred_Hp_mean = Ypred_Hp_mean_.values\n interdecile_range = Ypred_Hp_mean - Ypred_Lp_mean\n sigma = interdecile_range / sigma_divisor\n print('sigma shape: ', sigma.shape)\n yerror = Ytrue - Ypred_mean\n print('yerror shape: ', yerror.shape)\n Ypred_std_ = np.std(df_data.iloc[:, col_pred_start::3], axis=1)\n Ypred_std = Ypred_std_.values\n print('Ypred_std shape: ', Ypred_std.shape)\n MSE = np.mean((Ytrue - Ypred_mean)**2)\n print('MSE: ', MSE)\n MSE_STD = np.std((Ytrue - Ypred_mean)**2)\n print('MSE_STD: ', MSE_STD)\n # p-value 'not entirely reliable, reasonable for datasets > 500'\n spearman_cc, pval = spearmanr(Ytrue, Ypred_mean)\n print('Spearman CC: %f, p-value: %e' % (spearman_cc, pval))\n\n return Ytrue, Ypred_mean, yerror, sigma, Ypred_std, pred_name, Ypred_Lp_mean, Ypred_Hp_mean\n\n\ndef split_data_for_empirical_calibration(Ytrue, Ypred, sigma, cal_split=0.8):\n \"\"\"\n Extracts a portion of the arrays provided for the computation\n of the calibration and reserves the remainder portion\n for testing.\n\n Parameters\n ----------\n Ytrue : numpy array\n Array with true (observed) values\n Ypred : numpy array\n Array with predicted values.\n sigma : numpy array\n Array with standard deviations learned with deep learning\n model (or std value computed from prediction if homoscedastic\n inference).\n cal_split : float\n Split of data to use for estimating the calibration relationship.\n It is assumed that it will be a value in (0, 1).\n (Default: use 80% of predictions to generate empirical\n calibration).\n\n Return\n ----------\n index_perm_total : numpy array\n Random permutation of the array indices. The first 'num_cal'\n of the indices correspond to the samples that are used for\n calibration, while the remainder are the samples reserved\n for calibration testing.\n pSigma_cal : numpy array\n Part of the input sigma array to use for calibration.\n pSigma_test : numpy array\n Part of the input sigma array to reserve for testing.\n pPred_cal : numpy array\n Part of the input Ypred array to use for calibration.\n pPred_test : numpy array\n Part of the input Ypred array to reserve for testing.\n true_cal : numpy array\n Part of the input Ytrue array to use for calibration.\n true_test : numpy array\n Part of the input Ytrue array to reserve for testing.\n \"\"\"\n\n # shuffle data for calibration\n num_pred_total = sigma.shape[0]\n num_cal = np.int(num_pred_total * cal_split)\n index_perm_total = np.random.permutation(range(num_pred_total))\n\n # Permute data\n pSigma_perm_all = sigma[index_perm_total]\n pPred_perm_all = Ypred[index_perm_total]\n true_perm_all = Ytrue[index_perm_total]\n\n # Split in calibration and testing\n pSigma_cal = pSigma_perm_all[:num_cal]\n pSigma_test = pSigma_perm_all[num_cal:]\n pPred_cal = pPred_perm_all[:num_cal]\n pPred_test = pPred_perm_all[num_cal:]\n true_cal = true_perm_all[:num_cal]\n true_test = true_perm_all[num_cal:]\n\n print('Size of calibration set: ', true_cal.shape)\n print('Size of test set: ', true_test.shape)\n\n return index_perm_total, pSigma_cal, pSigma_test, pPred_cal, pPred_test, true_cal, true_test\n\n\ndef compute_empirical_calibration(pSigma_cal, pPred_cal, true_cal, bins, coverage_percentile):\n \"\"\" Use the arrays provided to estimate an empirical mapping\n between standard deviation and absolute value of error,\n both of which have been observed during inference. Since\n most of the times the raw statistics per bin are very noisy,\n a smoothing step (based on scipy's savgol filter) is performed.\n\n Parameters\n ----------\n pSigma_cal : numpy array\n Part of the standard deviations array to use for calibration.\n pPred_cal : numpy array\n Part of the predictions array to use for calibration.\n true_cal : numpy array\n Part of the true (observed) values array to use for calibration.\n bins : int\n Number of bins to split the range of standard deviations\n included in pSigma_cal array.\n coverage_percentile : float\n Value to use for estimating coverage when evaluating the percentiles\n of the observed absolute value of errors.\n\n Return\n ----------\n mean_sigma : numpy array\n Array with the mean standard deviations computed per bin.\n min_sigma : numpy array\n Array with the minimum standard deviations computed per bin.\n max_sigma : numpy array\n Array with the maximum standard deviations computed per bin.\n error_thresholds : numpy array\n Thresholds of the errors computed to attain a certain\n error coverage per bin.\n err_err : numpy array\n Error bars in errors (one standard deviation for a binomial\n distribution estimated by bin vs. the other bins) for the\n calibration error.\n error_thresholds_smooth : numpy array\n Thresholds of the errors computed to attain a certain\n error coverage per bin after a smoothed operation is applied\n to the frequently noisy bin-based estimations.\n sigma_start_index : non-negative integer\n Index in the mean_sigma array that defines the start of\n the valid empirical calibration interval (i.e. index to\n the smallest std for which a meaningful error mapping\n is obtained).\n sigma_end_index : non-negative integer\n Index in the mean_sigma array that defines the end of\n the valid empirical calibration interval (i.e. index to\n the largest std for which a meaningful error mapping\n is obtained).\n s_interpolate : scipy.interpolate python object\n A python object from scipy.interpolate that computes a\n univariate spline (InterpolatedUnivariateSpline) constructed\n to express the mapping from standard deviation to error. This\n spline is generated during the computational empirical\n calibration procedure.\n \"\"\"\n\n index_sigma_cal = np.argsort(pSigma_cal)\n pSigma_cal_ordered_ = pSigma_cal[index_sigma_cal]\n Er_vect_cal_ = np.abs(true_cal - pPred_cal)\n Er_vect_cal_orderedSigma_ = Er_vect_cal_[index_sigma_cal]\n\n minL_sigma = np.min(pSigma_cal_ordered_)\n maxL_sigma = np.max(pSigma_cal_ordered_)\n print('Complete Sigma range --> Min: %f, Max: %f' % (minL_sigma, maxL_sigma))\n\n # Bin statistics for error and sigma\n mean_sigma, min_sigma, max_sigma, error_thresholds, err_err = bining_for_calibration(pSigma_cal_ordered_,\n minL_sigma,\n maxL_sigma,\n Er_vect_cal_orderedSigma_,\n bins,\n coverage_percentile)\n\n # smooth error function\n # scipy.signal.savgol_filter(x, window_length, polyorder,\n # deriv=0, delta=1.0, axis=-1, mode='interp', cval=0.0)\n # error_thresholds_smooth = signal.savgol_filter(error_thresholds, 5, 1)\n error_thresholds_smooth = signal.savgol_filter(error_thresholds, 5, 1, mode='nearest')\n\n # Build Interpolant over smooth plot (this will become the calibration function)\n s_interpolate = InterpolatedUnivariateSpline(mean_sigma, error_thresholds_smooth)\n # Determine limits of calibration (i.e. monotonicity range)\n sigma_start_index, sigma_end_index = computation_of_valid_calibration_interval(error_thresholds, error_thresholds_smooth, err_err)\n\n print('Range of valid sigma: %.6f --> %.6f' % (mean_sigma[sigma_start_index], mean_sigma[sigma_end_index]))\n\n return mean_sigma, min_sigma, max_sigma, error_thresholds, err_err, error_thresholds_smooth, sigma_start_index, sigma_end_index, s_interpolate\n\n\ndef bining_for_calibration(pSigma_cal_ordered_, minL_sigma,\n maxL_sigma, Er_vect_cal_orderedSigma_,\n bins, coverage_percentile):\n \"\"\" Bin the values of the standard deviations observed during\n inference and estimate a specified coverage percentile\n in the absolute error (observed during inference as well).\n Bins that have less than 50 samples are merged until they\n surpass this threshold.\n\n Parameters\n ----------\n pSigma_cal_ordered_ : numpy array\n Array of standard deviations ordered in ascending way.\n minL_sigma : float\n Minimum value of standard deviations included in\n pSigma_cal_ordered_ array.\n maxL_sigma : numpy array\n Maximum value of standard deviations included in\n pSigma_cal_ordered_ array.\n Er_vect_cal_orderedSigma_ : numpy array\n Array ob absolute value of errors corresponding with\n the array of ordered standard deviations.\n bins : int\n Number of bins to split the range of standard deviations\n included in pSigma_cal_ordered_ array.\n coverage_percentile : float\n Value to use for estimating coverage when evaluating the percentiles\n of the observed absolute value of errors.\n\n Return\n ----------\n mean_sigma : numpy array\n Array with the mean standard deviations computed per bin.\n min_sigma : numpy array\n Array with the minimum standard deviations computed per bin.\n max_sigma : numpy array\n Array with the maximum standard deviations computed per bin.\n error_thresholds : numpy array\n Thresholds of the errors computed to attain a certain\n error coverage per bin.\n err_err : numpy array\n Error bars in errors (one standard deviation for a binomial\n distribution estimated by bin vs. the other bins) for the\n calibration error.\n \"\"\"\n\n # thresholds = np.logspace(np.log10(minL_sigma), np.log10(maxL_sigma), num=bins)\n thresholds = np.linspace(minL_sigma, maxL_sigma, num=bins)\n classes = np.digitize(pSigma_cal_ordered_, thresholds)\n Nbin = np.zeros(bins + 1)\n for i in range(bins + 1):\n indices = (classes == i)\n Nbin[i] = indices.sum()\n\n # Repair bins\n new_thresholds_l = []\n new_nbins_l = []\n sumN = 0\n for i in range(Nbin.shape[0]):\n sumN += Nbin[i]\n if sumN > 50:\n if i > (thresholds.shape[0] - 1):\n new_thresholds_l.append(thresholds[-1])\n else:\n new_thresholds_l.append(thresholds[i])\n new_nbins_l.append(sumN)\n sumN = 0\n new_thresholds = np.array(new_thresholds_l)\n new_nbins = np.array(new_nbins_l)\n new_thresholds[-1] = thresholds[-1]\n new_nbins[-1] += sumN\n\n #\n classes = np.digitize(pSigma_cal_ordered_, new_thresholds[:-1])\n error_thresholds = -1. * np.ones(new_nbins.shape[0])\n mean_sigma = -1. * np.ones(new_nbins.shape[0])\n min_sigma = -1. * np.ones(new_nbins.shape[0])\n max_sigma = -1. * np.ones(new_nbins.shape[0])\n err_err = -1. * np.ones(new_nbins.shape[0])\n Ncal = pSigma_cal_ordered_.shape[0]\n for i in range(error_thresholds.shape[0]):\n indices = (classes == i)\n n_aux = indices.sum()\n assert n_aux == new_nbins[i]\n print('Points in bin %d: %d' % (i, n_aux))\n mean_sigma[i] = np.mean(pSigma_cal_ordered_[indices])\n min_sigma[i] = np.min(pSigma_cal_ordered_[indices])\n max_sigma[i] = np.max(pSigma_cal_ordered_[indices])\n error_thresholds[i] = np.percentile(Er_vect_cal_orderedSigma_[indices], coverage_percentile)\n err_err[i] = np.sqrt(new_nbins[i] * (Ncal - new_nbins[i])) / Ncal * error_thresholds[i]\n\n return mean_sigma, min_sigma, max_sigma, error_thresholds, err_err\n\n\ndef computation_of_valid_calibration_interval(error_thresholds, error_thresholds_smooth, err_err):\n \"\"\" Function that estimates the empirical range in which a\n monotonic relation is observed between standard deviation\n and coverage of absolute value of error. Since the\n statistics computed per bin are relatively noisy, the\n application of a greedy criterion (e.g. guarantee a\n monotonically increasing relationship) does not yield\n good results. Therefore, a softer version is constructed\n based on the satisfaction of certain criteria depending\n on: the values of the error coverage computed per bin,\n a smoothed version of them and the associated error\n estimated (based on one standard deviation for a binomial\n distribution estimated by bin vs. the other bins).\n A minimal validation requiring the end idex to be\n largest than the starting index is performed before\n the function return.\n\n Current criteria:\n - the smoothed errors are inside the error bars AND\n they are almost increasing (a small tolerance is\n allowed, so a small wobbliness in the smoother\n values is permitted).\n OR\n - both the raw values for the bins (with a small tolerance)\n are increasing, AND the smoothed value is greater than the\n raw value.\n OR\n - the current smoothed value is greater than the previous AND\n the smoothed values for the next been are inside the error\n bars.\n\n Parameters\n ----------\n error_thresholds : numpy array\n Thresholds of the errors computed to attain a certain\n error coverage per bin.\n error_thresholds_smooth : numpy array\n Thresholds of the errors computed to attain a certain\n error coverage per bin after a smoothed operation is applied\n to the frequently noisy bin-based estimations.\n err_err : numpy array\n Error bars in errors (one standard deviation for a binomial\n distribution estimated by bin vs. the other bins) for the\n calibration error.\n\n Return\n ----------\n sigma_start_index : non-negative integer\n Index estimated in the mean_sigma array corresponding to\n the value that defines the start of the valid empirical\n calibration interval (i.e. index to the smallest std for\n which a meaningful error mapping is obtained, according\n to the criteria explained before).\n sigma_end_index : non-negative integer\n Index estimated in the mean_sigma array corresponding to\n the value that defines the end of the valid empirical\n calibration interval (i.e. index to the largest std for\n which a meaningful error mapping is obtained, according\n to the criteria explained before).\n \"\"\"\n\n # Computation of the calibration interval\n limitH = error_thresholds + err_err\n limitL = error_thresholds - err_err\n\n # search for starting point\n for i in range(err_err.shape[0]):\n if ((error_thresholds_smooth[i] >= limitL[i]) and\n (error_thresholds_smooth[i] <= limitH[i])): # Ask if the current is in the interval\n sigma_start_index = i\n break\n sigma_end_index = sigma_start_index - 1\n\n restart = max(1, sigma_start_index)\n for i in range(restart, err_err.shape[0] - 1):\n if (((error_thresholds_smooth[i] >= limitL[i]) and\n (error_thresholds_smooth[i] <= limitH[i]) and\n ((error_thresholds_smooth[i] * 1.005 > error_thresholds_smooth[i - 1]) or\n ((error_thresholds[i] * 1.01 > error_thresholds[i - 1]) and\n (error_thresholds_smooth[i] > error_thresholds[i])))) # Ask if the current is in the interval with slightly increasing trend\n or # Ask if the current is greater than the previous and the next is in the interval\n ((error_thresholds_smooth[i] > error_thresholds_smooth[i - 1]) and\n ((error_thresholds_smooth[i + 1] >= limitL[i + 1]) and\n (error_thresholds_smooth[i + 1] <= limitH[i + 1])))):\n\n sigma_end_index = i\n else: # Finalize search for monotonic range\n if (sigma_end_index - sigma_start_index) > 4:\n break\n else: # Reset indices\n sigma_start_index = i + 1\n sigma_end_index = i\n\n print('Range of valid sigma indices (inclusive): %d --> %d' % (sigma_start_index, sigma_end_index))\n\n assert (sigma_end_index > sigma_start_index)\n\n return sigma_start_index, sigma_end_index\n\n\ndef applying_calibration(pSigma_test, pPred_test, true_test, s_interpolate, minL_sigma_auto, maxL_sigma_auto):\n \"\"\" Use the empirical mapping between standard deviation and\n absolute value of error estimated during calibration (i.e.\n apply the univariate spline computed) to estimate the error\n for the part of the standard deviation array that was reserved\n for testing the empirical calibration. The resulting error array\n (yp_test) should overestimate the true observed error (eabs_red).\n All the computations are restricted to the valid calibration\n interval: [minL_sigma_auto, maxL_sigma_auto].\n\n Parameters\n ----------\n pSigma_test : numpy array\n Part of the standard deviations array to use for calibration testing.\n pPred_test : numpy array\n Part of the predictions array to use for calibration testing.\n true_test : numpy array\n Part of the true (observed) values array to use for calibration testing.\n s_interpolate : scipy.interpolate python object\n A python object from scipy.interpolate that computes a\n univariate spline (InterpolatedUnivariateSpline) expressing\n the mapping from standard deviation to error. This\n spline is generated during the computational empirical\n calibration procedure.\n minL_sigma_auto : float\n Starting value of the valid empirical calibration interval\n (i.e. smallest std for which a meaningful error mapping\n is obtained).\n maxL_sigma_auto : float\n Ending value of the valid empirical calibration interval\n (i.e. largest std for which a meaningful error mapping\n is obtained).\n\n Return\n ----------\n index_sigma_range_test : numpy array\n Indices of the pSigma_test array that are included in the\n valid calibration interval, given by:\n [minL_sigma_auto, maxL_sigma_auto].\n xp_test : numpy array\n Array with the mean standard deviations in the calibration\n testing array.\n yp_test : numpy array\n Mapping of the given standard deviation to error computed\n from the interpolation spline constructed by empirical\n calibration.\n eabs_red : numpy array\n Array with the observed absolute errors in the part of the testing\n array for which the observed standard deviations are in the\n valid interval of calibration.\n \"\"\"\n\n # Filter to appropriate range\n index_sigma_range_test = (pSigma_test >= minL_sigma_auto) & (pSigma_test < maxL_sigma_auto)\n xp_test = pSigma_test[index_sigma_range_test]\n yp_test = s_interpolate(xp_test)\n Er_vect_ = true_test - pPred_test\n eabs_ = np.abs(Er_vect_)\n eabs_red = eabs_[index_sigma_range_test]\n\n return index_sigma_range_test, xp_test, yp_test, eabs_red\n\n\ndef overprediction_check(yp_test, eabs_red):\n \"\"\" Compute the percentage of overestimated absolute error\n predictions for the arrays reserved for calibration testing\n and whose corresponding standard deviations are included\n in the valid calibration interval.\n\n Parameters\n ----------\n yp_test : numpy array\n Mapping of the standard deviation to error computed\n from the interpolation spline constructed by empirical\n calibration.\n eabs_red : numpy array\n Array with the observed absolute errors in the part of the testing\n array for which the observed standard deviations are in the\n valid interval of calibration.\n \"\"\"\n\n over_pred_error_index = (yp_test >= eabs_red)\n percentage_over_predicted = (over_pred_error_index.sum() / yp_test.shape[0])\n print(\"percentage over predicted: \", percentage_over_predicted)\n",
"# This material was prepared as an account of work sponsored by an agency of the\n# United States Government. Neither the United States Government nor the United\n# States Department of Energy, nor Battelle, nor any of their employees, nor any\n# jurisdiction or organization that has cooperated in the development of these\n# materials, makes any warranty, express or implied, or assumes any legal\n# liability or responsibility for the accuracy, completeness, or usefulness or\n# any information, apparatus, product, software, or process disclosed, or\n# represents that its use would not infringe privately owned rights. Reference\n# herein to any specific commercial product, process, or service by trade name,\n# trademark, manufacturer, or otherwise does not necessarily constitute or imply\n# its endorsement, recommendation, or favoring by the United States Government\n# or any agency thereof, or Battelle Memorial Institute. The views and opinions\n# of authors expressed herein do not necessarily state or reflect those of the\n# United States Government or any agency thereof.\n# PACIFIC NORTHWEST NATIONAL LABORATORY\n# operated by\n# BATTELLE\n# for the\n# UNITED STATES DEPARTMENT OF ENERGY\n# under Contract DE-AC05-76RL01830\nimport time\nimport os\nimport math\nimport json\nimport csv\nimport random\nimport tensorflow as tf\nimport sys\nimport gym\nimport pickle\nimport exarl as erl\nfrom exarl.base.comm_base import ExaComm\nfrom tensorflow import keras\nfrom collections import deque\nfrom datetime import datetime\nimport numpy as np\nfrom exarl.agents.agent_vault._prioritized_replay import PrioritizedReplayBuffer\nimport exarl.utils.candleDriver as cd\nfrom exarl.utils import log\nfrom exarl.utils.introspect import introspectTrace\nfrom tensorflow.compat.v1.keras.backend import set_session\n\nif ExaComm.num_learners > 1:\n import horovod.tensorflow as hvd\n multiLearner = True\nelse:\n multiLearner = False\n\nlogger = log.setup_logger(__name__, cd.lookup_params('log_level', [3, 3]))\n\nclass LossHistory(keras.callbacks.Callback):\n \"\"\"Loss history for training\n \"\"\"\n\n def on_train_begin(self, logs={}):\n self.loss = []\n\n def on_batch_end(self, batch, logs={}):\n self.loss.append(logs.get('loss'))\n\n# The Multi-Learner Discrete Double Deep Q-Network\nclass DQN(erl.ExaAgent):\n \"\"\"Multi-Learner Discrete Double Deep Q-Network with Prioritized Experience Replay\n \"\"\"\n\n def __init__(self, env, is_learner):\n \"\"\"DQN Constructor\n\n Args:\n env (OpenAI Gym environment object): env object indicates the RL environment\n is_learner (bool): Used to indicate if the agent is a learner or an actor\n \"\"\"\n\n # Initial values\n self.is_learner = is_learner\n self.model = None\n self.target_model = None\n self.target_weights = None\n self.device = None\n self.mirrored_strategy = None\n\n self.env = env\n self.agent_comm = ExaComm.agent_comm\n\n # MPI\n self.rank = self.agent_comm.rank\n self.size = self.agent_comm.size\n\n # Timers\n self.training_time = 0\n self.ntraining_time = 0\n self.dataprep_time = 0\n self.ndataprep_time = 0\n\n self.enable_xla = True if cd.run_params['xla'] == \"True\" else False\n if self.enable_xla:\n # Optimization using XLA (1.1x speedup)\n tf.config.optimizer.set_jit(True)\n\n # Optimization using mixed precision (1.5x speedup)\n # Layers use float16 computations and float32 variables\n from tensorflow.keras.mixed_precision import experimental as mixed_precision\n policy = mixed_precision.Policy('mixed_float16')\n mixed_precision.set_policy(policy)\n\n # dqn intrinsic variables\n self.results_dir = cd.run_params['output_dir']\n self.gamma = cd.run_params['gamma']\n self.epsilon = cd.run_params['epsilon']\n self.epsilon_min = cd.run_params['epsilon_min']\n self.epsilon_decay = cd.run_params['epsilon_decay']\n self.learning_rate = cd.run_params['learning_rate']\n self.batch_size = cd.run_params['batch_size']\n self.tau = cd.run_params['tau']\n self.model_type = cd.run_params['model_type']\n\n if self.model_type == 'MLP':\n # for mlp\n self.dense = cd.run_params['dense']\n\n if self.model_type == 'LSTM':\n # for lstm\n self.lstm_layers = cd.run_params['lstm_layers']\n self.gauss_noise = cd.run_params['gauss_noise']\n self.regularizer = cd.run_params['regularizer']\n self.clipnorm = cd.run_params['clipnorm']\n self.clipvalue = cd.run_params['clipvalue']\n\n # for both\n self.activation = cd.run_params['activation']\n self.out_activation = cd.run_params['out_activation']\n self.optimizer = cd.run_params['optimizer']\n self.loss = cd.run_params['loss']\n self.n_actions = cd.run_params['nactions']\n self.priority_scale = cd.run_params['priority_scale']\n\n # Check if the action space is discrete\n self.is_discrete = (type(env.action_space) == gym.spaces.discrete.Discrete)\n # If continuous, discretize the action space\n # TODO: Incorpoorate Ai's class\n if not self.is_discrete:\n env.action_space.n = self.n_actions\n self.actions = np.linspace(env.action_space.low, env.action_space.high, self.n_actions)\n\n # Data types of action and observation space\n self.dtype_action = np.array(self.env.action_space.sample()).dtype\n self.dtype_observation = self.env.observation_space.sample().dtype\n\n # Setup GPU cfg\n if ExaComm.is_learner():\n logger.info(\"Setting GPU rank\", self.rank)\n config = tf.compat.v1.ConfigProto(device_count={'GPU': 1, 'CPU': 1})\n else:\n logger.info(\"Setting no GPU rank\", self.rank)\n config = tf.compat.v1.ConfigProto(device_count={'GPU': 0, 'CPU': 1})\n # Get which device to run on\n self.device = self._get_device()\n\n config.gpu_options.allow_growth = True\n sess = tf.compat.v1.Session(config=config)\n tf.compat.v1.keras.backend.set_session(sess)\n\n # Build network model\n if self.is_learner:\n with tf.device(self.device):\n self.model = self._build_model()\n self.model.compile(loss=self.loss, optimizer=self.optimizer)\n self.model.summary()\n # self.mirrored_strategy = tf.distribute.MirroredStrategy()\n # logger.info(\"Using learner strategy: {}\".format(self.mirrored_strategy))\n # with self.mirrored_strategy.scope():\n # self.model = self._build_model()\n # self.model._name = \"learner\"\n # self.model.compile(loss=self.loss, optimizer=self.optimizer)\n # logger.info(\"Active model: \\n\".format(self.model.summary()))\n else:\n self.model = None\n with tf.device('/CPU:0'):\n self.target_model = self._build_model()\n self.target_model._name = \"target_model\"\n self.target_model.compile(loss=self.loss, optimizer=self.optimizer)\n # self.target_model.summary()\n self.target_weights = self.target_model.get_weights()\n\n if multiLearner and ExaComm.is_learner():\n hvd.init(comm=ExaComm.learner_comm.raw())\n self.first_batch = 1\n # TODO: Update candle driver to include different losses and optimizers\n # Default reduction is tf.keras.losses.Reduction.AUTO which errors out with distributed training\n # self.loss_fn = tf.keras.losses.MeanSquaredError(reduction=tf.keras.losses.Reduction.NONE)\n self.loss_fn = cd.candle.build_loss(self.loss, cd.kerasDefaults, reduction='none')\n # self.opt = tf.keras.optimizers.Adam(self.learning_rate * hvd.size())\n self.opt = cd.candle.build_optimizer(self.optimizer, self.learning_rate * hvd.size(), cd.kerasDefaults)\n\n self.maxlen = cd.run_params['mem_length']\n self.replay_buffer = PrioritizedReplayBuffer(maxlen=self.maxlen)\n\n def _get_device(self):\n \"\"\"Get device type (CPU/GPU)\n\n Returns:\n string: device type\n \"\"\"\n cpus = tf.config.experimental.list_physical_devices('CPU')\n gpus = tf.config.experimental.list_physical_devices('GPU')\n ngpus = len(gpus)\n logger.info('Number of available GPUs: {}'.format(ngpus))\n if ngpus > 0:\n gpu_id = self.rank % ngpus\n return '/GPU:{}'.format(gpu_id)\n else:\n return '/CPU:0'\n\n def _build_model(self):\n \"\"\"Build NN model based on parameters provided in the config file\n\n Returns:\n [type]: [description]\n \"\"\"\n if self.model_type == 'MLP':\n from exarl.agents.agent_vault._build_mlp import build_model\n return build_model(self)\n elif self.model_type == 'LSTM':\n from exarl.agents.agent_vault._build_lstm import build_model\n return build_model(self)\n else:\n sys.exit(\"Oops! That was not a valid model type. Try again...\")\n\n # TODO: Check if this is used in any workflow, if not delete\n def set_learner(self):\n logger.debug(\n \"Agent[{}] - Creating active model for the learner\".format(self.rank)\n )\n\n def remember(self, state, action, reward, next_state, done):\n \"\"\"Add experience to replay buffer\n\n Args:\n state (list or array): Current state of the system\n action (list or array): Action to take\n reward (list or array): Environment reward\n next_state (list or array): Next state of the system\n done (bool): Indicates episode completion\n \"\"\"\n lost_data = self.replay_buffer.add((state, action, reward, next_state, done))\n if lost_data and self.priority_scale:\n # logger.warning(\"Priority replay buffer size too small. Data loss negates replay effect!\")\n print(\"Priority replay buffer size too small. Data loss negates replay effect!\", flush=True)\n\n def get_action(self, state):\n \"\"\"Use epsilon-greedy approach to generate actions\n\n Args:\n state (list or array): Current state of the system\n\n Returns:\n (list or array): Action to take\n \"\"\"\n random.seed(datetime.now())\n random_data = os.urandom(4)\n np.random.seed(int.from_bytes(random_data, byteorder=\"big\"))\n rdm = np.random.rand()\n if rdm <= self.epsilon:\n self.epsilon_adj()\n action = random.randrange(self.env.action_space.n)\n return action, 0\n else:\n np_state = np.array(state).reshape(1, 1, len(state))\n with tf.device(self.device):\n act_values = self.target_model.predict(np_state)\n action = np.argmax(act_values[0])\n return action, 1\n\n @introspectTrace()\n def action(self, state):\n \"\"\"Discretizes 1D continuous actions to work with DQN\n\n Args:\n state (list or array): Current state of the system\n\n Returns:\n action (list or array): Action to take\n policy (int): random (0) or inference (1)\n \"\"\"\n action, policy = self.get_action(state)\n if not self.is_discrete:\n action = [self.actions[action]]\n return action, policy\n\n @introspectTrace()\n def calc_target_f(self, exp):\n \"\"\"Bellman equation calculations\n\n Args:\n exp (list of experience): contains state, action, reward, next state, done\n\n Returns:\n target Q value (array): [description]\n \"\"\"\n state, action, reward, next_state, done = exp\n np_state = np.array(state, dtype=self.dtype_observation).reshape(1, 1, len(state))\n np_next_state = np.array(next_state, dtype=self.dtype_observation).reshape(1, 1, len(next_state))\n expectedQ = 0\n if not done:\n with tf.device(self.device):\n expectedQ = self.gamma * np.amax(self.target_model.predict(np_next_state)[0])\n target = reward + expectedQ\n with tf.device(self.device):\n target_f = self.target_model.predict(np_state)\n # For handling continuous to discrete actions\n action_idx = action if self.is_discrete else np.where(self.actions == action)[1]\n target_f[0][action_idx] = target\n return target_f[0]\n\n def has_data(self):\n \"\"\"Indicates if the buffer has data of size batch_size or more\n\n Returns:\n bool: True if replay_buffer length >= self.batch_size\n \"\"\"\n return (self.replay_buffer.get_buffer_length() >= self.batch_size)\n\n @introspectTrace()\n def generate_data(self):\n \"\"\"Unpack and yield training data\n\n Yields:\n batch_states (numpy array): training input\n batch_target (numpy array): training labels\n With PER:\n indices (numpy array): data indices\n importance (numpy array): importance weights\n \"\"\"\n # Has data checks if the buffer is greater than batch size for training\n if not self.has_data():\n # Worker method to create samples for training\n batch_states = np.zeros((self.batch_size, 1, self.env.observation_space.shape[0]), dtype=self.dtype_observation)\n batch_target = np.zeros((self.batch_size, self.env.action_space.n), dtype=self.dtype_action)\n indices = -1 * np.ones(self.batch_size)\n importance = np.ones(self.batch_size)\n else:\n minibatch, importance, indices = self.replay_buffer.sample(self.batch_size, priority_scale=self.priority_scale)\n batch_target = list(map(self.calc_target_f, minibatch))\n batch_states = [np.array(exp[0], dtype=self.dtype_observation).reshape(1, 1, len(exp[0]))[0] for exp in minibatch]\n batch_states = np.reshape(batch_states, [len(minibatch), 1, len(minibatch[0][0])])\n batch_target = np.reshape(batch_target, [len(minibatch), self.env.action_space.n])\n\n if self.priority_scale > 0:\n yield batch_states, batch_target, indices, importance\n else:\n yield batch_states, batch_target\n\n @introspectTrace()\n def train(self, batch):\n \"\"\"Train the NN\n\n Args:\n batch (list): sampled batch of experiences\n\n Returns:\n if PER:\n indices (numpy array): data indices\n loss: training loss\n else:\n None\n \"\"\"\n ret = None\n if self.is_learner:\n start_time = time.time()\n with tf.device(self.device):\n if self.priority_scale > 0:\n if multiLearner:\n loss = self.training_step(batch)\n else:\n loss = LossHistory()\n sample_weight = batch[3] ** (1 - self.epsilon)\n self.model.fit(batch[0], batch[1], epochs=1, batch_size=1, verbose=0, callbacks=loss, sample_weight=sample_weight)\n loss = loss.loss\n ret = batch[2], loss\n else:\n if multiLearner:\n loss = self.training_step(batch)\n else:\n self.model.fit(batch[0], batch[1], epochs=1, verbose=0)\n end_time = time.time()\n self.training_time += (end_time - start_time)\n self.ntraining_time += 1\n logger.info('Agent[{}]- Training: {} '.format(self.rank, (end_time - start_time)))\n start_time_episode = time.time()\n logger.info('Agent[%s] - Target update time: %s ' % (str(self.rank), str(time.time() - start_time_episode)))\n else:\n logger.warning('Training will not be done because this instance is not set to learn.')\n return ret\n\n @tf.function\n def training_step(self, batch):\n \"\"\" Training step for multi-learner using Horovod\n\n Args:\n batch (list): sampled batch of experiences\n\n Returns:\n loss_value: loss value per training step for multi-learner\n \"\"\"\n with tf.GradientTape() as tape:\n probs = self.model(batch[0], training=True)\n if len(batch) > 2:\n sample_weight = batch[3] * (1 - self.epsilon)\n else:\n sample_weight = np.ones(len(batch[0]))\n loss_value = self.loss_fn(batch[1], probs, sample_weight=sample_weight)\n\n # Horovod distributed gradient tape\n tape = hvd.DistributedGradientTape(tape)\n grads = tape.gradient(loss_value, self.model.trainable_variables)\n self.opt.apply_gradients(zip(grads, self.model.trainable_variables))\n\n if self.first_batch:\n hvd.broadcast_variables(self.model.variables, root_rank=0)\n hvd.broadcast_variables(self.opt.variables(), root_rank=0)\n self.first_batch = 0\n return loss_value\n\n def set_priorities(self, indices, loss):\n \"\"\" Set priorities for training data\n\n Args:\n indices (array): data indices\n loss (array): Losses\n \"\"\"\n self.replay_buffer.set_priorities(indices, loss)\n\n def get_weights(self):\n \"\"\"Get weights from target model\n\n Returns:\n weights (list): target model weights\n \"\"\"\n logger.debug(\"Agent[%s] - get target weight.\" % str(self.rank))\n return self.target_model.get_weights()\n\n def set_weights(self, weights):\n \"\"\"Set model weights\n\n Args:\n weights (list): model weights\n \"\"\"\n logger.info(\"Agent[%s] - set target weight.\" % str(self.rank))\n logger.debug(\"Agent[%s] - set target weight: %s\" % (str(self.rank), weights))\n with tf.device(self.device):\n self.target_model.set_weights(weights)\n\n @introspectTrace()\n def target_train(self):\n \"\"\"Update target model\n \"\"\"\n if self.is_learner:\n logger.info(\"Agent[%s] - update target weights.\" % str(self.rank))\n with tf.device(self.device):\n model_weights = self.model.get_weights()\n target_weights = self.target_model.get_weights()\n for i in range(len(target_weights)):\n target_weights[i] = (\n self.tau * model_weights[i] + (1 - self.tau) * target_weights[i]\n )\n self.set_weights(target_weights)\n else:\n logger.warning(\n \"Weights will not be updated because this instance is not set to learn.\"\n )\n\n def epsilon_adj(self):\n \"\"\"Update epsilon value\n \"\"\"\n if self.epsilon > self.epsilon_min:\n self.epsilon *= self.epsilon_decay\n\n def load(self, filename):\n \"\"\"Load model weights from pickle file\n\n Args:\n filename (string): full path of model file\n \"\"\"\n layers = self.target_model.layers\n with open(filename, 'rb') as f:\n pickle_list = pickle.load(f)\n\n for layerId in range(len(layers)):\n # assert(layers[layerId].name == pickle_list[layerId][0])\n layers[layerId].set_weights(pickle_list[layerId][1])\n\n def save(self, filename):\n \"\"\"Save model weights to pickle file\n\n Args:\n filename (string): full path of model file\n \"\"\"\n layers = self.target_model.layers\n pickle_list = []\n for layerId in range(len(layers)):\n weigths = layers[layerId].get_weights()\n pickle_list.append([layers[layerId].name, weigths])\n\n with open(filename, 'wb') as f:\n pickle.dump(pickle_list, f, -1)\n\n def update(self):\n logger.info(\"Implement update method in dqn.py\")\n\n def monitor(self):\n logger.info(\"Implement monitor method in dqn.py\")\n"
] | [
[
"numpy.sqrt",
"numpy.linspace",
"numpy.round",
"numpy.int",
"numpy.max",
"numpy.mean",
"scipy.stats.spearmanr",
"numpy.digitize",
"numpy.exp",
"scipy.signal.savgol_filter",
"scipy.interpolate.InterpolatedUnivariateSpline",
"numpy.arange",
"numpy.std",
"numpy.zeros",
"numpy.min",
"numpy.argsort",
"numpy.array",
"numpy.abs",
"numpy.random.shuffle",
"numpy.ones",
"numpy.percentile"
],
[
"tensorflow.device",
"tensorflow.compat.v1.ConfigProto",
"numpy.linspace",
"tensorflow.keras.mixed_precision.experimental.Policy",
"tensorflow.compat.v1.keras.backend.set_session",
"tensorflow.config.experimental.list_physical_devices",
"tensorflow.keras.mixed_precision.experimental.set_policy",
"numpy.ones",
"tensorflow.compat.v1.Session",
"numpy.argmax",
"numpy.where",
"numpy.random.rand",
"numpy.array",
"numpy.zeros",
"tensorflow.config.optimizer.set_jit",
"tensorflow.GradientTape"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [
"0.14",
"1.6",
"1.10",
"0.15",
"1.4",
"0.16",
"1.9",
"0.19",
"1.5",
"0.18",
"1.2",
"1.7",
"1.0",
"0.17",
"1.3",
"1.8"
],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"1.10",
"2.7",
"1.12",
"2.6",
"2.2",
"1.13",
"2.3",
"2.4",
"2.9",
"2.5",
"2.8",
"2.10"
]
}
] |
ibenemerito88/openBF_workshop | [
"a63a6fbd1ef8528890fb1072730124e054875008"
] | [
"Workshop/Part3/part3_sol.py"
] | [
"import numpy as np\nimport matplotlib.pyplot as plt\nfrom scipy import integrate\nimport reslast\n\n\nplt.close(\"all\")\n\n# Symmetric network\nq,a,p,u,c,n,s = reslast.resu(\"network\")\n# Non-symmetric network\nqn,an,pn,un,cn,nn,sn = reslast.resu(\"networknonsym\")\n\n\n\n\n\nplt.show()"
] | [
[
"matplotlib.pyplot.show",
"matplotlib.pyplot.close"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
AsaphLightricks/3DDFA | [
"7630986c0286cd2c85b5dfd14ae6e8322e4ba605"
] | [
"utils/cython/setup.py"
] | [
"'''\npython setup.py build_ext -i\nto compile\n'''\n\n# setup.py\nfrom distutils.core import setup, Extension\n# from Cython.Build import cythonize\nfrom Cython.Distutils import build_ext\nimport numpy\n\nsetup(\n name='mesh_core_cython',\n cmdclass={'build_ext': build_ext},\n ext_modules=[Extension(\"mesh_core_cython\",\n sources=[\"mesh_core_cython.pyx\", \"mesh_core.cpp\"],\n language='c++',\n include_dirs=[numpy.get_include()], extra_compile_args=['-std=c++11', '-D_hypot=hypot', '-stdlib=libc++'])],\n\n)\n"
] | [
[
"numpy.get_include"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
britta-wstnr/mne-python | [
"b69afd1ff3337ac84f219b26c53537a5c8ceb1b9",
"33146156f2660f122ecc04fa0d5b3fd3c34b549e",
"33146156f2660f122ecc04fa0d5b3fd3c34b549e",
"33146156f2660f122ecc04fa0d5b3fd3c34b549e",
"33146156f2660f122ecc04fa0d5b3fd3c34b549e"
] | [
"mne/io/pick.py",
"tutorials/plot_brainstorm_auditory.py",
"mne/io/proj.py",
"examples/visualization/plot_topo_compare_conditions.py",
"mne/preprocessing/tests/test_maxwell.py"
] | [
"# Authors: Alexandre Gramfort <[email protected]>\n# Matti Hamalainen <[email protected]>\n# Martin Luessi <[email protected]>\n#\n# License: BSD (3-clause)\n\nfrom copy import deepcopy\nimport re\n\nimport numpy as np\n\nfrom .constants import FIFF\nfrom ..utils import logger, verbose\nfrom ..externals.six import string_types\n\n\ndef channel_type(info, idx):\n \"\"\"Get channel type.\n\n Parameters\n ----------\n info : dict\n Measurement info\n idx : int\n Index of channel\n\n Returns\n -------\n type : 'grad' | 'mag' | 'eeg' | 'stim' | 'eog' | 'emg' | 'ecg'\n 'ref_meg' | 'resp' | 'exci' | 'ias' | 'syst' | 'misc'\n 'seeg' | 'bio' | 'chpi' | 'dipole' | 'gof' | 'ecog' | 'hbo' | 'hbr'\n Type of channel\n \"\"\"\n kind = info['chs'][idx]['kind']\n if kind == FIFF.FIFFV_MEG_CH:\n if info['chs'][idx]['unit'] == FIFF.FIFF_UNIT_T_M:\n return 'grad'\n elif info['chs'][idx]['unit'] == FIFF.FIFF_UNIT_T:\n return 'mag'\n elif kind == FIFF.FIFFV_REF_MEG_CH:\n return 'ref_meg'\n elif kind == FIFF.FIFFV_EEG_CH:\n return 'eeg'\n elif kind == FIFF.FIFFV_STIM_CH:\n return 'stim'\n elif kind == FIFF.FIFFV_EOG_CH:\n return 'eog'\n elif kind == FIFF.FIFFV_EMG_CH:\n return 'emg'\n elif kind == FIFF.FIFFV_ECG_CH:\n return 'ecg'\n elif kind == FIFF.FIFFV_RESP_CH:\n return 'resp'\n elif kind == FIFF.FIFFV_MISC_CH:\n return 'misc'\n elif kind == FIFF.FIFFV_EXCI_CH:\n return 'exci'\n elif kind == FIFF.FIFFV_IAS_CH:\n return 'ias'\n elif kind == FIFF.FIFFV_SYST_CH:\n return 'syst'\n elif kind == FIFF.FIFFV_SEEG_CH:\n return 'seeg'\n elif kind == FIFF.FIFFV_BIO_CH:\n return 'bio'\n elif kind in [FIFF.FIFFV_QUAT_0, FIFF.FIFFV_QUAT_1, FIFF.FIFFV_QUAT_2,\n FIFF.FIFFV_QUAT_3, FIFF.FIFFV_QUAT_4, FIFF.FIFFV_QUAT_5,\n FIFF.FIFFV_QUAT_6, FIFF.FIFFV_HPI_G, FIFF.FIFFV_HPI_ERR,\n FIFF.FIFFV_HPI_MOV]:\n return 'chpi' # channels relative to head position monitoring\n elif kind == FIFF.FIFFV_DIPOLE_WAVE:\n return 'dipole'\n elif kind == FIFF.FIFFV_GOODNESS_FIT:\n return 'gof'\n elif kind == FIFF.FIFFV_ECOG_CH:\n return 'ecog'\n elif kind == FIFF.FIFFV_FNIRS_CH:\n if info['chs'][idx]['coil_type'] == FIFF.FIFFV_COIL_FNIRS_HBO:\n return 'hbo'\n elif info['chs'][idx]['coil_type'] == FIFF.FIFFV_COIL_FNIRS_HBR:\n return 'hbr'\n raise Exception('Unknown channel type')\n\n\ndef pick_channels(ch_names, include, exclude=[]):\n \"\"\"Pick channels by names.\n\n Returns the indices of the good channels in ch_names.\n\n Parameters\n ----------\n ch_names : list of string\n List of channels.\n include : list of string\n List of channels to include (if empty include all available).\n\n .. note:: This is to be treated as a set. The order of this list\n is not used or maintained in ``sel``.\n\n exclude : list of string\n List of channels to exclude (if empty do not exclude any channel).\n Defaults to [].\n\n See Also\n --------\n pick_channels_regexp, pick_types\n\n Returns\n -------\n sel : array of int\n Indices of good channels.\n \"\"\"\n if len(np.unique(ch_names)) != len(ch_names):\n raise RuntimeError('ch_names is not a unique list, picking is unsafe')\n _check_excludes_includes(include)\n _check_excludes_includes(exclude)\n if not isinstance(include, set):\n include = set(include)\n if not isinstance(exclude, set):\n exclude = set(exclude)\n\n sel = []\n for k, name in enumerate(ch_names):\n if (len(include) == 0 or name in include) and name not in exclude:\n sel.append(k)\n return np.array(sel, int)\n\n\ndef pick_channels_regexp(ch_names, regexp):\n \"\"\"Pick channels using regular expression.\n\n Returns the indices of the good channels in ch_names.\n\n Parameters\n ----------\n ch_names : list of string\n List of channels\n\n regexp : string\n The regular expression. See python standard module for regular\n expressions.\n\n Returns\n -------\n sel : array of int\n Indices of good channels.\n\n See Also\n --------\n pick_channels\n\n Examples\n --------\n >>> pick_channels_regexp(['MEG 2331', 'MEG 2332', 'MEG 2333'], 'MEG ...1')\n [0]\n >>> pick_channels_regexp(['MEG 2331', 'MEG 2332', 'MEG 2333'], 'MEG *')\n [0, 1, 2]\n \"\"\"\n r = re.compile(regexp)\n return [k for k, name in enumerate(ch_names) if r.match(name)]\n\n\ndef _triage_meg_pick(ch, meg):\n \"\"\"Triage an MEG pick type.\"\"\"\n if meg is True:\n return True\n elif ch['unit'] == FIFF.FIFF_UNIT_T_M:\n if meg == 'grad':\n return True\n elif meg == 'planar1' and ch['ch_name'].endswith('2'):\n return True\n elif meg == 'planar2' and ch['ch_name'].endswith('3'):\n return True\n elif (meg == 'mag' and ch['unit'] == FIFF.FIFF_UNIT_T):\n return True\n return False\n\n\ndef _triage_fnirs_pick(ch, fnirs):\n \"\"\"Triage an fNIRS pick type.\"\"\"\n if fnirs is True:\n return True\n elif ch['coil_type'] == FIFF.FIFFV_COIL_FNIRS_HBO and fnirs == 'hbo':\n return True\n elif ch['coil_type'] == FIFF.FIFFV_COIL_FNIRS_HBR and fnirs == 'hbr':\n return True\n return False\n\n\ndef _check_meg_type(meg, allow_auto=False):\n \"\"\"Ensure a valid meg type.\"\"\"\n if isinstance(meg, string_types):\n allowed_types = ['grad', 'mag', 'planar1', 'planar2']\n allowed_types += ['auto'] if allow_auto else []\n if meg not in allowed_types:\n raise ValueError('meg value must be one of %s or bool, not %s'\n % (allowed_types, meg))\n\n\ndef pick_types(info, meg=True, eeg=False, stim=False, eog=False, ecg=False,\n emg=False, ref_meg='auto', misc=False, resp=False, chpi=False,\n exci=False, ias=False, syst=False, seeg=False, dipole=False,\n gof=False, bio=False, ecog=False, fnirs=False, include=(),\n exclude='bads', selection=None):\n \"\"\"Pick channels by type and names.\n\n Parameters\n ----------\n info : dict\n The measurement info.\n meg : bool | str\n If True include all MEG channels. If False include None\n If string it can be 'mag', 'grad', 'planar1' or 'planar2' to select\n only magnetometers, all gradiometers, or a specific type of\n gradiometer.\n eeg : bool\n If True include EEG channels.\n stim : bool\n If True include stimulus channels.\n eog : bool\n If True include EOG channels.\n ecg : bool\n If True include ECG channels.\n emg : bool\n If True include EMG channels.\n ref_meg: bool | str\n If True include CTF / 4D reference channels. If 'auto', the reference\n channels are only included if compensations are present. Can also be\n the string options from `meg`.\n misc : bool\n If True include miscellaneous analog channels.\n resp : bool\n If True include response-trigger channel. For some MEG systems this\n is separate from the stim channel.\n chpi : bool\n If True include continuous HPI coil channels.\n exci : bool\n Flux excitation channel used to be a stimulus channel.\n ias : bool\n Internal Active Shielding data (maybe on Triux only).\n syst : bool\n System status channel information (on Triux systems only).\n seeg : bool\n Stereotactic EEG channels.\n dipole : bool\n Dipole time course channels.\n gof : bool\n Dipole goodness of fit channels.\n bio : bool\n Bio channels.\n ecog : bool\n Electrocorticography channels.\n fnirs : bool | str\n Functional near-infrared spectroscopy channels. If True include all\n fNIRS channels. If False (default) include none. If string it can be\n 'hbo' (to include channels measuring oxyhemoglobin) or 'hbr' (to\n include channels measuring deoxyhemoglobin).\n include : list of string\n List of additional channels to include. If empty do not include any.\n exclude : list of string | str\n List of channels to exclude. If 'bads' (default), exclude channels\n in ``info['bads']``.\n selection : list of string\n Restrict sensor channels (MEG, EEG) to this list of channel names.\n\n Returns\n -------\n sel : array of int\n Indices of good channels.\n \"\"\"\n # NOTE: Changes to this function's signature should also be changed in\n # PickChannelsMixin\n from .meas_info import Info\n if not isinstance(info, Info):\n raise TypeError('info must be an instance of Info, not %s'\n % type(info))\n info._check_consistency()\n nchan = info['nchan']\n pick = np.zeros(nchan, dtype=np.bool)\n\n if exclude is None:\n raise ValueError('exclude must be a list of strings or \"bads\"')\n elif exclude == 'bads':\n exclude = info.get('bads', [])\n elif not isinstance(exclude, (list, tuple)):\n raise ValueError('exclude must either be \"bads\" or a list of strings.'\n ' If only one channel is to be excluded, use '\n '[ch_name] instead of passing ch_name.')\n\n _check_meg_type(ref_meg, allow_auto=True)\n _check_meg_type(meg)\n if isinstance(ref_meg, string_types) and ref_meg == 'auto':\n ref_meg = ('comps' in info and info['comps'] is not None and\n len(info['comps']) > 0)\n\n for param in (eeg, stim, eog, ecg, emg, misc, resp, chpi, exci,\n ias, syst, seeg, dipole, gof, bio, ecog):\n if not isinstance(param, bool):\n w = ('Parameters for all channel types (with the exception '\n 'of \"meg\", \"ref_meg\" and \"fnirs\") must be of type bool, '\n 'not {0}.')\n raise ValueError(w.format(type(param)))\n\n for k in range(nchan):\n kind = info['chs'][k]['kind']\n # XXX eventually we should de-duplicate this with channel_type!\n if kind == FIFF.FIFFV_MEG_CH and meg:\n pick[k] = _triage_meg_pick(info['chs'][k], meg)\n elif kind == FIFF.FIFFV_EEG_CH and eeg:\n pick[k] = True\n elif kind == FIFF.FIFFV_STIM_CH and stim:\n pick[k] = True\n elif kind == FIFF.FIFFV_EOG_CH and eog:\n pick[k] = True\n elif kind == FIFF.FIFFV_ECG_CH and ecg:\n pick[k] = True\n elif kind == FIFF.FIFFV_EMG_CH and emg:\n pick[k] = True\n elif kind == FIFF.FIFFV_MISC_CH and misc:\n pick[k] = True\n elif kind == FIFF.FIFFV_REF_MEG_CH and ref_meg:\n pick[k] = _triage_meg_pick(info['chs'][k], ref_meg)\n elif kind == FIFF.FIFFV_RESP_CH and resp:\n pick[k] = True\n elif kind == FIFF.FIFFV_SYST_CH and syst:\n pick[k] = True\n elif kind == FIFF.FIFFV_SEEG_CH and seeg:\n pick[k] = True\n elif kind == FIFF.FIFFV_IAS_CH and ias:\n pick[k] = True\n elif kind == FIFF.FIFFV_EXCI_CH and exci:\n pick[k] = True\n elif kind in [FIFF.FIFFV_QUAT_0, FIFF.FIFFV_QUAT_1, FIFF.FIFFV_QUAT_2,\n FIFF.FIFFV_QUAT_3, FIFF.FIFFV_QUAT_4, FIFF.FIFFV_QUAT_5,\n FIFF.FIFFV_QUAT_6, FIFF.FIFFV_HPI_G, FIFF.FIFFV_HPI_ERR,\n FIFF.FIFFV_HPI_MOV] and chpi:\n pick[k] = True\n elif kind == FIFF.FIFFV_DIPOLE_WAVE and dipole:\n pick[k] = True\n elif kind == FIFF.FIFFV_GOODNESS_FIT and gof:\n pick[k] = True\n elif kind == FIFF.FIFFV_BIO_CH and bio:\n pick[k] = True\n elif kind == FIFF.FIFFV_ECOG_CH and ecog:\n pick[k] = True\n elif kind == FIFF.FIFFV_FNIRS_CH:\n pick[k] = _triage_fnirs_pick(info['chs'][k], fnirs)\n\n # restrict channels to selection if provided\n if selection is not None:\n # the selection only restricts these types of channels\n sel_kind = [FIFF.FIFFV_MEG_CH, FIFF.FIFFV_REF_MEG_CH,\n FIFF.FIFFV_EEG_CH]\n for k in np.where(pick)[0]:\n if (info['chs'][k]['kind'] in sel_kind and\n info['ch_names'][k] not in selection):\n pick[k] = False\n\n myinclude = [info['ch_names'][k] for k in range(nchan) if pick[k]]\n myinclude += include\n\n if len(myinclude) == 0:\n sel = np.array([], int)\n else:\n sel = pick_channels(info['ch_names'], myinclude, exclude)\n\n return sel\n\n\ndef pick_info(info, sel=(), copy=True):\n \"\"\"Restrict an info structure to a selection of channels.\n\n Parameters\n ----------\n info : dict\n Info structure from evoked or raw data.\n sel : list of int | None\n Indices of channels to include.\n copy : bool\n If copy is False, info is modified inplace.\n\n Returns\n -------\n res : dict\n Info structure restricted to a selection of channels.\n \"\"\"\n info._check_consistency()\n info = info.copy() if copy else info\n if sel is None:\n return info\n elif len(sel) == 0:\n raise ValueError('No channels match the selection.')\n\n info['chs'] = [info['chs'][k] for k in sel]\n info._update_redundant()\n info['bads'] = [ch for ch in info['bads'] if ch in info['ch_names']]\n\n comps = deepcopy(info['comps'])\n for c in comps:\n row_idx = [k for k, n in enumerate(c['data']['row_names'])\n if n in info['ch_names']]\n row_names = [c['data']['row_names'][i] for i in row_idx]\n rowcals = c['rowcals'][row_idx]\n c['rowcals'] = rowcals\n c['data']['nrow'] = len(row_names)\n c['data']['row_names'] = row_names\n c['data']['data'] = c['data']['data'][row_idx]\n info['comps'] = comps\n info._check_consistency()\n return info\n\n\ndef _has_kit_refs(info, picks):\n \"\"\"Determine if KIT ref channels are chosen.\n\n This is currently only used by make_forward_solution, which cannot\n run when KIT reference channels are included.\n \"\"\"\n for p in picks:\n if info['chs'][p]['coil_type'] == FIFF.FIFFV_COIL_KIT_REF_MAG:\n return True\n return False\n\n\ndef pick_channels_evoked(orig, include=[], exclude='bads'):\n \"\"\"Pick channels from evoked data.\n\n Parameters\n ----------\n orig : Evoked object\n One evoked dataset.\n include : list of string, (optional)\n List of channels to include (if empty, include all available).\n exclude : list of string | str\n List of channels to exclude. If empty do not exclude any (default).\n If 'bads', exclude channels in orig.info['bads']. Defaults to 'bads'.\n\n Returns\n -------\n res : instance of Evoked\n Evoked data restricted to selected channels. If include and\n exclude are empty it returns orig without copy.\n \"\"\"\n if len(include) == 0 and len(exclude) == 0:\n return orig\n\n exclude = _check_excludes_includes(exclude, info=orig.info,\n allow_bads=True)\n sel = pick_channels(orig.info['ch_names'], include=include,\n exclude=exclude)\n\n if len(sel) == 0:\n raise ValueError('Warning : No channels match the selection.')\n\n res = deepcopy(orig)\n #\n # Modify the measurement info\n #\n res.info = pick_info(res.info, sel)\n #\n # Create the reduced data set\n #\n res.data = res.data[sel, :]\n\n return res\n\n\n@verbose\ndef pick_channels_forward(orig, include=[], exclude=[], verbose=None):\n \"\"\"Pick channels from forward operator.\n\n Parameters\n ----------\n orig : dict\n A forward solution.\n include : list of string\n List of channels to include (if empty, include all available).\n Defaults to [].\n exclude : list of string | 'bads'\n Channels to exclude (if empty, do not exclude any). Defaults to [].\n If 'bads', then exclude bad channels in orig.\n verbose : bool, str, int, or None\n If not None, override default verbose level (see :func:`mne.verbose`\n and :ref:`Logging documentation <tut_logging>` for more).\n\n Returns\n -------\n res : dict\n Forward solution restricted to selected channels. If include and\n exclude are empty it returns orig without copy.\n \"\"\"\n orig['info']._check_consistency()\n if len(include) == 0 and len(exclude) == 0:\n return orig\n exclude = _check_excludes_includes(exclude,\n info=orig['info'], allow_bads=True)\n\n # Allow for possibility of channel ordering in forward solution being\n # different from that of the M/EEG file it is based on.\n sel_sol = pick_channels(orig['sol']['row_names'], include=include,\n exclude=exclude)\n sel_info = pick_channels(orig['info']['ch_names'], include=include,\n exclude=exclude)\n\n fwd = deepcopy(orig)\n\n # Check that forward solution and original data file agree on #channels\n if len(sel_sol) != len(sel_info):\n raise ValueError('Forward solution and functional data appear to '\n 'have different channel names, please check.')\n\n # Do we have something?\n nuse = len(sel_sol)\n if nuse == 0:\n raise ValueError('Nothing remains after picking')\n\n logger.info(' %d out of %d channels remain after picking'\n % (nuse, fwd['nchan']))\n\n # Pick the correct rows of the forward operator using sel_sol\n fwd['sol']['data'] = fwd['sol']['data'][sel_sol, :]\n fwd['_orig_sol'] = fwd['_orig_sol'][sel_sol, :]\n fwd['sol']['nrow'] = nuse\n\n ch_names = [fwd['sol']['row_names'][k] for k in sel_sol]\n fwd['nchan'] = nuse\n fwd['sol']['row_names'] = ch_names\n\n # Pick the appropriate channel names from the info-dict using sel_info\n fwd['info']['chs'] = [fwd['info']['chs'][k] for k in sel_info]\n fwd['info']._update_redundant()\n fwd['info']['bads'] = [b for b in fwd['info']['bads'] if b in ch_names]\n\n if fwd['sol_grad'] is not None:\n fwd['sol_grad']['data'] = fwd['sol_grad']['data'][sel_sol, :]\n fwd['_orig_sol_grad'] = fwd['_orig_sol_grad'][sel_sol, :]\n fwd['sol_grad']['nrow'] = nuse\n fwd['sol_grad']['row_names'] = [fwd['sol_grad']['row_names'][k]\n for k in sel_sol]\n\n return fwd\n\n\ndef pick_types_forward(orig, meg=True, eeg=False, ref_meg=True, seeg=False,\n ecog=False, include=[], exclude=[]):\n \"\"\"Pick by channel type and names from a forward operator.\n\n Parameters\n ----------\n orig : dict\n A forward solution\n meg : bool or string\n If True include all MEG channels. If False include None\n If string it can be 'mag' or 'grad' to select only gradiometers\n or magnetometers.\n eeg : bool\n If True include EEG channels\n ref_meg : bool\n If True include CTF / 4D reference channels\n seeg : bool\n If True include stereotactic EEG channels\n ecog : bool\n If True include electrocorticography channels\n include : list of string\n List of additional channels to include. If empty do not include any.\n exclude : list of string | str\n List of channels to exclude. If empty do not exclude any (default).\n If 'bads', exclude channels in orig['info']['bads'].\n\n Returns\n -------\n res : dict\n Forward solution restricted to selected channel types.\n \"\"\"\n info = orig['info']\n sel = pick_types(info, meg, eeg, ref_meg=ref_meg, seeg=seeg, ecog=ecog,\n include=include, exclude=exclude)\n if len(sel) == 0:\n raise ValueError('No valid channels found')\n include_ch_names = [info['ch_names'][k] for k in sel]\n\n return pick_channels_forward(orig, include_ch_names)\n\n\ndef channel_indices_by_type(info):\n \"\"\"Get indices of channels by type.\"\"\"\n idx = dict((key, list()) for key in _PICK_TYPES_KEYS if\n key not in ('meg', 'fnirs'))\n idx.update(mag=list(), grad=list(), hbo=list(), hbr=list())\n for k, ch in enumerate(info['chs']):\n for key in idx.keys():\n if channel_type(info, k) == key:\n idx[key].append(k)\n\n return idx\n\n\ndef pick_channels_cov(orig, include=[], exclude='bads'):\n \"\"\"Pick channels from covariance matrix.\n\n Parameters\n ----------\n orig : Covariance\n A covariance.\n include : list of string, (optional)\n List of channels to include (if empty, include all available).\n exclude : list of string, (optional) | 'bads'\n Channels to exclude (if empty, do not exclude any). Defaults to 'bads'.\n\n Returns\n -------\n res : dict\n Covariance solution restricted to selected channels.\n \"\"\"\n from ..cov import Covariance\n exclude = orig['bads'] if exclude == 'bads' else exclude\n sel = pick_channels(orig['names'], include=include, exclude=exclude)\n data = orig['data'][sel][:, sel] if not orig['diag'] else orig['data'][sel]\n names = [orig['names'][k] for k in sel]\n bads = [name for name in orig['bads'] if name in orig['names']]\n res = Covariance(\n data=data, names=names, bads=bads, projs=deepcopy(orig['projs']),\n nfree=orig['nfree'], eig=None, eigvec=None,\n method=orig.get('method', None), loglik=orig.get('loglik', None))\n return res\n\n\ndef _picks_by_type(info, meg_combined=False, ref_meg=False, exclude='bads'):\n \"\"\"Get data channel indices as separate list of tuples.\n\n Parameters\n ----------\n info : instance of mne.measuerment_info.Info\n The info.\n meg_combined : bool\n Whether to return combined picks for grad and mag.\n ref_meg : bool\n If True include CTF / 4D reference channels\n exclude : list of string | str\n List of channels to exclude. If 'bads' (default), exclude channels\n in info['bads'].\n\n Returns\n -------\n picks_list : list of tuples\n The list of tuples of picks and the type string.\n \"\"\"\n from ..channels.channels import _contains_ch_type\n picks_list = []\n has_mag, has_grad, has_eeg = [_contains_ch_type(info, k)\n for k in ('mag', 'grad', 'eeg')]\n if has_mag and (meg_combined is not True or not has_grad):\n picks_list.append(\n ('mag', pick_types(info, meg='mag', eeg=False, stim=False,\n ref_meg=ref_meg, exclude=exclude))\n )\n if has_grad and (meg_combined is not True or not has_mag):\n picks_list.append(\n ('grad', pick_types(info, meg='grad', eeg=False, stim=False,\n ref_meg=ref_meg, exclude=exclude))\n )\n if has_mag and has_grad and meg_combined is True:\n picks_list.append(\n ('meg', pick_types(info, meg=True, eeg=False, stim=False,\n ref_meg=ref_meg, exclude=exclude))\n )\n if has_eeg:\n picks_list.append(\n ('eeg', pick_types(info, meg=False, eeg=True, stim=False,\n ref_meg=ref_meg, exclude=exclude))\n )\n return picks_list\n\n\ndef _check_excludes_includes(chs, info=None, allow_bads=False):\n \"\"\"Ensure that inputs to exclude/include are list-like or \"bads\".\n\n Parameters\n ----------\n chs : any input, should be list, tuple, string\n The channels passed to include or exclude.\n allow_bads : bool\n Allow the user to supply \"bads\" as a string for auto exclusion.\n\n Returns\n -------\n chs : list\n Channels to be excluded/excluded. If allow_bads, and chs==\"bads\",\n this will be the bad channels found in 'info'.\n \"\"\"\n from .meas_info import Info\n if not isinstance(chs, (list, tuple, np.ndarray)):\n if allow_bads is True:\n if not isinstance(info, Info):\n raise ValueError('Supply an info object if allow_bads is true')\n elif chs != 'bads':\n raise ValueError('If chs is a string, it must be \"bads\"')\n else:\n chs = info['bads']\n else:\n raise ValueError(\n 'include/exclude must be list, tuple, ndarray, or \"bads\". ' +\n 'You provided type {0}'.format(type(chs)))\n return chs\n\n\n_PICK_TYPES_DATA_DICT = dict(\n meg=True, eeg=True, stim=False, eog=False, ecg=False, emg=False,\n misc=False, resp=False, chpi=False, exci=False, ias=False, syst=False,\n seeg=True, dipole=False, gof=False, bio=False, ecog=True, fnirs=True)\n_PICK_TYPES_KEYS = tuple(list(_PICK_TYPES_DATA_DICT.keys()) + ['ref_meg'])\n_DATA_CH_TYPES_SPLIT = ['mag', 'grad', 'eeg', 'seeg', 'ecog', 'hbo', 'hbr']\n\n# Valid data types, ordered for consistency, used in viz/evoked.\n_VALID_CHANNEL_TYPES = ['eeg', 'grad', 'mag', 'seeg', 'eog', 'ecg', 'emg',\n 'dipole', 'gof', 'bio', 'ecog', 'hbo', 'hbr',\n 'misc']\n\n\ndef _pick_data_channels(info, exclude='bads', with_ref_meg=True):\n \"\"\"Pick only data channels.\"\"\"\n return pick_types(info, ref_meg=with_ref_meg, include=[], exclude=exclude,\n selection=None, **_PICK_TYPES_DATA_DICT)\n\n\ndef _pick_aux_channels(info, exclude='bads'):\n \"\"\"Pick only auxiliary channels.\n\n Corresponds to EOG, ECG, EMG and BIO\n \"\"\"\n return pick_types(info, meg=False, eog=True, ecg=True, emg=True, bio=True,\n ref_meg=False, exclude=exclude)\n\n\ndef _pick_data_or_ica(info):\n \"\"\"Pick only data or ICA channels.\"\"\"\n ch_names = [c['ch_name'] for c in info['chs']]\n if 'ICA ' in ','.join(ch_names):\n picks = pick_types(info, exclude=[], misc=True)\n else:\n picks = _pick_data_channels(info, exclude=[], with_ref_meg=True)\n return picks\n",
"# -*- coding: utf-8 -*-\n\"\"\"\n====================================\nBrainstorm auditory tutorial dataset\n====================================\n\nHere we compute the evoked from raw for the auditory Brainstorm\ntutorial dataset. For comparison, see [1]_ and:\n\n http://neuroimage.usc.edu/brainstorm/Tutorials/Auditory\n\nExperiment:\n\n - One subject, 2 acquisition runs 6 minutes each.\n - Each run contains 200 regular beeps and 40 easy deviant beeps.\n - Random ISI: between 0.7s and 1.7s seconds, uniformly distributed.\n - Button pressed when detecting a deviant with the right index finger.\n\nThe specifications of this dataset were discussed initially on the\n`FieldTrip bug tracker <http://bugzilla.fcdonders.nl/show_bug.cgi?id=2300>`_.\n\nReferences\n----------\n.. [1] Tadel F, Baillet S, Mosher JC, Pantazis D, Leahy RM.\n Brainstorm: A User-Friendly Application for MEG/EEG Analysis.\n Computational Intelligence and Neuroscience, vol. 2011, Article ID\n 879716, 13 pages, 2011. doi:10.1155/2011/879716\n\"\"\"\n\n# Authors: Mainak Jas <[email protected]>\n# Eric Larson <[email protected]>\n# Jaakko Leppakangas <[email protected]>\n#\n# License: BSD (3-clause)\n\nimport os.path as op\nimport pandas as pd\nimport numpy as np\n\nimport mne\nfrom mne import combine_evoked\nfrom mne.minimum_norm import apply_inverse\nfrom mne.datasets.brainstorm import bst_auditory\nfrom mne.io import read_raw_ctf\nfrom mne.filter import notch_filter, filter_data\n\nprint(__doc__)\n\n###############################################################################\n# To reduce memory consumption and running time, some of the steps are\n# precomputed. To run everything from scratch change this to False. With\n# ``use_precomputed = False`` running time of this script can be several\n# minutes even on a fast computer.\nuse_precomputed = True\n\n###############################################################################\n# The data was collected with a CTF 275 system at 2400 Hz and low-pass\n# filtered at 600 Hz. Here the data and empty room data files are read to\n# construct instances of :class:`mne.io.Raw`.\ndata_path = bst_auditory.data_path()\n\nsubject = 'bst_auditory'\nsubjects_dir = op.join(data_path, 'subjects')\n\nraw_fname1 = op.join(data_path, 'MEG', 'bst_auditory',\n 'S01_AEF_20131218_01.ds')\nraw_fname2 = op.join(data_path, 'MEG', 'bst_auditory',\n 'S01_AEF_20131218_02.ds')\nerm_fname = op.join(data_path, 'MEG', 'bst_auditory',\n 'S01_Noise_20131218_01.ds')\n\n###############################################################################\n# In the memory saving mode we use ``preload=False`` and use the memory\n# efficient IO which loads the data on demand. However, filtering and some\n# other functions require the data to be preloaded in the memory.\npreload = not use_precomputed\nraw = read_raw_ctf(raw_fname1, preload=preload)\nn_times_run1 = raw.n_times\nmne.io.concatenate_raws([raw, read_raw_ctf(raw_fname2, preload=preload)])\nraw_erm = read_raw_ctf(erm_fname, preload=preload)\n\n###############################################################################\n# Data channel array consisted of 274 MEG axial gradiometers, 26 MEG reference\n# sensors and 2 EEG electrodes (Cz and Pz).\n# In addition:\n#\n# - 1 stim channel for marking presentation times for the stimuli\n# - 1 audio channel for the sent signal\n# - 1 response channel for recording the button presses\n# - 1 ECG bipolar\n# - 2 EOG bipolar (vertical and horizontal)\n# - 12 head tracking channels\n# - 20 unused channels\n#\n# The head tracking channels and the unused channels are marked as misc\n# channels. Here we define the EOG and ECG channels.\nraw.set_channel_types({'HEOG': 'eog', 'VEOG': 'eog', 'ECG': 'ecg'})\nif not use_precomputed:\n # Leave out the two EEG channels for easier computation of forward.\n raw.pick_types(meg=True, eeg=False, stim=True, misc=True, eog=True,\n ecg=True)\n\n###############################################################################\n# For noise reduction, a set of bad segments have been identified and stored\n# in csv files. The bad segments are later used to reject epochs that overlap\n# with them.\n# The file for the second run also contains some saccades. The saccades are\n# removed by using SSP. We use pandas to read the data from the csv files. You\n# can also view the files with your favorite text editor.\n\nannotations_df = pd.DataFrame()\noffset = n_times_run1\nfor idx in [1, 2]:\n csv_fname = op.join(data_path, 'MEG', 'bst_auditory',\n 'events_bad_0%s.csv' % idx)\n df = pd.read_csv(csv_fname, header=None,\n names=['onset', 'duration', 'id', 'label'])\n print('Events from run {0}:'.format(idx))\n print(df)\n\n df['onset'] += offset * (idx - 1)\n annotations_df = pd.concat([annotations_df, df], axis=0)\n\nsaccades_events = df[df['label'] == 'saccade'].values[:, :3].astype(int)\n\n# Conversion from samples to times:\nonsets = annotations_df['onset'].values / raw.info['sfreq']\ndurations = annotations_df['duration'].values / raw.info['sfreq']\ndescriptions = annotations_df['label'].values\n\nannotations = mne.Annotations(onsets, durations, descriptions)\nraw.annotations = annotations\ndel onsets, durations, descriptions\n\n###############################################################################\n# Here we compute the saccade and EOG projectors for magnetometers and add\n# them to the raw data. The projectors are added to both runs.\nsaccade_epochs = mne.Epochs(raw, saccades_events, 1, 0., 0.5, preload=True,\n reject_by_annotation=False)\n\nprojs_saccade = mne.compute_proj_epochs(saccade_epochs, n_mag=1, n_eeg=0,\n desc_prefix='saccade')\nif use_precomputed:\n proj_fname = op.join(data_path, 'MEG', 'bst_auditory',\n 'bst_auditory-eog-proj.fif')\n projs_eog = mne.read_proj(proj_fname)[0]\nelse:\n projs_eog, _ = mne.preprocessing.compute_proj_eog(raw.load_data(),\n n_mag=1, n_eeg=0)\nraw.add_proj(projs_saccade)\nraw.add_proj(projs_eog)\ndel saccade_epochs, saccades_events, projs_eog, projs_saccade # To save memory\n\n###############################################################################\n# Visually inspect the effects of projections. Click on 'proj' button at the\n# bottom right corner to toggle the projectors on/off. EOG events can be\n# plotted by adding the event list as a keyword argument. As the bad segments\n# and saccades were added as annotations to the raw data, they are plotted as\n# well.\nraw.plot(block=True)\n\n###############################################################################\n# Typical preprocessing step is the removal of power line artifact (50 Hz or\n# 60 Hz). Here we notch filter the data at 60, 120 and 180 to remove the\n# original 60 Hz artifact and the harmonics. The power spectra are plotted\n# before and after the filtering to show the effect. The drop after 600 Hz\n# appears because the data was filtered during the acquisition. In memory\n# saving mode we do the filtering at evoked stage, which is not something you\n# usually would do.\nif not use_precomputed:\n meg_picks = mne.pick_types(raw.info, meg=True, eeg=False)\n raw.plot_psd(tmax=np.inf, picks=meg_picks)\n notches = np.arange(60, 181, 60)\n raw.notch_filter(notches)\n raw.plot_psd(tmax=np.inf, picks=meg_picks)\n\n###############################################################################\n# We also lowpass filter the data at 100 Hz to remove the hf components.\nif not use_precomputed:\n raw.filter(None, 100., h_trans_bandwidth=0.5, filter_length='10s',\n phase='zero-double', fir_design='firwin2')\n\n###############################################################################\n# Epoching and averaging.\n# First some parameters are defined and events extracted from the stimulus\n# channel (UPPT001). The rejection thresholds are defined as peak-to-peak\n# values and are in T / m for gradiometers, T for magnetometers and\n# V for EOG and EEG channels.\ntmin, tmax = -0.1, 0.5\nevent_id = dict(standard=1, deviant=2)\nreject = dict(mag=4e-12, eog=250e-6)\n# find events\nevents = mne.find_events(raw, stim_channel='UPPT001')\n\n###############################################################################\n# The event timing is adjusted by comparing the trigger times on detected\n# sound onsets on channel UADC001-4408.\nsound_data = raw[raw.ch_names.index('UADC001-4408')][0][0]\nonsets = np.where(np.abs(sound_data) > 2. * np.std(sound_data))[0]\nmin_diff = int(0.5 * raw.info['sfreq'])\ndiffs = np.concatenate([[min_diff + 1], np.diff(onsets)])\nonsets = onsets[diffs > min_diff]\nassert len(onsets) == len(events)\ndiffs = 1000. * (events[:, 0] - onsets) / raw.info['sfreq']\nprint('Trigger delay removed (μ ± σ): %0.1f ± %0.1f ms'\n % (np.mean(diffs), np.std(diffs)))\nevents[:, 0] = onsets\ndel sound_data, diffs\n\n###############################################################################\n# We mark a set of bad channels that seem noisier than others. This can also\n# be done interactively with ``raw.plot`` by clicking the channel name\n# (or the line). The marked channels are added as bad when the browser window\n# is closed.\nraw.info['bads'] = ['MLO52-4408', 'MRT51-4408', 'MLO42-4408', 'MLO43-4408']\n\n###############################################################################\n# The epochs (trials) are created for MEG channels. First we find the picks\n# for MEG and EOG channels. Then the epochs are constructed using these picks.\n# The epochs overlapping with annotated bad segments are also rejected by\n# default. To turn off rejection by bad segments (as was done earlier with\n# saccades) you can use keyword ``reject_by_annotation=False``.\npicks = mne.pick_types(raw.info, meg=True, eeg=False, stim=False, eog=True,\n exclude='bads')\n\nepochs = mne.Epochs(raw, events, event_id, tmin, tmax, picks=picks,\n baseline=(None, 0), reject=reject, preload=False,\n proj=True)\n\n###############################################################################\n# We only use first 40 good epochs from each run. Since we first drop the bad\n# epochs, the indices of the epochs are no longer same as in the original\n# epochs collection. Investigation of the event timings reveals that first\n# epoch from the second run corresponds to index 182.\nepochs.drop_bad()\nepochs_standard = mne.concatenate_epochs([epochs['standard'][range(40)],\n epochs['standard'][182:222]])\nepochs_standard.load_data() # Resampling to save memory.\nepochs_standard.resample(600, npad='auto')\nepochs_deviant = epochs['deviant'].load_data()\nepochs_deviant.resample(600, npad='auto')\ndel epochs, picks\n\n###############################################################################\n# The averages for each conditions are computed.\nevoked_std = epochs_standard.average()\nevoked_dev = epochs_deviant.average()\ndel epochs_standard, epochs_deviant\n\n###############################################################################\n# Typical preprocessing step is the removal of power line artifact (50 Hz or\n# 60 Hz). Here we notch filter the data at 60, 120 and 180 to remove the\n# original 60 Hz artifact and the harmonics. Normally this would be done to\n# raw data (with :func:`mne.io.Raw.filter`), but to reduce memory consumption\n# of this tutorial, we do it at evoked stage.\nif use_precomputed:\n sfreq = evoked_std.info['sfreq']\n notches = [60, 120, 180]\n for evoked in (evoked_std, evoked_dev):\n evoked.data[:] = notch_filter(evoked.data, sfreq, notches)\n evoked.data[:] = filter_data(evoked.data, sfreq, l_freq=None,\n h_freq=100.)\n\n###############################################################################\n# Here we plot the ERF of standard and deviant conditions. In both conditions\n# we can see the P50 and N100 responses. The mismatch negativity is visible\n# only in the deviant condition around 100-200 ms. P200 is also visible around\n# 170 ms in both conditions but much stronger in the standard condition. P300\n# is visible in deviant condition only (decision making in preparation of the\n# button press). You can view the topographies from a certain time span by\n# painting an area with clicking and holding the left mouse button.\nevoked_std.plot(window_title='Standard', gfp=True)\nevoked_dev.plot(window_title='Deviant', gfp=True)\n\n\n###############################################################################\n# Show activations as topography figures.\ntimes = np.arange(0.05, 0.301, 0.025)\nevoked_std.plot_topomap(times=times, title='Standard')\nevoked_dev.plot_topomap(times=times, title='Deviant')\n\n###############################################################################\n# We can see the MMN effect more clearly by looking at the difference between\n# the two conditions. P50 and N100 are no longer visible, but MMN/P200 and\n# P300 are emphasised.\nevoked_difference = combine_evoked([evoked_dev, -evoked_std], weights='equal')\nevoked_difference.plot(window_title='Difference', gfp=True)\n\n###############################################################################\n# Source estimation.\n# We compute the noise covariance matrix from the empty room measurement\n# and use it for the other runs.\nreject = dict(mag=4e-12)\ncov = mne.compute_raw_covariance(raw_erm, reject=reject)\ncov.plot(raw_erm.info)\ndel raw_erm\n\n###############################################################################\n# The transformation is read from a file. More information about coregistering\n# the data, see :ref:`ch_interactive_analysis` or\n# :func:`mne.gui.coregistration`.\ntrans_fname = op.join(data_path, 'MEG', 'bst_auditory',\n 'bst_auditory-trans.fif')\ntrans = mne.read_trans(trans_fname)\n\n###############################################################################\n# To save time and memory, the forward solution is read from a file. Set\n# ``use_precomputed=False`` in the beginning of this script to build the\n# forward solution from scratch. The head surfaces for constructing a BEM\n# solution are read from a file. Since the data only contains MEG channels, we\n# only need the inner skull surface for making the forward solution. For more\n# information: :ref:`CHDBBCEJ`, :func:`mne.setup_source_space`,\n# :ref:`create_bem_model`, :func:`mne.bem.make_watershed_bem`.\nif use_precomputed:\n fwd_fname = op.join(data_path, 'MEG', 'bst_auditory',\n 'bst_auditory-meg-oct-6-fwd.fif')\n fwd = mne.read_forward_solution(fwd_fname)\nelse:\n src = mne.setup_source_space(subject, spacing='ico4',\n subjects_dir=subjects_dir, overwrite=True)\n model = mne.make_bem_model(subject=subject, ico=4, conductivity=[0.3],\n subjects_dir=subjects_dir)\n bem = mne.make_bem_solution(model)\n fwd = mne.make_forward_solution(evoked_std.info, trans=trans, src=src,\n bem=bem)\n\ninv = mne.minimum_norm.make_inverse_operator(evoked_std.info, fwd, cov)\nsnr = 3.0\nlambda2 = 1.0 / snr ** 2\ndel fwd\n\n###############################################################################\n# The sources are computed using dSPM method and plotted on an inflated brain\n# surface. For interactive controls over the image, use keyword\n# ``time_viewer=True``.\n# Standard condition.\nstc_standard = mne.minimum_norm.apply_inverse(evoked_std, inv, lambda2, 'dSPM')\nbrain = stc_standard.plot(subjects_dir=subjects_dir, subject=subject,\n surface='inflated', time_viewer=False, hemi='lh',\n initial_time=0.1, time_unit='s')\ndel stc_standard, brain\n\n###############################################################################\n# Deviant condition.\nstc_deviant = mne.minimum_norm.apply_inverse(evoked_dev, inv, lambda2, 'dSPM')\nbrain = stc_deviant.plot(subjects_dir=subjects_dir, subject=subject,\n surface='inflated', time_viewer=False, hemi='lh',\n initial_time=0.1, time_unit='s')\ndel stc_deviant, brain\n\n###############################################################################\n# Difference.\nstc_difference = apply_inverse(evoked_difference, inv, lambda2, 'dSPM')\nbrain = stc_difference.plot(subjects_dir=subjects_dir, subject=subject,\n surface='inflated', time_viewer=False, hemi='lh',\n initial_time=0.15, time_unit='s')\n",
"# Authors: Alexandre Gramfort <[email protected]>\n# Matti Hamalainen <[email protected]>\n# Denis Engemann <[email protected]>\n# Teon Brooks <[email protected]>\n#\n# License: BSD (3-clause)\n\nfrom copy import deepcopy\nfrom itertools import count\nfrom math import sqrt\n\nimport numpy as np\nfrom scipy import linalg\n\nfrom .tree import dir_tree_find\nfrom .tag import find_tag\nfrom .constants import FIFF\nfrom .pick import pick_types\nfrom .write import (write_int, write_float, write_string, write_name_list,\n write_float_matrix, end_block, start_block)\nfrom ..utils import logger, verbose, warn\nfrom ..externals.six import string_types\n\n\nclass Projection(dict):\n \"\"\"Projection vector.\n\n A basic class to proj a meaningful print for projection vectors.\n \"\"\"\n\n def __repr__(self): # noqa: D105\n s = \"%s\" % self['desc']\n s += \", active : %s\" % self['active']\n s += \", n_channels : %s\" % self['data']['ncol']\n return \"<Projection | %s>\" % s\n\n\nclass ProjMixin(object):\n \"\"\"Mixin class for Raw, Evoked, Epochs.\n\n Notes\n -----\n This mixin adds a proj attribute as a property to data containers.\n It is True if at least one proj is present and all of them are active.\n The projs might not be applied yet if data are not preloaded. In\n this case it's the _projector attribute that does the job.\n If a private _data attribute is present then the projs applied\n to it are the ones marked as active.\n\n A proj parameter passed in constructor of raw or epochs calls\n apply_proj and hence after the .proj attribute is True.\n\n As soon as you've applied the projs it will stay active in the\n remaining pipeline.\n\n The suggested pipeline is proj=True in epochs (it's cheaper than for raw).\n\n When you use delayed SSP in Epochs, projs are applied when you call\n get_data() method. They are not applied to the evoked._data unless you call\n apply_proj(). The reason is that you want to reject with projs although\n it's not stored in proj mode.\n \"\"\"\n\n @property\n def proj(self):\n \"\"\"Whether or not projections are active.\"\"\"\n return (len(self.info['projs']) > 0 and\n all(p['active'] for p in self.info['projs']))\n\n @verbose\n def add_proj(self, projs, remove_existing=False, verbose=None):\n \"\"\"Add SSP projection vectors.\n\n Parameters\n ----------\n projs : list\n List with projection vectors.\n remove_existing : bool\n Remove the projection vectors currently in the file.\n verbose : bool, str, int, or None\n If not None, override default verbose level (see\n :func:`mne.verbose` and :ref:`Logging documentation <tut_logging>`\n for more).\n\n Returns\n -------\n self : instance of Raw | Epochs | Evoked\n The data container.\n \"\"\"\n if isinstance(projs, Projection):\n projs = [projs]\n\n if (not isinstance(projs, list) and\n not all(isinstance(p, Projection) for p in projs)):\n raise ValueError('Only projs can be added. You supplied '\n 'something else.')\n\n # mark proj as inactive, as they have not been applied\n projs = deactivate_proj(projs, copy=True, verbose=self.verbose)\n if remove_existing:\n # we cannot remove the proj if they are active\n if any(p['active'] for p in self.info['projs']):\n raise ValueError('Cannot remove projectors that have '\n 'already been applied')\n self.info['projs'] = projs\n else:\n self.info['projs'].extend(projs)\n # We don't want to add projectors that are activated again.\n self.info['projs'] = _uniquify_projs(self.info['projs'],\n check_active=False, sort=False)\n return self\n\n def apply_proj(self):\n \"\"\"Apply the signal space projection (SSP) operators to the data.\n\n Notes\n -----\n Once the projectors have been applied, they can no longer be\n removed. It is usually not recommended to apply the projectors at\n too early stages, as they are applied automatically later on\n (e.g. when computing inverse solutions).\n Hint: using the copy method individual projection vectors\n can be tested without affecting the original data.\n With evoked data, consider the following example::\n\n projs_a = mne.read_proj('proj_a.fif')\n projs_b = mne.read_proj('proj_b.fif')\n # add the first, copy, apply and see ...\n evoked.add_proj(a).copy().apply_proj().plot()\n # add the second, copy, apply and see ...\n evoked.add_proj(b).copy().apply_proj().plot()\n # drop the first and see again\n evoked.copy().del_proj(0).apply_proj().plot()\n evoked.apply_proj() # finally keep both\n\n Returns\n -------\n self : instance of Raw | Epochs | Evoked\n The instance.\n \"\"\"\n from ..epochs import BaseEpochs\n from ..evoked import Evoked\n from .base import BaseRaw\n if self.info['projs'] is None or len(self.info['projs']) == 0:\n logger.info('No projector specified for this dataset. '\n 'Please consider the method self.add_proj.')\n return self\n\n # Exit delayed mode if you apply proj\n if isinstance(self, BaseEpochs) and self._do_delayed_proj:\n logger.info('Leaving delayed SSP mode.')\n self._do_delayed_proj = False\n\n if all(p['active'] for p in self.info['projs']):\n logger.info('Projections have already been applied. '\n 'Setting proj attribute to True.')\n return self\n\n _projector, info = setup_proj(deepcopy(self.info), activate=True,\n verbose=self.verbose)\n # let's not raise a RuntimeError here, otherwise interactive plotting\n if _projector is None: # won't be fun.\n logger.info('The projections don\\'t apply to these data.'\n ' Doing nothing.')\n return self\n self._projector, self.info = _projector, info\n if isinstance(self, (BaseRaw, Evoked)):\n if self.preload:\n self._data = np.dot(self._projector, self._data)\n else: # BaseEpochs\n if self.preload:\n for ii, e in enumerate(self._data):\n self._data[ii] = self._project_epoch(e)\n else:\n self.load_data() # will automatically apply\n logger.info('SSP projectors applied...')\n return self\n\n def del_proj(self, idx='all'):\n \"\"\"Remove SSP projection vector.\n\n Note: The projection vector can only be removed if it is inactive\n (has not been applied to the data).\n\n Parameters\n ----------\n idx : int | list of int | str\n Index of the projector to remove. Can also be \"all\" (default)\n to remove all projectors.\n\n Returns\n -------\n self : instance of Raw | Epochs | Evoked\n \"\"\"\n if isinstance(idx, string_types) and idx == 'all':\n idx = list(range(len(self.info['projs'])))\n idx = np.atleast_1d(np.array(idx, int)).ravel()\n if any(self.info['projs'][ii]['active'] for ii in idx):\n raise ValueError('Cannot remove projectors that have already '\n 'been applied')\n self.info['projs'] = [p for pi, p in enumerate(self.info['projs'])\n if pi not in idx]\n return self\n\n def plot_projs_topomap(self, ch_type=None, layout=None, axes=None):\n \"\"\"Plot SSP vector.\n\n Parameters\n ----------\n ch_type : 'mag' | 'grad' | 'planar1' | 'planar2' | 'eeg' | None | List\n The channel type to plot. For 'grad', the gradiometers are collec-\n ted in pairs and the RMS for each pair is plotted. If None\n (default), it will return all channel types present. If a list of\n ch_types is provided, it will return multiple figures.\n layout : None | Layout | List of Layouts\n Layout instance specifying sensor positions (does not need to\n be specified for Neuromag data). If possible, the correct\n layout file is inferred from the data; if no appropriate layout\n file was found, the layout is automatically generated from the\n sensor locations. Or a list of Layout if projections\n are from different sensor types.\n axes : instance of Axes | list | None\n The axes to plot to. If list, the list must be a list of Axes of\n the same length as the number of projectors. If instance of Axes,\n there must be only one projector. Defaults to None.\n\n Returns\n -------\n fig : instance of matplotlib figure\n Figure distributing one image per channel across sensor topography.\n \"\"\"\n if self.info['projs'] is not None or len(self.info['projs']) != 0:\n from ..viz.topomap import plot_projs_topomap\n from ..channels.layout import find_layout\n if layout is None:\n layout = []\n if ch_type is None:\n ch_type = [ch for ch in ['meg', 'eeg'] if ch in self]\n elif isinstance(ch_type, string_types):\n ch_type = [ch_type]\n for ch in ch_type:\n if ch in self:\n layout.append(find_layout(self.info, ch, exclude=[]))\n else:\n warn('Channel type %s is not found in info.' % ch)\n fig = plot_projs_topomap(self.info['projs'], layout, axes=axes)\n else:\n raise ValueError(\"Info is missing projs. Nothing to plot.\")\n\n return fig\n\n\ndef _proj_equal(a, b, check_active=True):\n \"\"\"Test if two projectors are equal.\"\"\"\n equal = ((a['active'] == b['active'] or not check_active) and\n a['kind'] == b['kind'] and\n a['desc'] == b['desc'] and\n a['data']['col_names'] == b['data']['col_names'] and\n a['data']['row_names'] == b['data']['row_names'] and\n a['data']['ncol'] == b['data']['ncol'] and\n a['data']['nrow'] == b['data']['nrow'] and\n np.all(a['data']['data'] == b['data']['data']))\n return equal\n\n\n@verbose\ndef _read_proj(fid, node, verbose=None):\n \"\"\"Read spatial projections from a FIF file.\n\n Parameters\n ----------\n fid : file\n The file descriptor of the open file.\n node : tree node\n The node of the tree where to look.\n verbose : bool, str, int, or None\n If not None, override default verbose level (see :func:`mne.verbose`\n and :ref:`Logging documentation <tut_logging>` for more).\n\n Returns\n -------\n projs : list of Projection\n The list of projections.\n \"\"\"\n projs = list()\n\n # Locate the projection data\n nodes = dir_tree_find(node, FIFF.FIFFB_PROJ)\n if len(nodes) == 0:\n return projs\n\n tag = find_tag(fid, nodes[0], FIFF.FIFF_NCHAN)\n if tag is not None:\n global_nchan = int(tag.data)\n\n items = dir_tree_find(nodes[0], FIFF.FIFFB_PROJ_ITEM)\n for item in items:\n # Find all desired tags in one item\n tag = find_tag(fid, item, FIFF.FIFF_NCHAN)\n if tag is not None:\n nchan = int(tag.data)\n else:\n nchan = global_nchan\n\n tag = find_tag(fid, item, FIFF.FIFF_DESCRIPTION)\n if tag is not None:\n desc = tag.data\n else:\n tag = find_tag(fid, item, FIFF.FIFF_NAME)\n if tag is not None:\n desc = tag.data\n else:\n raise ValueError('Projection item description missing')\n\n # XXX : is this useful ?\n # tag = find_tag(fid, item, FIFF.FIFF_PROJ_ITEM_CH_NAME_LIST)\n # if tag is not None:\n # namelist = tag.data\n # else:\n # raise ValueError('Projection item channel list missing')\n\n tag = find_tag(fid, item, FIFF.FIFF_PROJ_ITEM_KIND)\n if tag is not None:\n kind = int(tag.data)\n else:\n raise ValueError('Projection item kind missing')\n\n tag = find_tag(fid, item, FIFF.FIFF_PROJ_ITEM_NVEC)\n if tag is not None:\n nvec = int(tag.data)\n else:\n raise ValueError('Number of projection vectors not specified')\n\n tag = find_tag(fid, item, FIFF.FIFF_PROJ_ITEM_CH_NAME_LIST)\n if tag is not None:\n names = tag.data.split(':')\n else:\n raise ValueError('Projection item channel list missing')\n\n tag = find_tag(fid, item, FIFF.FIFF_PROJ_ITEM_VECTORS)\n if tag is not None:\n data = tag.data\n else:\n raise ValueError('Projection item data missing')\n\n tag = find_tag(fid, item, FIFF.FIFF_MNE_PROJ_ITEM_ACTIVE)\n if tag is not None:\n active = bool(tag.data)\n else:\n active = False\n\n tag = find_tag(fid, item, FIFF.FIFF_MNE_ICA_PCA_EXPLAINED_VAR)\n if tag is not None:\n explained_var = tag.data\n else:\n explained_var = None\n\n # handle the case when data is transposed for some reason\n if data.shape[0] == len(names) and data.shape[1] == nvec:\n data = data.T\n\n if data.shape[1] != len(names):\n raise ValueError('Number of channel names does not match the '\n 'size of data matrix')\n\n # Use exactly the same fields in data as in a named matrix\n one = Projection(kind=kind, active=active, desc=desc,\n data=dict(nrow=nvec, ncol=nchan, row_names=None,\n col_names=names, data=data),\n explained_var=explained_var)\n\n projs.append(one)\n\n if len(projs) > 0:\n logger.info(' Read a total of %d projection items:' % len(projs))\n for k in range(len(projs)):\n if projs[k]['active']:\n misc = 'active'\n else:\n misc = ' idle'\n logger.info(' %s (%d x %d) %s'\n % (projs[k]['desc'], projs[k]['data']['nrow'],\n projs[k]['data']['ncol'], misc))\n\n return projs\n\n\n###############################################################################\n# Write\n\ndef _write_proj(fid, projs):\n \"\"\"Write a projection operator to a file.\n\n Parameters\n ----------\n fid : file\n The file descriptor of the open file.\n projs : dict\n The projection operator.\n \"\"\"\n if len(projs) == 0:\n return\n start_block(fid, FIFF.FIFFB_PROJ)\n\n for proj in projs:\n start_block(fid, FIFF.FIFFB_PROJ_ITEM)\n write_int(fid, FIFF.FIFF_NCHAN, proj['data']['ncol'])\n write_name_list(fid, FIFF.FIFF_PROJ_ITEM_CH_NAME_LIST,\n proj['data']['col_names'])\n write_string(fid, FIFF.FIFF_NAME, proj['desc'])\n write_int(fid, FIFF.FIFF_PROJ_ITEM_KIND, proj['kind'])\n if proj['kind'] == FIFF.FIFFV_PROJ_ITEM_FIELD:\n write_float(fid, FIFF.FIFF_PROJ_ITEM_TIME, 0.0)\n\n write_int(fid, FIFF.FIFF_PROJ_ITEM_NVEC, proj['data']['nrow'])\n write_int(fid, FIFF.FIFF_MNE_PROJ_ITEM_ACTIVE, proj['active'])\n write_float_matrix(fid, FIFF.FIFF_PROJ_ITEM_VECTORS,\n proj['data']['data'])\n if proj['explained_var'] is not None:\n write_float(fid, FIFF.FIFF_MNE_ICA_PCA_EXPLAINED_VAR,\n proj['explained_var'])\n end_block(fid, FIFF.FIFFB_PROJ_ITEM)\n\n end_block(fid, FIFF.FIFFB_PROJ)\n\n\n###############################################################################\n# Utils\n\ndef _check_projs(projs, copy=True):\n \"\"\"Check that projs is a list of Projection.\"\"\"\n if not isinstance(projs, (list, tuple)):\n raise TypeError('projs must be a list or tuple, got %s'\n % (type(projs),))\n for pi, p in enumerate(projs):\n if not isinstance(p, Projection):\n raise TypeError('All entries in projs list must be Projection '\n 'instances, but projs[%d] is type %s'\n % (pi, type(p)))\n return deepcopy(projs) if copy else projs\n\n\ndef make_projector(projs, ch_names, bads=(), include_active=True):\n \"\"\"Create an SSP operator from SSP projection vectors.\n\n Parameters\n ----------\n projs : list\n List of projection vectors.\n ch_names : list of str\n List of channels to include in the projection matrix.\n bads : list of str\n Some bad channels to exclude. If bad channels were marked\n in the raw file when projs were calculated using mne-python,\n they should not need to be included here as they will\n have been automatically omitted from the projectors.\n include_active : bool\n Also include projectors that are already active.\n\n Returns\n -------\n proj : array of shape [n_channels, n_channels]\n The projection operator to apply to the data.\n nproj : int\n How many items in the projector.\n U : array\n The orthogonal basis of the projection vectors (optional).\n \"\"\"\n return _make_projector(projs, ch_names, bads, include_active)\n\n\ndef _make_projector(projs, ch_names, bads=(), include_active=True,\n inplace=False):\n \"\"\"Subselect projs based on ch_names and bads.\n\n Use inplace=True mode to modify ``projs`` inplace so that no\n warning will be raised next time projectors are constructed with\n the given inputs. If inplace=True, no meaningful data are returned.\n \"\"\"\n nchan = len(ch_names)\n if nchan == 0:\n raise ValueError('No channel names specified')\n\n default_return = (np.eye(nchan, nchan), 0, [])\n\n # Check trivial cases first\n if projs is None:\n return default_return\n\n nvec = 0\n nproj = 0\n for p in projs:\n if not p['active'] or include_active:\n nproj += 1\n nvec += p['data']['nrow']\n\n if nproj == 0:\n return default_return\n\n # Pick the appropriate entries\n vecs = np.zeros((nchan, nvec))\n nvec = 0\n nonzero = 0\n bads = set(bads)\n for k, p in enumerate(projs):\n if not p['active'] or include_active:\n if (len(p['data']['col_names']) !=\n len(np.unique(p['data']['col_names']))):\n raise ValueError('Channel name list in projection item %d'\n ' contains duplicate items' % k)\n\n # Get the two selection vectors to pick correct elements from\n # the projection vectors omitting bad channels\n sel = []\n vecsel = []\n p_set = set(p['data']['col_names']) # faster membership access\n for c, name in enumerate(ch_names):\n if name not in bads and name in p_set:\n sel.append(c)\n vecsel.append(p['data']['col_names'].index(name))\n\n # If there is something to pick, pickit\n nrow = p['data']['nrow']\n this_vecs = vecs[:, nvec:nvec + nrow]\n if len(sel) > 0:\n this_vecs[sel] = p['data']['data'][:, vecsel].T\n\n # Rescale for better detection of small singular values\n for v in range(p['data']['nrow']):\n psize = sqrt(np.sum(this_vecs[:, v] * this_vecs[:, v]))\n if psize > 0:\n orig_n = p['data']['data'].any(axis=0).sum()\n # Average ref still works if channels are removed\n if len(vecsel) < 0.9 * orig_n and not inplace and \\\n (p['kind'] != FIFF.FIFFV_MNE_PROJ_ITEM_EEG_AVREF or\n len(vecsel) == 1):\n warn('Projection vector \"%s\" has magnitude %0.2f '\n '(should be unity), applying projector with '\n '%s/%s of the original channels available may '\n 'be dangerous, consider recomputing and adding '\n 'projection vectors for channels that are '\n 'eventually used. If this is intentional, '\n 'consider using info.normalize_proj()'\n % (p['desc'], psize, len(vecsel), orig_n))\n this_vecs[:, v] /= psize\n nonzero += 1\n # If doing \"inplace\" mode, \"fix\" the projectors to only operate\n # on this subset of channels.\n if inplace:\n p['data']['data'] = this_vecs[sel].T\n p['data']['col_names'] = [p['data']['col_names'][ii]\n for ii in vecsel]\n nvec += p['data']['nrow']\n\n # Check whether all of the vectors are exactly zero\n if nonzero == 0 or inplace:\n return default_return\n\n # Reorthogonalize the vectors\n U, S, V = linalg.svd(vecs[:, :nvec], full_matrices=False)\n\n # Throw away the linearly dependent guys\n nproj = np.sum((S / S[0]) > 1e-2)\n U = U[:, :nproj]\n\n # Here is the celebrated result\n proj = np.eye(nchan, nchan) - np.dot(U, U.T)\n\n return proj, nproj, U\n\n\ndef _normalize_proj(info):\n \"\"\"Normalize proj after subselection to avoid warnings.\n\n This is really only useful for tests, and might not be needed\n eventually if we change or improve our handling of projectors\n with picks.\n \"\"\"\n # Here we do info.get b/c info can actually be a noise cov\n _make_projector(info['projs'], info.get('ch_names', info.get('names')),\n info['bads'], include_active=True, inplace=True)\n\n\ndef make_projector_info(info, include_active=True):\n \"\"\"Make an SSP operator using the measurement info.\n\n Calls make_projector on good channels.\n\n Parameters\n ----------\n info : dict\n Measurement info.\n include_active : bool\n Also include projectors that are already active.\n\n Returns\n -------\n proj : array of shape [n_channels, n_channels]\n The projection operator to apply to the data.\n nproj : int\n How many items in the projector.\n \"\"\"\n proj, nproj, _ = make_projector(info['projs'], info['ch_names'],\n info['bads'], include_active)\n return proj, nproj\n\n\n@verbose\ndef activate_proj(projs, copy=True, verbose=None):\n \"\"\"Set all projections to active.\n\n Useful before passing them to make_projector.\n\n Parameters\n ----------\n projs : list\n The projectors.\n copy : bool\n Modify projs in place or operate on a copy.\n verbose : bool, str, int, or None\n If not None, override default verbose level (see :func:`mne.verbose`\n and :ref:`Logging documentation <tut_logging>` for more).\n\n Returns\n -------\n projs : list\n The projectors.\n \"\"\"\n if copy:\n projs = deepcopy(projs)\n\n # Activate the projection items\n for proj in projs:\n proj['active'] = True\n\n logger.info('%d projection items activated' % len(projs))\n\n return projs\n\n\n@verbose\ndef deactivate_proj(projs, copy=True, verbose=None):\n \"\"\"Set all projections to inactive.\n\n Useful before saving raw data without projectors applied.\n\n Parameters\n ----------\n projs : list\n The projectors.\n copy : bool\n Modify projs in place or operate on a copy.\n verbose : bool, str, int, or None\n If not None, override default verbose level (see :func:`mne.verbose`\n and :ref:`Logging documentation <tut_logging>` for more).\n\n Returns\n -------\n projs : list\n The projectors.\n \"\"\"\n if copy:\n projs = deepcopy(projs)\n\n # Deactivate the projection items\n for proj in projs:\n proj['active'] = False\n\n logger.info('%d projection items deactivated' % len(projs))\n\n return projs\n\n\n@verbose\ndef make_eeg_average_ref_proj(info, activate=True, verbose=None):\n \"\"\"Create an EEG average reference SSP projection vector.\n\n Parameters\n ----------\n info : dict\n Measurement info.\n activate : bool\n If True projections are activated.\n verbose : bool, str, int, or None\n If not None, override default verbose level (see :func:`mne.verbose`\n and :ref:`Logging documentation <tut_logging>` for more).\n\n Returns\n -------\n eeg_proj: instance of Projection\n The SSP/PCA projector.\n \"\"\"\n if info.get('custom_ref_applied', False):\n raise RuntimeError('A custom reference has been applied to the '\n 'data earlier. Please use the '\n 'mne.io.set_eeg_reference function to move from '\n 'one EEG reference to another.')\n\n logger.info(\"Adding average EEG reference projection.\")\n eeg_sel = pick_types(info, meg=False, eeg=True, ref_meg=False,\n exclude='bads')\n ch_names = info['ch_names']\n eeg_names = [ch_names[k] for k in eeg_sel]\n n_eeg = len(eeg_sel)\n if n_eeg == 0:\n raise ValueError('Cannot create EEG average reference projector '\n '(no EEG data found)')\n vec = np.ones((1, n_eeg))\n vec /= n_eeg\n explained_var = None\n eeg_proj_data = dict(col_names=eeg_names, row_names=None,\n data=vec, nrow=1, ncol=n_eeg)\n eeg_proj = Projection(active=activate, data=eeg_proj_data,\n desc='Average EEG reference',\n kind=FIFF.FIFFV_MNE_PROJ_ITEM_EEG_AVREF,\n explained_var=explained_var)\n return eeg_proj\n\n\ndef _has_eeg_average_ref_proj(projs, check_active=False):\n \"\"\"Determine if a list of projectors has an average EEG ref.\n\n Optionally, set check_active=True to additionally check if the CAR\n has already been applied.\n \"\"\"\n for proj in projs:\n if (proj['desc'] == 'Average EEG reference' or\n proj['kind'] == FIFF.FIFFV_MNE_PROJ_ITEM_EEG_AVREF):\n if not check_active or proj['active']:\n return True\n return False\n\n\ndef _needs_eeg_average_ref_proj(info):\n \"\"\"Determine if the EEG needs an averge EEG reference.\n\n This returns True if no custom reference has been applied and no average\n reference projection is present in the list of projections.\n \"\"\"\n eeg_sel = pick_types(info, meg=False, eeg=True, ref_meg=False,\n exclude='bads')\n return (len(eeg_sel) > 0 and\n not info['custom_ref_applied'] and\n not _has_eeg_average_ref_proj(info['projs']))\n\n\n@verbose\ndef setup_proj(info, add_eeg_ref=True, activate=True, verbose=None):\n \"\"\"Set up projection for Raw and Epochs.\n\n Parameters\n ----------\n info : dict\n The measurement info.\n add_eeg_ref : bool\n If True, an EEG average reference will be added (unless one\n already exists).\n activate : bool\n If True projections are activated.\n verbose : bool, str, int, or None\n If not None, override default verbose level (see :func:`mne.verbose`\n and :ref:`Logging documentation <tut_logging>` for more).\n\n Returns\n -------\n projector : array of shape [n_channels, n_channels]\n The projection operator to apply to the data.\n info : dict\n The modified measurement info (Warning: info is modified inplace).\n \"\"\"\n # Add EEG ref reference proj if necessary\n if add_eeg_ref and _needs_eeg_average_ref_proj(info):\n eeg_proj = make_eeg_average_ref_proj(info, activate=activate)\n info['projs'].append(eeg_proj)\n\n # Create the projector\n projector, nproj = make_projector_info(info)\n if nproj == 0:\n if verbose:\n logger.info('The projection vectors do not apply to these '\n 'channels')\n projector = None\n else:\n logger.info('Created an SSP operator (subspace dimension = %d)'\n % nproj)\n\n # The projection items have been activated\n if activate:\n info['projs'] = activate_proj(info['projs'], copy=False)\n\n return projector, info\n\n\ndef _uniquify_projs(projs, check_active=True, sort=True):\n \"\"\"Make unique projs.\"\"\"\n final_projs = []\n for proj in projs: # flatten\n if not any(_proj_equal(p, proj, check_active) for p in final_projs):\n final_projs.append(proj)\n\n my_count = count(len(final_projs))\n\n def sorter(x):\n \"\"\"Sort in a nice way.\"\"\"\n digits = [s for s in x['desc'] if s.isdigit()]\n if digits:\n sort_idx = int(digits[-1])\n else:\n sort_idx = next(my_count)\n return (sort_idx, x['desc'])\n\n return sorted(final_projs, key=sorter) if sort else final_projs\n",
"\"\"\"\n=================================================\nCompare evoked responses for different conditions\n=================================================\n\nIn this example, an Epochs object for visual and\nauditory responses is created. Both conditions\nare then accessed by their respective names to\ncreate a sensor layout plot of the related\nevoked responses.\n\n\"\"\"\n\n# Authors: Denis Engemann <[email protected]>\n# Alexandre Gramfort <[email protected]>\n\n# License: BSD (3-clause)\n\n\nimport matplotlib.pyplot as plt\nimport mne\n\nfrom mne.viz import plot_evoked_topo\nfrom mne.datasets import sample\n\nprint(__doc__)\n\ndata_path = sample.data_path()\n\n###############################################################################\n# Set parameters\nraw_fname = data_path + '/MEG/sample/sample_audvis_filt-0-40_raw.fif'\nevent_fname = data_path + '/MEG/sample/sample_audvis_filt-0-40_raw-eve.fif'\nevent_id = 1\ntmin = -0.2\ntmax = 0.5\n\n# Setup for reading the raw data\nraw = mne.io.read_raw_fif(raw_fname)\nevents = mne.read_events(event_fname)\n\n# Set up pick list: MEG + STI 014 - bad channels (modify to your needs)\ninclude = [] # or stim channels ['STI 014']\n# bad channels in raw.info['bads'] will be automatically excluded\n\n# Set up amplitude-peak rejection values for MEG channels\nreject = dict(grad=4000e-13, mag=4e-12)\n\n# pick MEG channels\npicks = mne.pick_types(raw.info, meg=True, eeg=False, stim=False, eog=True,\n include=include, exclude='bads')\n\n# Create epochs including different events\nevent_id = {'audio/left': 1, 'audio/right': 2,\n 'visual/left': 3, 'visual/right': 4}\nepochs = mne.Epochs(raw, events, event_id, tmin, tmax,\n picks=picks, baseline=(None, 0), reject=reject)\n\n# Generate list of evoked objects from conditions names\nevokeds = [epochs[name].average() for name in ('left', 'right')]\n\n###############################################################################\n# Show topography for two different conditions\n\ncolors = 'blue', 'red'\ntitle = 'MNE sample data\\nleft vs right (A/V combined)'\n\nplot_evoked_topo(evokeds, color=colors, title=title, background_color='w')\n\nplt.show()\n",
"# Author: Mark Wronkiewicz <[email protected]>\n#\n# License: BSD (3-clause)\n\nimport os.path as op\nimport warnings\nimport numpy as np\n\nfrom numpy.testing import assert_equal, assert_allclose\nfrom nose.tools import assert_true, assert_raises\n\nfrom mne import compute_raw_covariance, pick_types\nfrom mne.chpi import read_head_pos, filter_chpi\nfrom mne.forward import _prep_meg_channels\nfrom mne.cov import _estimate_rank_meeg_cov\nfrom mne.datasets import testing\nfrom mne.io import (read_raw_fif, proc_history, read_info, read_raw_bti,\n read_raw_kit, BaseRaw)\nfrom mne.preprocessing.maxwell import (\n maxwell_filter, _get_n_moments, _sss_basis_basic, _sh_complex_to_real,\n _sh_real_to_complex, _sh_negate, _bases_complex_to_real, _trans_sss_basis,\n _bases_real_to_complex, _prep_mf_coils)\nfrom mne.fixes import _get_sph_harm\nfrom mne.tests.common import assert_meg_snr\nfrom mne.utils import (_TempDir, run_tests_if_main, slow_test, catch_logging,\n requires_version, object_diff, buggy_mkl_svd)\n\nwarnings.simplefilter('always') # Always throw warnings\n\ndata_path = testing.data_path(download=False)\nsss_path = op.join(data_path, 'SSS')\npre = op.join(sss_path, 'test_move_anon_')\nraw_fname = pre + 'raw.fif'\nsss_std_fname = pre + 'stdOrigin_raw_sss.fif'\nsss_nonstd_fname = pre + 'nonStdOrigin_raw_sss.fif'\nsss_bad_recon_fname = pre + 'badRecon_raw_sss.fif'\nsss_reg_in_fname = pre + 'regIn_raw_sss.fif'\nsss_fine_cal_fname = pre + 'fineCal_raw_sss.fif'\nsss_ctc_fname = pre + 'crossTalk_raw_sss.fif'\nsss_trans_default_fname = pre + 'transDefault_raw_sss.fif'\nsss_trans_sample_fname = pre + 'transSample_raw_sss.fif'\nsss_st1FineCalCrossTalkRegIn_fname = \\\n pre + 'st1FineCalCrossTalkRegIn_raw_sss.fif'\nsss_st1FineCalCrossTalkRegInTransSample_fname = \\\n pre + 'st1FineCalCrossTalkRegInTransSample_raw_sss.fif'\nsss_movecomp_fname = pre + 'movecomp_raw_sss.fif'\nsss_movecomp_reg_in_fname = pre + 'movecomp_regIn_raw_sss.fif'\nsss_movecomp_reg_in_st4s_fname = pre + 'movecomp_regIn_st4s_raw_sss.fif'\n\nerm_fname = pre + 'erm_raw.fif'\nsss_erm_std_fname = pre + 'erm_devOrigin_raw_sss.fif'\nsss_erm_reg_in_fname = pre + 'erm_regIn_raw_sss.fif'\nsss_erm_fine_cal_fname = pre + 'erm_fineCal_raw_sss.fif'\nsss_erm_ctc_fname = pre + 'erm_crossTalk_raw_sss.fif'\nsss_erm_st_fname = pre + 'erm_st1_raw_sss.fif'\nsss_erm_st1FineCalCrossTalk_fname = pre + 'erm_st1FineCalCrossTalk_raw_sss.fif'\nsss_erm_st1FineCalCrossTalkRegIn_fname = \\\n pre + 'erm_st1FineCalCrossTalkRegIn_raw_sss.fif'\n\nsample_fname = op.join(data_path, 'MEG', 'sample_audvis_trunc_raw.fif')\nsss_samp_reg_in_fname = op.join(data_path, 'SSS',\n 'sample_audvis_trunc_regIn_raw_sss.fif')\nsss_samp_fname = op.join(data_path, 'SSS', 'sample_audvis_trunc_raw_sss.fif')\n\npos_fname = op.join(data_path, 'SSS', 'test_move_anon_raw.pos')\n\nbases_fname = op.join(sss_path, 'sss_data.mat')\nfine_cal_fname = op.join(sss_path, 'sss_cal_3053.dat')\nfine_cal_fname_3d = op.join(sss_path, 'sss_cal_3053_3d.dat')\nctc_fname = op.join(sss_path, 'ct_sparse.fif')\nfine_cal_mgh_fname = op.join(sss_path, 'sss_cal_mgh.dat')\nctc_mgh_fname = op.join(sss_path, 'ct_sparse_mgh.fif')\n\nsample_fname = op.join(data_path, 'MEG', 'sample',\n 'sample_audvis_trunc_raw.fif')\n\ntriux_path = op.join(data_path, 'SSS', 'TRIUX')\ntri_fname = op.join(triux_path, 'triux_bmlhus_erm_raw.fif')\ntri_sss_fname = op.join(triux_path, 'triux_bmlhus_erm_raw_sss.fif')\ntri_sss_reg_fname = op.join(triux_path, 'triux_bmlhus_erm_regIn_raw_sss.fif')\ntri_sss_st4_fname = op.join(triux_path, 'triux_bmlhus_erm_st4_raw_sss.fif')\ntri_sss_ctc_fname = op.join(triux_path, 'triux_bmlhus_erm_ctc_raw_sss.fif')\ntri_sss_cal_fname = op.join(triux_path, 'triux_bmlhus_erm_cal_raw_sss.fif')\ntri_sss_ctc_cal_fname = op.join(\n triux_path, 'triux_bmlhus_erm_ctc_cal_raw_sss.fif')\ntri_sss_ctc_cal_reg_in_fname = op.join(\n triux_path, 'triux_bmlhus_erm_ctc_cal_regIn_raw_sss.fif')\ntri_ctc_fname = op.join(triux_path, 'ct_sparse_BMLHUS.fif')\ntri_cal_fname = op.join(triux_path, 'sss_cal_BMLHUS.dat')\n\nio_dir = op.join(op.dirname(__file__), '..', '..', 'io')\nfname_ctf_raw = op.join(io_dir, 'tests', 'data', 'test_ctf_comp_raw.fif')\n\nint_order, ext_order = 8, 3\nmf_head_origin = (0., 0., 0.04)\nmf_meg_origin = (0., 0.013, -0.006)\n\n# otherwise we can get SVD error\nrequires_svd_convergence = requires_version('scipy', '0.12')\n\n# 30 random bad MEG channels (20 grad, 10 mag) that were used in generation\nbads = ['MEG0912', 'MEG1722', 'MEG2213', 'MEG0132', 'MEG1312', 'MEG0432',\n 'MEG2433', 'MEG1022', 'MEG0442', 'MEG2332', 'MEG0633', 'MEG1043',\n 'MEG1713', 'MEG0422', 'MEG0932', 'MEG1622', 'MEG1343', 'MEG0943',\n 'MEG0643', 'MEG0143', 'MEG2142', 'MEG0813', 'MEG2143', 'MEG1323',\n 'MEG0522', 'MEG1123', 'MEG0423', 'MEG2122', 'MEG2532', 'MEG0812']\n\n\ndef _assert_n_free(raw_sss, lower, upper=None):\n \"\"\"Check the DOF.\"\"\"\n upper = lower if upper is None else upper\n n_free = raw_sss.info['proc_history'][0]['max_info']['sss_info']['nfree']\n assert_true(lower <= n_free <= upper,\n 'nfree fail: %s <= %s <= %s' % (lower, n_free, upper))\n\n\ndef read_crop(fname, lims=(0, None)):\n \"\"\"Read and crop.\"\"\"\n return read_raw_fif(fname, allow_maxshield='yes').crop(*lims)\n\n\n@slow_test\[email protected]_testing_data\ndef test_movement_compensation():\n \"\"\"Test movement compensation.\"\"\"\n temp_dir = _TempDir()\n lims = (0, 4)\n raw = read_crop(raw_fname, lims).load_data()\n head_pos = read_head_pos(pos_fname)\n\n #\n # Movement compensation, no regularization, no tSSS\n #\n raw_sss = maxwell_filter(raw, head_pos=head_pos, origin=mf_head_origin,\n regularize=None, bad_condition='ignore')\n assert_meg_snr(raw_sss, read_crop(sss_movecomp_fname, lims),\n 4.6, 12.4, chpi_med_tol=58)\n # IO\n temp_fname = op.join(temp_dir, 'test_raw_sss.fif')\n raw_sss.save(temp_fname)\n raw_sss = read_crop(temp_fname)\n assert_meg_snr(raw_sss, read_crop(sss_movecomp_fname, lims),\n 4.6, 12.4, chpi_med_tol=58)\n\n #\n # Movement compensation, regularization, no tSSS\n #\n raw_sss = maxwell_filter(raw, head_pos=head_pos, origin=mf_head_origin)\n assert_meg_snr(raw_sss, read_crop(sss_movecomp_reg_in_fname, lims),\n 0.5, 1.9, chpi_med_tol=121)\n\n #\n # Movement compensation, regularization, tSSS at the end\n #\n raw_nohpi = filter_chpi(raw.copy())\n with warnings.catch_warnings(record=True) as w: # untested feature\n raw_sss_mv = maxwell_filter(raw_nohpi, head_pos=head_pos,\n st_duration=4., origin=mf_head_origin,\n st_fixed=False)\n assert_equal(len(w), 1)\n assert_true('is untested' in str(w[0].message))\n # Neither match is particularly good because our algorithm actually differs\n assert_meg_snr(raw_sss_mv, read_crop(sss_movecomp_reg_in_st4s_fname, lims),\n 0.6, 1.3)\n tSSS_fname = op.join(sss_path, 'test_move_anon_st4s_raw_sss.fif')\n assert_meg_snr(raw_sss_mv, read_crop(tSSS_fname, lims),\n 0.6, 1.0, chpi_med_tol=None)\n assert_meg_snr(read_crop(sss_movecomp_reg_in_st4s_fname),\n read_crop(tSSS_fname), 0.8, 1.0, chpi_med_tol=None)\n\n #\n # Movement compensation, regularization, tSSS at the beginning\n #\n raw_sss_mc = maxwell_filter(raw_nohpi, head_pos=head_pos, st_duration=4.,\n origin=mf_head_origin)\n assert_meg_snr(raw_sss_mc, read_crop(tSSS_fname, lims),\n 0.6, 1.0, chpi_med_tol=None)\n assert_meg_snr(raw_sss_mc, raw_sss_mv, 0.6, 1.4)\n\n # some degenerate cases\n raw_erm = read_crop(erm_fname)\n assert_raises(ValueError, maxwell_filter, raw_erm, coord_frame='meg',\n head_pos=head_pos) # can't do ERM file\n assert_raises(ValueError, maxwell_filter, raw,\n head_pos=head_pos[:, :9]) # bad shape\n assert_raises(TypeError, maxwell_filter, raw, head_pos='foo') # bad type\n assert_raises(ValueError, maxwell_filter, raw, head_pos=head_pos[::-1])\n head_pos_bad = head_pos.copy()\n head_pos_bad[0, 0] = raw.first_samp / raw.info['sfreq'] - 1e-2\n assert_raises(ValueError, maxwell_filter, raw, head_pos=head_pos_bad)\n\n head_pos_bad = head_pos.copy()\n head_pos_bad[0, 4] = 1. # off by more than 1 m\n with warnings.catch_warnings(record=True) as w:\n maxwell_filter(raw.copy().crop(0, 0.1), head_pos=head_pos_bad,\n bad_condition='ignore')\n assert_true(any('greater than 1 m' in str(ww.message) for ww in w))\n\n # make sure numerical error doesn't screw it up, though\n head_pos_bad = head_pos.copy()\n head_pos_bad[0, 0] = raw.first_samp / raw.info['sfreq'] - 5e-4\n raw_sss_tweak = maxwell_filter(\n raw.copy().crop(0, 0.05), head_pos=head_pos_bad, origin=mf_head_origin)\n assert_meg_snr(raw_sss_tweak, raw_sss.copy().crop(0, 0.05), 1.4, 8.,\n chpi_med_tol=5)\n\n\n@slow_test\ndef test_other_systems():\n \"\"\"Test Maxwell filtering on KIT, BTI, and CTF files.\"\"\"\n # KIT\n kit_dir = op.join(io_dir, 'kit', 'tests', 'data')\n sqd_path = op.join(kit_dir, 'test.sqd')\n mrk_path = op.join(kit_dir, 'test_mrk.sqd')\n elp_path = op.join(kit_dir, 'test_elp.txt')\n hsp_path = op.join(kit_dir, 'test_hsp.txt')\n raw_kit = read_raw_kit(sqd_path, mrk_path, elp_path, hsp_path)\n with warnings.catch_warnings(record=True): # head fit\n assert_raises(RuntimeError, maxwell_filter, raw_kit)\n raw_sss = maxwell_filter(raw_kit, origin=(0., 0., 0.04), ignore_ref=True)\n _assert_n_free(raw_sss, 65, 65)\n raw_sss_auto = maxwell_filter(raw_kit, origin=(0., 0., 0.04),\n ignore_ref=True, mag_scale='auto')\n assert_allclose(raw_sss._data, raw_sss_auto._data)\n # XXX this KIT origin fit is terrible! Eventually we should get a\n # corrected HSP file with proper coverage\n with warnings.catch_warnings(record=True):\n with catch_logging() as log_file:\n assert_raises(RuntimeError, maxwell_filter, raw_kit,\n ignore_ref=True, regularize=None) # bad condition\n raw_sss = maxwell_filter(raw_kit, origin='auto',\n ignore_ref=True, bad_condition='warning',\n verbose='warning')\n log_file = log_file.getvalue()\n assert_true('badly conditioned' in log_file)\n assert_true('more than 20 mm from' in log_file)\n # fits can differ slightly based on scipy version, so be lenient here\n _assert_n_free(raw_sss, 28, 34) # bad origin == brutal reg\n # Let's set the origin\n with warnings.catch_warnings(record=True):\n with catch_logging() as log_file:\n raw_sss = maxwell_filter(raw_kit, origin=(0., 0., 0.04),\n ignore_ref=True, bad_condition='warning',\n regularize=None, verbose='warning')\n log_file = log_file.getvalue()\n assert_true('badly conditioned' in log_file)\n _assert_n_free(raw_sss, 80)\n # Now with reg\n with warnings.catch_warnings(record=True):\n with catch_logging() as log_file:\n raw_sss = maxwell_filter(raw_kit, origin=(0., 0., 0.04),\n ignore_ref=True, verbose=True)\n log_file = log_file.getvalue()\n assert_true('badly conditioned' not in log_file)\n _assert_n_free(raw_sss, 65)\n\n # BTi\n bti_dir = op.join(io_dir, 'bti', 'tests', 'data')\n bti_pdf = op.join(bti_dir, 'test_pdf_linux')\n bti_config = op.join(bti_dir, 'test_config_linux')\n bti_hs = op.join(bti_dir, 'test_hs_linux')\n with warnings.catch_warnings(record=True): # weght table\n raw_bti = read_raw_bti(bti_pdf, bti_config, bti_hs, preload=False)\n picks = pick_types(raw_bti.info, meg='mag', exclude=())\n power = np.sqrt(np.sum(raw_bti[picks][0] ** 2))\n raw_sss = maxwell_filter(raw_bti)\n _assert_n_free(raw_sss, 70)\n _assert_shielding(raw_sss, power, 0.5)\n raw_sss_auto = maxwell_filter(raw_bti, mag_scale='auto', verbose=True)\n _assert_shielding(raw_sss_auto, power, 0.7)\n\n # CTF\n raw_ctf = read_crop(fname_ctf_raw)\n assert_equal(raw_ctf.compensation_grade, 3)\n assert_raises(RuntimeError, maxwell_filter, raw_ctf) # compensated\n raw_ctf.apply_gradient_compensation(0)\n assert_raises(ValueError, maxwell_filter, raw_ctf) # cannot fit headshape\n raw_sss = maxwell_filter(raw_ctf, origin=(0., 0., 0.04))\n _assert_n_free(raw_sss, 68)\n _assert_shielding(raw_sss, raw_ctf, 1.8)\n raw_sss = maxwell_filter(raw_ctf, origin=(0., 0., 0.04), ignore_ref=True)\n _assert_n_free(raw_sss, 70)\n _assert_shielding(raw_sss, raw_ctf, 12)\n raw_sss_auto = maxwell_filter(raw_ctf, origin=(0., 0., 0.04),\n ignore_ref=True, mag_scale='auto')\n assert_allclose(raw_sss._data, raw_sss_auto._data)\n\n\ndef test_spherical_conversions():\n \"\"\"Test spherical harmonic conversions.\"\"\"\n # Test our real<->complex conversion functions\n az, pol = np.meshgrid(np.linspace(0, 2 * np.pi, 30),\n np.linspace(0, np.pi, 20))\n for degree in range(1, int_order):\n for order in range(0, degree + 1):\n sph = _get_sph_harm()(order, degree, az, pol)\n # ensure that we satisfy the conjugation property\n assert_allclose(_sh_negate(sph, order),\n _get_sph_harm()(-order, degree, az, pol))\n # ensure our conversion functions work\n sph_real_pos = _sh_complex_to_real(sph, order)\n sph_real_neg = _sh_complex_to_real(sph, -order)\n sph_2 = _sh_real_to_complex([sph_real_pos, sph_real_neg], order)\n assert_allclose(sph, sph_2, atol=1e-7)\n\n\[email protected]_testing_data\ndef test_multipolar_bases():\n \"\"\"Test multipolar moment basis calculation using sensor information.\"\"\"\n from scipy.io import loadmat\n # Test our basis calculations\n info = read_info(raw_fname)\n coils = _prep_meg_channels(info, accurate=True, elekta_defs=True,\n do_es=True)[0]\n # Check against a known benchmark\n sss_data = loadmat(bases_fname)\n exp = dict(int_order=int_order, ext_order=ext_order)\n for origin in ((0, 0, 0.04), (0, 0.02, 0.02)):\n o_str = ''.join('%d' % (1000 * n) for n in origin)\n exp.update(origin=origin)\n S_tot = _sss_basis_basic(exp, coils, method='alternative')\n # Test our real<->complex conversion functions\n S_tot_complex = _bases_real_to_complex(S_tot, int_order, ext_order)\n S_tot_round = _bases_complex_to_real(S_tot_complex,\n int_order, ext_order)\n assert_allclose(S_tot, S_tot_round, atol=1e-7)\n\n S_tot_mat = np.concatenate([sss_data['Sin' + o_str],\n sss_data['Sout' + o_str]], axis=1)\n S_tot_mat_real = _bases_complex_to_real(S_tot_mat,\n int_order, ext_order)\n S_tot_mat_round = _bases_real_to_complex(S_tot_mat_real,\n int_order, ext_order)\n assert_allclose(S_tot_mat, S_tot_mat_round, atol=1e-7)\n assert_allclose(S_tot_complex, S_tot_mat, rtol=1e-4, atol=1e-8)\n assert_allclose(S_tot, S_tot_mat_real, rtol=1e-4, atol=1e-8)\n\n # Now normalize our columns\n S_tot /= np.sqrt(np.sum(S_tot * S_tot, axis=0))[np.newaxis]\n S_tot_complex /= np.sqrt(np.sum(\n (S_tot_complex * S_tot_complex.conj()).real, axis=0))[np.newaxis]\n # Check against a known benchmark\n S_tot_mat = np.concatenate([sss_data['SNin' + o_str],\n sss_data['SNout' + o_str]], axis=1)\n # Check this roundtrip\n S_tot_mat_real = _bases_complex_to_real(S_tot_mat,\n int_order, ext_order)\n S_tot_mat_round = _bases_real_to_complex(S_tot_mat_real,\n int_order, ext_order)\n assert_allclose(S_tot_mat, S_tot_mat_round, atol=1e-7)\n assert_allclose(S_tot_complex, S_tot_mat, rtol=1e-4, atol=1e-8)\n\n # Now test our optimized version\n S_tot = _sss_basis_basic(exp, coils)\n S_tot_fast = _trans_sss_basis(\n exp, all_coils=_prep_mf_coils(info), trans=info['dev_head_t'])\n # there are some sign differences for columns (order/degrees)\n # in here, likely due to Condon-Shortley. Here we use a\n # Magnetometer channel to figure out the flips because the\n # gradiometer channels have effectively zero values for first three\n # external components (i.e., S_tot[grad_picks, 80:83])\n flips = (np.sign(S_tot_fast[2]) != np.sign(S_tot[2]))\n flips = 1 - 2 * flips\n assert_allclose(S_tot, S_tot_fast * flips, atol=1e-16)\n\n\[email protected]_testing_data\ndef test_basic():\n \"\"\"Test Maxwell filter basic version.\"\"\"\n # Load testing data (raw, SSS std origin, SSS non-standard origin)\n raw = read_crop(raw_fname, (0., 1.))\n raw_err = read_crop(raw_fname).apply_proj()\n raw_erm = read_crop(erm_fname)\n assert_raises(RuntimeError, maxwell_filter, raw_err)\n assert_raises(TypeError, maxwell_filter, 1.) # not a raw\n assert_raises(ValueError, maxwell_filter, raw, int_order=20) # too many\n\n n_int_bases = int_order ** 2 + 2 * int_order\n n_ext_bases = ext_order ** 2 + 2 * ext_order\n nbases = n_int_bases + n_ext_bases\n\n # Check number of bases computed correctly\n assert_equal(_get_n_moments([int_order, ext_order]).sum(), nbases)\n\n # Test SSS computation at the standard head origin\n assert_equal(len(raw.info['projs']), 12) # 11 MEG projs + 1 AVG EEG\n raw_sss = maxwell_filter(raw, origin=mf_head_origin, regularize=None,\n bad_condition='ignore')\n assert_equal(len(raw_sss.info['projs']), 1) # avg EEG\n assert_equal(raw_sss.info['projs'][0]['desc'], 'Average EEG reference')\n assert_meg_snr(raw_sss, read_crop(sss_std_fname), 200., 1000.)\n py_cal = raw_sss.info['proc_history'][0]['max_info']['sss_cal']\n assert_equal(len(py_cal), 0)\n py_ctc = raw_sss.info['proc_history'][0]['max_info']['sss_ctc']\n assert_equal(len(py_ctc), 0)\n py_st = raw_sss.info['proc_history'][0]['max_info']['max_st']\n assert_equal(len(py_st), 0)\n assert_raises(RuntimeError, maxwell_filter, raw_sss)\n\n # Test SSS computation at non-standard head origin\n raw_sss = maxwell_filter(raw, origin=[0., 0.02, 0.02], regularize=None,\n bad_condition='ignore')\n assert_meg_snr(raw_sss, read_crop(sss_nonstd_fname), 250., 700.)\n\n # Test SSS computation at device origin\n sss_erm_std = read_crop(sss_erm_std_fname)\n raw_sss = maxwell_filter(raw_erm, coord_frame='meg',\n origin=mf_meg_origin, regularize=None,\n bad_condition='ignore')\n assert_meg_snr(raw_sss, sss_erm_std, 100., 900.)\n for key in ('job', 'frame'):\n vals = [x.info['proc_history'][0]['max_info']['sss_info'][key]\n for x in [raw_sss, sss_erm_std]]\n assert_equal(vals[0], vals[1])\n\n # Check against SSS functions from proc_history\n sss_info = raw_sss.info['proc_history'][0]['max_info']\n assert_equal(_get_n_moments(int_order),\n proc_history._get_sss_rank(sss_info))\n\n # Degenerate cases\n assert_raises(ValueError, maxwell_filter, raw, coord_frame='foo')\n assert_raises(ValueError, maxwell_filter, raw, origin='foo')\n assert_raises(ValueError, maxwell_filter, raw, origin=[0] * 4)\n assert_raises(ValueError, maxwell_filter, raw, mag_scale='foo')\n raw_missing = raw.copy().load_data()\n raw_missing.info['bads'] = ['MEG0111']\n raw_missing.pick_types(meg=True) # will be missing the bad\n maxwell_filter(raw_missing)\n with warnings.catch_warnings(record=True) as w:\n maxwell_filter(raw_missing, calibration=fine_cal_fname)\n assert_equal(len(w), 1)\n assert_true('not in data' in str(w[0].message))\n\n\[email protected]_testing_data\ndef test_maxwell_filter_additional():\n \"\"\"Test processing of Maxwell filtered data.\"\"\"\n\n # TODO: Future tests integrate with mne/io/tests/test_proc_history\n\n # Load testing data (raw, SSS std origin, SSS non-standard origin)\n data_path = op.join(testing.data_path(download=False))\n\n file_name = 'test_move_anon'\n\n raw_fname = op.join(data_path, 'SSS', file_name + '_raw.fif')\n\n # Use 2.0 seconds of data to get stable cov. estimate\n raw = read_crop(raw_fname, (0., 2.))\n\n # Get MEG channels, compute Maxwell filtered data\n raw.load_data()\n raw.pick_types(meg=True, eeg=False)\n int_order = 8\n raw_sss = maxwell_filter(raw, origin=mf_head_origin, regularize=None,\n bad_condition='ignore')\n\n # Test io on processed data\n tempdir = _TempDir()\n test_outname = op.join(tempdir, 'test_raw_sss.fif')\n raw_sss.save(test_outname)\n raw_sss_loaded = read_crop(test_outname).load_data()\n\n # Some numerical imprecision since save uses 'single' fmt\n assert_allclose(raw_sss_loaded[:][0], raw_sss[:][0],\n rtol=1e-6, atol=1e-20)\n\n # Test rank of covariance matrices for raw and SSS processed data\n cov_raw = compute_raw_covariance(raw)\n cov_sss = compute_raw_covariance(raw_sss)\n\n scalings = None\n cov_raw_rank = _estimate_rank_meeg_cov(cov_raw['data'], raw.info, scalings)\n cov_sss_rank = _estimate_rank_meeg_cov(cov_sss['data'], raw_sss.info,\n scalings)\n\n assert_equal(cov_raw_rank, raw.info['nchan'])\n assert_equal(cov_sss_rank, _get_n_moments(int_order))\n\n\n@slow_test\[email protected]_testing_data\ndef test_bads_reconstruction():\n \"\"\"Test Maxwell filter reconstruction of bad channels.\"\"\"\n raw = read_crop(raw_fname, (0., 1.))\n raw.info['bads'] = bads\n raw_sss = maxwell_filter(raw, origin=mf_head_origin, regularize=None,\n bad_condition='ignore')\n assert_meg_snr(raw_sss, read_crop(sss_bad_recon_fname), 300.)\n\n\n@buggy_mkl_svd\n@requires_svd_convergence\[email protected]_testing_data\ndef test_spatiotemporal():\n \"\"\"Test Maxwell filter (tSSS) spatiotemporal processing.\"\"\"\n # Load raw testing data\n raw = read_crop(raw_fname)\n\n # Test that window is less than length of data\n assert_raises(ValueError, maxwell_filter, raw, st_duration=1000.)\n\n # We could check both 4 and 10 seconds because Elekta handles them\n # differently (to ensure that std/non-std tSSS windows are correctly\n # handled), but the 4-sec case should hopefully be sufficient.\n st_durations = [4.] # , 10.]\n tols = [325.] # , 200.]\n kwargs = dict(origin=mf_head_origin, regularize=None,\n bad_condition='ignore')\n for st_duration, tol in zip(st_durations, tols):\n # Load tSSS data depending on st_duration and get data\n tSSS_fname = op.join(sss_path,\n 'test_move_anon_st%0ds_raw_sss.fif' % st_duration)\n tsss_bench = read_crop(tSSS_fname)\n # Because Elekta's tSSS sometimes(!) lumps the tail window of data\n # onto the previous buffer if it's shorter than st_duration, we have to\n # crop the data here to compensate for Elekta's tSSS behavior.\n # if st_duration == 10.:\n # tsss_bench.crop(0, st_duration)\n # raw.crop(0, st_duration)\n\n # Test sss computation at the standard head origin. Same cropping issue\n # as mentioned above.\n raw_tsss = maxwell_filter(\n raw, st_duration=st_duration, **kwargs)\n assert_equal(raw_tsss.estimate_rank(), 140)\n assert_meg_snr(raw_tsss, tsss_bench, tol)\n py_st = raw_tsss.info['proc_history'][0]['max_info']['max_st']\n assert_true(len(py_st) > 0)\n assert_equal(py_st['buflen'], st_duration)\n assert_equal(py_st['subspcorr'], 0.98)\n\n # Degenerate cases\n assert_raises(ValueError, maxwell_filter, raw, st_duration=10.,\n st_correlation=0.)\n\n\n@slow_test\n@requires_svd_convergence\[email protected]_testing_data\ndef test_spatiotemporal_only():\n \"\"\"Test tSSS-only processing.\"\"\"\n # Load raw testing data\n tmax = 0.5\n raw = read_crop(raw_fname, (0, tmax)).load_data()\n picks = pick_types(raw.info, meg=True, exclude='bads')[::2]\n raw.pick_channels([raw.ch_names[pick] for pick in picks])\n mag_picks = pick_types(raw.info, meg='mag', exclude=())\n power = np.sqrt(np.sum(raw[mag_picks][0] ** 2))\n # basics\n raw_tsss = maxwell_filter(raw, st_duration=tmax / 2., st_only=True)\n assert_equal(len(raw.info['projs']), len(raw_tsss.info['projs']))\n assert_equal(raw_tsss.estimate_rank(), len(picks))\n _assert_shielding(raw_tsss, power, 9)\n # with movement\n head_pos = read_head_pos(pos_fname)\n raw_tsss = maxwell_filter(raw, st_duration=tmax / 2., st_only=True,\n head_pos=head_pos)\n assert_equal(raw_tsss.estimate_rank(), len(picks))\n _assert_shielding(raw_tsss, power, 9)\n with warnings.catch_warnings(record=True): # st_fixed False\n raw_tsss = maxwell_filter(raw, st_duration=tmax / 2., st_only=True,\n head_pos=head_pos, st_fixed=False)\n assert_equal(raw_tsss.estimate_rank(), len(picks))\n _assert_shielding(raw_tsss, power, 9)\n # should do nothing\n raw_tsss = maxwell_filter(raw, st_duration=tmax, st_correlation=1.,\n st_only=True)\n assert_allclose(raw[:][0], raw_tsss[:][0])\n # degenerate\n assert_raises(ValueError, maxwell_filter, raw, st_only=True) # no ST\n # two-step process equivalent to single-step process\n raw_tsss = maxwell_filter(raw, st_duration=tmax, st_only=True)\n raw_tsss = maxwell_filter(raw_tsss)\n raw_tsss_2 = maxwell_filter(raw, st_duration=tmax)\n assert_meg_snr(raw_tsss, raw_tsss_2, 1e5)\n # now also with head movement, and a bad MEG channel\n assert_equal(len(raw.info['bads']), 0)\n bads = [raw.ch_names[0]]\n raw.info['bads'] = list(bads)\n raw_tsss = maxwell_filter(raw, st_duration=tmax, st_only=True,\n head_pos=head_pos)\n assert_equal(raw.info['bads'], bads)\n assert_equal(raw_tsss.info['bads'], bads) # don't reset\n raw_tsss = maxwell_filter(raw_tsss, head_pos=head_pos)\n assert_equal(raw_tsss.info['bads'], []) # do reset MEG bads\n raw_tsss_2 = maxwell_filter(raw, st_duration=tmax, head_pos=head_pos)\n assert_equal(raw_tsss_2.info['bads'], [])\n assert_meg_snr(raw_tsss, raw_tsss_2, 1e5)\n\n\[email protected]_testing_data\ndef test_fine_calibration():\n \"\"\"Test Maxwell filter fine calibration.\"\"\"\n\n # Load testing data (raw, SSS std origin, SSS non-standard origin)\n raw = read_crop(raw_fname, (0., 1.))\n sss_fine_cal = read_crop(sss_fine_cal_fname)\n\n # Test 1D SSS fine calibration\n raw_sss = maxwell_filter(raw, calibration=fine_cal_fname,\n origin=mf_head_origin, regularize=None,\n bad_condition='ignore')\n assert_meg_snr(raw_sss, sss_fine_cal, 82, 611)\n py_cal = raw_sss.info['proc_history'][0]['max_info']['sss_cal']\n assert_true(py_cal is not None)\n assert_true(len(py_cal) > 0)\n mf_cal = sss_fine_cal.info['proc_history'][0]['max_info']['sss_cal']\n # we identify these differently\n mf_cal['cal_chans'][mf_cal['cal_chans'][:, 1] == 3022, 1] = 3024\n assert_allclose(py_cal['cal_chans'], mf_cal['cal_chans'])\n assert_allclose(py_cal['cal_corrs'], mf_cal['cal_corrs'],\n rtol=1e-3, atol=1e-3)\n # with missing channels\n raw_missing = raw.copy().load_data()\n raw_missing.info['bads'] = ['MEG0111', 'MEG0943'] # 1 mag, 1 grad\n raw_missing.info._check_consistency()\n raw_sss_bad = maxwell_filter(\n raw_missing, calibration=fine_cal_fname, origin=mf_head_origin,\n regularize=None, bad_condition='ignore')\n raw_missing.pick_types() # actually remove bads\n raw_sss_bad.pick_channels(raw_missing.ch_names) # remove them here, too\n with warnings.catch_warnings(record=True):\n raw_sss_missing = maxwell_filter(\n raw_missing, calibration=fine_cal_fname, origin=mf_head_origin,\n regularize=None, bad_condition='ignore')\n assert_meg_snr(raw_sss_missing, raw_sss_bad, 1000., 10000.)\n\n # Test 3D SSS fine calibration (no equivalent func in MaxFilter yet!)\n # very low SNR as proc differs, eventually we should add a better test\n raw_sss_3D = maxwell_filter(raw, calibration=fine_cal_fname_3d,\n origin=mf_head_origin, regularize=None,\n bad_condition='ignore')\n assert_meg_snr(raw_sss_3D, sss_fine_cal, 1.0, 6.)\n raw_ctf = read_crop(fname_ctf_raw).apply_gradient_compensation(0)\n assert_raises(RuntimeError, maxwell_filter, raw_ctf, origin=(0., 0., 0.04),\n calibration=fine_cal_fname)\n\n\n@slow_test\[email protected]_testing_data\ndef test_regularization():\n \"\"\"Test Maxwell filter regularization.\"\"\"\n # Load testing data (raw, SSS std origin, SSS non-standard origin)\n min_tols = (100., 2.6, 1.0)\n med_tols = (1000., 21.4, 3.7)\n origins = ((0., 0., 0.04), (0.,) * 3, (0., 0.02, 0.02))\n coord_frames = ('head', 'meg', 'head')\n raw_fnames = (raw_fname, erm_fname, sample_fname)\n sss_fnames = (sss_reg_in_fname, sss_erm_reg_in_fname,\n sss_samp_reg_in_fname)\n comp_tols = [0, 1, 4]\n for ii, rf in enumerate(raw_fnames):\n raw = read_crop(rf, (0., 1.))\n sss_reg_in = read_crop(sss_fnames[ii])\n\n # Test \"in\" regularization\n raw_sss = maxwell_filter(raw, coord_frame=coord_frames[ii],\n origin=origins[ii])\n assert_meg_snr(raw_sss, sss_reg_in, min_tols[ii], med_tols[ii], msg=rf)\n\n # check components match\n _check_reg_match(raw_sss, sss_reg_in, comp_tols[ii])\n\n\ndef _check_reg_match(sss_py, sss_mf, comp_tol):\n \"\"\"Helper to check regularization.\"\"\"\n info_py = sss_py.info['proc_history'][0]['max_info']['sss_info']\n assert_true(info_py is not None)\n assert_true(len(info_py) > 0)\n info_mf = sss_mf.info['proc_history'][0]['max_info']['sss_info']\n n_in = None\n for inf in (info_py, info_mf):\n if n_in is None:\n n_in = _get_n_moments(inf['in_order'])\n else:\n assert_equal(n_in, _get_n_moments(inf['in_order']))\n assert_equal(inf['components'][:n_in].sum(), inf['nfree'])\n assert_allclose(info_py['nfree'], info_mf['nfree'],\n atol=comp_tol, err_msg=sss_py._filenames[0])\n\n\[email protected]_testing_data\ndef test_cross_talk():\n \"\"\"Test Maxwell filter cross-talk cancellation.\"\"\"\n raw = read_crop(raw_fname, (0., 1.))\n raw.info['bads'] = bads\n sss_ctc = read_crop(sss_ctc_fname)\n raw_sss = maxwell_filter(raw, cross_talk=ctc_fname,\n origin=mf_head_origin, regularize=None,\n bad_condition='ignore')\n assert_meg_snr(raw_sss, sss_ctc, 275.)\n py_ctc = raw_sss.info['proc_history'][0]['max_info']['sss_ctc']\n assert_true(len(py_ctc) > 0)\n assert_raises(ValueError, maxwell_filter, raw, cross_talk=raw)\n assert_raises(ValueError, maxwell_filter, raw, cross_talk=raw_fname)\n mf_ctc = sss_ctc.info['proc_history'][0]['max_info']['sss_ctc']\n del mf_ctc['block_id'] # we don't write this\n assert_equal(object_diff(py_ctc, mf_ctc), '')\n raw_ctf = read_crop(fname_ctf_raw).apply_gradient_compensation(0)\n assert_raises(ValueError, maxwell_filter, raw_ctf) # cannot fit headshape\n raw_sss = maxwell_filter(raw_ctf, origin=(0., 0., 0.04))\n _assert_n_free(raw_sss, 68)\n raw_sss = maxwell_filter(raw_ctf, origin=(0., 0., 0.04), ignore_ref=True)\n _assert_n_free(raw_sss, 70)\n raw_missing = raw.copy().crop(0, 0.1).load_data().pick_channels(\n [raw.ch_names[pi] for pi in pick_types(raw.info, meg=True,\n exclude=())[3:]])\n with warnings.catch_warnings(record=True) as w:\n maxwell_filter(raw_missing, cross_talk=ctc_fname)\n assert_equal(len(w), 1)\n assert_true('Not all cross-talk channels in raw' in str(w[0].message))\n # MEG channels not in cross-talk\n assert_raises(RuntimeError, maxwell_filter, raw_ctf, origin=(0., 0., 0.04),\n cross_talk=ctc_fname)\n\n\[email protected]_testing_data\ndef test_head_translation():\n \"\"\"Test Maxwell filter head translation.\"\"\"\n raw = read_crop(raw_fname, (0., 1.))\n # First try with an unchanged destination\n raw_sss = maxwell_filter(raw, destination=raw_fname,\n origin=mf_head_origin, regularize=None,\n bad_condition='ignore')\n assert_meg_snr(raw_sss, read_crop(sss_std_fname, (0., 1.)), 200.)\n # Now with default\n with warnings.catch_warnings(record=True):\n with catch_logging() as log:\n raw_sss = maxwell_filter(raw, destination=mf_head_origin,\n origin=mf_head_origin, regularize=None,\n bad_condition='ignore', verbose='warning')\n assert_true('over 25 mm' in log.getvalue())\n assert_meg_snr(raw_sss, read_crop(sss_trans_default_fname), 125.)\n destination = np.eye(4)\n destination[2, 3] = 0.04\n assert_allclose(raw_sss.info['dev_head_t']['trans'], destination)\n # Now to sample's head pos\n with warnings.catch_warnings(record=True):\n with catch_logging() as log:\n raw_sss = maxwell_filter(raw, destination=sample_fname,\n origin=mf_head_origin, regularize=None,\n bad_condition='ignore', verbose='warning')\n assert_true('= 25.6 mm' in log.getvalue())\n assert_meg_snr(raw_sss, read_crop(sss_trans_sample_fname), 350.)\n assert_allclose(raw_sss.info['dev_head_t']['trans'],\n read_info(sample_fname)['dev_head_t']['trans'])\n # Degenerate cases\n assert_raises(RuntimeError, maxwell_filter, raw,\n destination=mf_head_origin, coord_frame='meg')\n assert_raises(ValueError, maxwell_filter, raw, destination=[0.] * 4)\n\n\n# TODO: Eventually add simulation tests mirroring Taulu's original paper\n# that calculates the localization error:\n# http://ieeexplore.ieee.org/xpl/articleDetails.jsp?arnumber=1495874\n\ndef _assert_shielding(raw_sss, erm_power, shielding_factor, meg='mag'):\n \"\"\"Helper to assert a minimum shielding factor using empty-room power.\"\"\"\n picks = pick_types(raw_sss.info, meg=meg, ref_meg=False)\n if isinstance(erm_power, BaseRaw):\n picks_erm = pick_types(raw_sss.info, meg=meg, ref_meg=False)\n assert_allclose(picks, picks_erm)\n erm_power = np.sqrt((erm_power[picks_erm][0] ** 2).sum())\n sss_power = raw_sss[picks][0].ravel()\n sss_power = np.sqrt(np.sum(sss_power * sss_power))\n factor = erm_power / sss_power\n assert_true(factor >= shielding_factor,\n 'Shielding factor %0.3f < %0.3f' % (factor, shielding_factor))\n\n\n@buggy_mkl_svd\n@slow_test\n@requires_svd_convergence\[email protected]_testing_data\ndef test_shielding_factor():\n \"\"\"Test Maxwell filter shielding factor using empty room.\"\"\"\n raw_erm = read_crop(erm_fname).load_data().pick_types(meg=True)\n erm_power = raw_erm[pick_types(raw_erm.info, meg='mag')][0]\n erm_power = np.sqrt(np.sum(erm_power * erm_power))\n erm_power_grad = raw_erm[pick_types(raw_erm.info, meg='grad')][0]\n erm_power_grad = np.sqrt(np.sum(erm_power * erm_power))\n\n # Vanilla SSS (second value would be for meg=True instead of meg='mag')\n _assert_shielding(read_crop(sss_erm_std_fname), erm_power, 10) # 1.5)\n raw_sss = maxwell_filter(raw_erm, coord_frame='meg', regularize=None)\n _assert_shielding(raw_sss, erm_power, 12) # 1.5)\n _assert_shielding(raw_sss, erm_power_grad, 0.45, 'grad') # 1.5)\n\n # Using different mag_scale values\n raw_sss = maxwell_filter(raw_erm, coord_frame='meg', regularize=None,\n mag_scale='auto')\n _assert_shielding(raw_sss, erm_power, 12)\n _assert_shielding(raw_sss, erm_power_grad, 0.48, 'grad')\n raw_sss = maxwell_filter(raw_erm, coord_frame='meg', regularize=None,\n mag_scale=1.) # not a good choice\n _assert_shielding(raw_sss, erm_power, 7.3)\n _assert_shielding(raw_sss, erm_power_grad, 0.2, 'grad')\n raw_sss = maxwell_filter(raw_erm, coord_frame='meg', regularize=None,\n mag_scale=1000., bad_condition='ignore')\n _assert_shielding(raw_sss, erm_power, 4.0)\n _assert_shielding(raw_sss, erm_power_grad, 0.1, 'grad')\n\n # Fine cal\n _assert_shielding(read_crop(sss_erm_fine_cal_fname), erm_power, 12) # 2.0)\n raw_sss = maxwell_filter(raw_erm, coord_frame='meg', regularize=None,\n origin=mf_meg_origin,\n calibration=fine_cal_fname)\n _assert_shielding(raw_sss, erm_power, 12) # 2.0)\n\n # Crosstalk\n _assert_shielding(read_crop(sss_erm_ctc_fname), erm_power, 12) # 2.1)\n raw_sss = maxwell_filter(raw_erm, coord_frame='meg', regularize=None,\n origin=mf_meg_origin,\n cross_talk=ctc_fname)\n _assert_shielding(raw_sss, erm_power, 12) # 2.1)\n\n # Fine cal + Crosstalk\n raw_sss = maxwell_filter(raw_erm, coord_frame='meg', regularize=None,\n calibration=fine_cal_fname,\n origin=mf_meg_origin,\n cross_talk=ctc_fname)\n _assert_shielding(raw_sss, erm_power, 13) # 2.2)\n\n # tSSS\n _assert_shielding(read_crop(sss_erm_st_fname), erm_power, 37) # 5.8)\n raw_sss = maxwell_filter(raw_erm, coord_frame='meg', regularize=None,\n origin=mf_meg_origin, st_duration=1.)\n _assert_shielding(raw_sss, erm_power, 37) # 5.8)\n\n # Crosstalk + tSSS\n raw_sss = maxwell_filter(raw_erm, coord_frame='meg', regularize=None,\n cross_talk=ctc_fname, origin=mf_meg_origin,\n st_duration=1.)\n _assert_shielding(raw_sss, erm_power, 38) # 5.91)\n\n # Fine cal + tSSS\n raw_sss = maxwell_filter(raw_erm, coord_frame='meg', regularize=None,\n calibration=fine_cal_fname,\n origin=mf_meg_origin, st_duration=1.)\n _assert_shielding(raw_sss, erm_power, 38) # 5.98)\n\n # Fine cal + Crosstalk + tSSS\n _assert_shielding(read_crop(sss_erm_st1FineCalCrossTalk_fname),\n erm_power, 39) # 6.07)\n raw_sss = maxwell_filter(raw_erm, coord_frame='meg', regularize=None,\n calibration=fine_cal_fname, origin=mf_meg_origin,\n cross_talk=ctc_fname, st_duration=1.)\n _assert_shielding(raw_sss, erm_power, 39) # 6.05)\n\n # Fine cal + Crosstalk + tSSS + Reg-in\n _assert_shielding(read_crop(sss_erm_st1FineCalCrossTalkRegIn_fname),\n erm_power, 57) # 6.97)\n raw_sss = maxwell_filter(raw_erm, calibration=fine_cal_fname,\n cross_talk=ctc_fname, st_duration=1.,\n origin=mf_meg_origin,\n coord_frame='meg', regularize='in')\n _assert_shielding(raw_sss, erm_power, 53) # 6.64)\n raw_sss = maxwell_filter(raw_erm, calibration=fine_cal_fname,\n cross_talk=ctc_fname, st_duration=1.,\n coord_frame='meg', regularize='in')\n _assert_shielding(raw_sss, erm_power, 58) # 7.0)\n _assert_shielding(raw_sss, erm_power_grad, 1.6, 'grad')\n raw_sss = maxwell_filter(raw_erm, calibration=fine_cal_fname,\n cross_talk=ctc_fname, st_duration=1.,\n coord_frame='meg', regularize='in',\n mag_scale='auto')\n _assert_shielding(raw_sss, erm_power, 51)\n _assert_shielding(raw_sss, erm_power_grad, 1.5, 'grad')\n raw_sss = maxwell_filter(raw_erm, calibration=fine_cal_fname_3d,\n cross_talk=ctc_fname, st_duration=1.,\n coord_frame='meg', regularize='in')\n\n # Our 3D cal has worse defaults for this ERM than the 1D file\n _assert_shielding(raw_sss, erm_power, 54)\n # Show it by rewriting the 3D as 1D and testing it\n temp_dir = _TempDir()\n temp_fname = op.join(temp_dir, 'test_cal.dat')\n with open(fine_cal_fname_3d, 'r') as fid:\n with open(temp_fname, 'w') as fid_out:\n for line in fid:\n fid_out.write(' '.join(line.strip().split(' ')[:14]) + '\\n')\n raw_sss = maxwell_filter(raw_erm, calibration=temp_fname,\n cross_talk=ctc_fname, st_duration=1.,\n coord_frame='meg', regularize='in')\n # Our 3D cal has worse defaults for this ERM than the 1D file\n _assert_shielding(raw_sss, erm_power, 44)\n\n\n@slow_test\n@requires_svd_convergence\[email protected]_testing_data\ndef test_all():\n \"\"\"Test maxwell filter using all options.\"\"\"\n raw_fnames = (raw_fname, raw_fname, erm_fname, sample_fname)\n sss_fnames = (sss_st1FineCalCrossTalkRegIn_fname,\n sss_st1FineCalCrossTalkRegInTransSample_fname,\n sss_erm_st1FineCalCrossTalkRegIn_fname,\n sss_samp_fname)\n fine_cals = (fine_cal_fname,\n fine_cal_fname,\n fine_cal_fname,\n fine_cal_mgh_fname)\n coord_frames = ('head', 'head', 'meg', 'head')\n ctcs = (ctc_fname, ctc_fname, ctc_fname, ctc_mgh_fname)\n mins = (3.5, 3.5, 1.2, 0.9)\n meds = (10.8, 10.4, 3.2, 6.)\n st_durs = (1., 1., 1., None)\n destinations = (None, sample_fname, None, None)\n origins = (mf_head_origin,\n mf_head_origin,\n mf_meg_origin,\n mf_head_origin)\n for ii, rf in enumerate(raw_fnames):\n raw = read_crop(rf, (0., 1.))\n with warnings.catch_warnings(record=True): # head fit off-center\n sss_py = maxwell_filter(\n raw, calibration=fine_cals[ii], cross_talk=ctcs[ii],\n st_duration=st_durs[ii], coord_frame=coord_frames[ii],\n destination=destinations[ii], origin=origins[ii])\n sss_mf = read_crop(sss_fnames[ii])\n assert_meg_snr(sss_py, sss_mf, mins[ii], meds[ii], msg=rf)\n\n\n@slow_test\n@requires_svd_convergence\[email protected]_testing_data\ndef test_triux():\n \"\"\"Test TRIUX system support.\"\"\"\n raw = read_crop(tri_fname, (0, 0.999))\n raw.fix_mag_coil_types()\n # standard\n sss_py = maxwell_filter(raw, coord_frame='meg', regularize=None)\n assert_meg_snr(sss_py, read_crop(tri_sss_fname), 37, 700)\n # cross-talk\n sss_py = maxwell_filter(raw, coord_frame='meg', regularize=None,\n cross_talk=tri_ctc_fname)\n assert_meg_snr(sss_py, read_crop(tri_sss_ctc_fname), 35, 700)\n # fine cal\n sss_py = maxwell_filter(raw, coord_frame='meg', regularize=None,\n calibration=tri_cal_fname)\n assert_meg_snr(sss_py, read_crop(tri_sss_cal_fname), 31, 360)\n # ctc+cal\n sss_py = maxwell_filter(raw, coord_frame='meg', regularize=None,\n calibration=tri_cal_fname,\n cross_talk=tri_ctc_fname)\n assert_meg_snr(sss_py, read_crop(tri_sss_ctc_cal_fname), 31, 350)\n # regularization\n sss_py = maxwell_filter(raw, coord_frame='meg', regularize='in')\n sss_mf = read_crop(tri_sss_reg_fname)\n assert_meg_snr(sss_py, sss_mf, 0.6, 9)\n _check_reg_match(sss_py, sss_mf, 1)\n # all three\n sss_py = maxwell_filter(raw, coord_frame='meg', regularize='in',\n calibration=tri_cal_fname,\n cross_talk=tri_ctc_fname)\n sss_mf = read_crop(tri_sss_ctc_cal_reg_in_fname)\n assert_meg_snr(sss_py, sss_mf, 0.6, 9)\n _check_reg_match(sss_py, sss_mf, 1)\n # tSSS\n raw = read_crop(tri_fname).fix_mag_coil_types()\n sss_py = maxwell_filter(raw, coord_frame='meg', regularize=None,\n st_duration=4., verbose=True)\n assert_meg_snr(sss_py, read_crop(tri_sss_st4_fname), 700., 1600)\n\n\[email protected]_testing_data\ndef test_MGH_cross_talk():\n raw = read_crop(raw_fname, (0., 1.))\n raw_sss = maxwell_filter(raw, cross_talk=ctc_mgh_fname)\n py_ctc = raw_sss.info['proc_history'][0]['max_info']['sss_ctc']\n assert_true(len(py_ctc) > 0)\n\nrun_tests_if_main()\n"
] | [
[
"numpy.array",
"numpy.zeros",
"numpy.where",
"numpy.unique"
],
[
"pandas.concat",
"pandas.read_csv",
"numpy.abs",
"numpy.arange",
"pandas.DataFrame",
"numpy.std",
"numpy.diff",
"numpy.mean"
],
[
"numpy.dot",
"scipy.linalg.svd",
"numpy.unique",
"numpy.eye",
"numpy.ones",
"numpy.all",
"numpy.array",
"numpy.zeros",
"numpy.sum"
],
[
"matplotlib.pyplot.show"
],
[
"numpy.testing.assert_equal",
"numpy.linspace",
"numpy.eye",
"scipy.io.loadmat",
"numpy.concatenate",
"numpy.sign",
"numpy.testing.assert_allclose",
"numpy.sum"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [
"2.0",
"1.4",
"1.1",
"1.5",
"1.2",
"1.3"
],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [
"0.13",
"0.14",
"0.15",
"0.12",
"0.10"
],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [
"1.7",
"1.0",
"0.10",
"1.2",
"0.14",
"0.19",
"1.5",
"0.12",
"0.17",
"0.13",
"1.6",
"1.4",
"1.9",
"1.3",
"1.10",
"0.15",
"0.18",
"0.16",
"1.8"
],
"tensorflow": []
}
] |
michaelyeah7/magics_mbrl | [
"7f1503986fd50c8336b8b9e7bb1d2f4be4e84b08",
"7f1503986fd50c8336b8b9e7bb1d2f4be4e84b08"
] | [
"gym-rbdl/gym_rbdl/envs/real_pendulum.py",
"gym-rbdl/gym_rbdl/envs/cartpole_jbdl.py"
] | [
"import gym\nfrom gym import spaces\nfrom gym.utils import seeding\nimport numpy as np\nfrom os import path\n\n\nclass PendulumEnv(gym.Env):\n metadata = {\"render.modes\": [\"human\", \"rgb_array\"], \"video.frames_per_second\": 30}\n\n def __init__(self, g=10.0):\n self.max_speed = 8\n self.max_torque = 2.0\n self.dt = 0.05\n self.g = g\n self.m = 1.0\n self.l = 1.0\n self.viewer = None\n\n high = np.array([1.0, 1.0, self.max_speed], dtype=np.float32)\n self.action_space = spaces.Box(\n low=-self.max_torque, high=self.max_torque, shape=(1,), dtype=np.float32\n )\n self.observation_space = spaces.Box(low=-high, high=high, dtype=np.float32)\n\n self.seed()\n\n def seed(self, seed=None):\n self.np_random, seed = seeding.np_random(seed)\n return [seed]\n\n def step(self, u):\n th, thdot = self.state # th := theta\n\n g = self.g\n m = self.m\n l = self.l\n dt = self.dt\n\n u = np.clip(u, -self.max_torque, self.max_torque)[0]\n self.last_u = u # for rendering\n # costs = angle_normalize(th) ** 2 + 0.1 * thdot ** 2 + 0.001 * (u ** 2)\n y = np.cos(th)\n x = np.sin(th)\n costs = y + .1 * np.abs(x) + 0.1 * thdot ** 2 + 0.001 * (u ** 2)\n\n newthdot = (\n thdot\n + (-3 * g / (2 * l) * np.sin(th + np.pi) + 3.0 / (m * l ** 2) * u) * dt\n )\n newth = th + newthdot * dt\n newthdot = np.clip(newthdot, -self.max_speed, self.max_speed)\n\n self.state = np.array([newth, newthdot])\n return self._get_obs(), -costs, False, {}\n\n def reset(self):\n high = np.array([np.pi, 1])\n self.state = self.np_random.uniform(low=-high, high=high)\n self.last_u = None\n return self._get_obs()\n\n def _get_obs(self):\n theta, thetadot = self.state\n return np.array([np.cos(theta), np.sin(theta), thetadot], dtype=np.float32)\n\n def render(self, mode=\"human\"):\n if self.viewer is None:\n from gym.envs.classic_control import rendering\n\n self.viewer = rendering.Viewer(500, 500)\n self.viewer.set_bounds(-2.2, 2.2, -2.2, 2.2)\n rod = rendering.make_capsule(1, 0.2)\n rod.set_color(0.8, 0.3, 0.3)\n self.pole_transform = rendering.Transform()\n rod.add_attr(self.pole_transform)\n self.viewer.add_geom(rod)\n axle = rendering.make_circle(0.05)\n axle.set_color(0, 0, 0)\n self.viewer.add_geom(axle)\n fname = path.join(path.dirname(__file__), \"assets/clockwise.png\")\n self.img = rendering.Image(fname, 1.0, 1.0)\n self.imgtrans = rendering.Transform()\n self.img.add_attr(self.imgtrans)\n\n self.viewer.add_onetime(self.img)\n self.pole_transform.set_rotation(self.state[0] + np.pi / 2)\n if self.last_u is not None:\n self.imgtrans.scale = (-self.last_u / 2, np.abs(self.last_u) / 2)\n\n return self.viewer.render(return_rgb_array=mode == \"rgb_array\")\n\n def close(self):\n if self.viewer:\n self.viewer.close()\n self.viewer = None\n\n\ndef angle_normalize(x):\n return ((x + np.pi) % (2 * np.pi)) - np.pi\n",
"import gym\nfrom gym import error, spaces, utils\nfrom gym.utils import seeding\n\nimport math\nimport gym\nimport numpy as np\n\nimport math\nimport jax\nimport jax.numpy as jnp\nfrom jbdl.rbdl.dynamics.forward_dynamics import forward_dynamics_core\nimport pybullet as p\nimport pybullet_data\nfrom jbdl.rbdl.model.rigid_body_inertia import rigid_body_inertia, init_Ic_by_cholesky\nfrom jbdl.rbdl.utils import xyz2int\nfrom functools import partial\nfrom jbdl.experimental.ode.runge_kutta import odeint\nfrom jax import jit, vmap\nfrom jax.ops import index_update, index\n# from jbdlenvs.utils.parser import URDFBasedRobot\n\nfrom simulator.UrdfWrapper import UrdfWrapper\n# from jaxRBDL.Utils.UrdfWrapper_guo import UrdfWrapper\nfrom simulator.ObdlRender import ObdlRender\nfrom simulator.ObdlSim import ObdlSim\n\nM_CART = 1.0\nM_POLE = 0.1\nHALF_POLE_LENGTH = 0.5\nPOLE_IC_PARAMS = jnp.zeros((6,))\nDEFAULT_PURE_CART_POLE_PARAMS = (M_CART, M_POLE, HALF_POLE_LENGTH, POLE_IC_PARAMS)\n\n\ndef init_I(m, c, l):\n Ic = init_Ic_by_cholesky(l)\n I = rigid_body_inertia(m, c, Ic)\n\n return I\n\n\n\nclass CartPoleJBDLEnv(gym.Env):\n \"\"\"\n Description:\n A pole is attached by an un-actuated joint to a cart, which moves along\n a frictionless track. The pendulum starts upright, and the goal is to\n prevent it from falling over by increasing and reducing the cart's\n velocity.\n\n Source:\n This environment corresponds to the version of the cart-pole problem\n described by Barto, Sutton, and Anderson\n\n Observation:\n Type: Box(4)\n Num\tObservation Min Max\n 0\tCart Position -x_threshold x_threshold\n 1\tPole Angle -theta_threshold theta_threshold\n 2\tCart Velocity -Inf Inf\n 3\tPole Rotation Velocity -Inf Inf\n\n Actions:\n Type: Continous(1)\n Num\tAction\n 0\tForce applied to the cart.\n\n \"\"\"\n\n def __init__(self, pure_cart_pole_params=DEFAULT_PURE_CART_POLE_PARAMS, reward_fun=None, seed=0, batch_size=0, render=False):\n self._init_params(*pure_cart_pole_params)\n \n action_max = np.ones(1)*100.\n self._action_space = spaces.Box(low=-action_max, high=action_max)\n observation_high = np.ones(4)*math.pi\n observation_low = np.zeros(4)\n self._observation_space = spaces.Box(low=observation_low, high=observation_high)\n\n\n self.NB = 2\n self.nf = 3\n self.a_grav = jnp.array([[0.], [0.], [0.], [0.], [0.], [-9.81]])\n self.jtype = (1, 0)\n self.jaxis = xyz2int('xy')\n self.parent = (0, 1)\n self.Xtree = list([jnp.eye(6) for i in range(self.NB)])\n self.sim_dt = 0.1\n self.batch_size = batch_size\n \n \n\n self.render = render\n\n # Angle at which to fail the episode\n # Angle at which to fail the episode\n self.theta_threshold = 15.0 / 360.0 * math.pi\n self.x_threshold = 2.5\n self.key = jax.random.PRNGKey(seed)\n\n if self.render:\n p.connect(p.GUI)\n p.resetDebugVisualizerCamera(cameraDistance=6.18, cameraYaw=0, cameraPitch=-30, cameraTargetPosition=[0, 0, 1.0])\n self.cartpole_render = URDFBasedRobot(\"cartpole.urdf\", \"physics\", action_dim=1, obs_dim=4)\n self.cartpole_render.load(p)\n \n self.model = UrdfWrapper(\"urdf/cartpole_add_base.urdf\").model\n self.osim = ObdlSim(self.model,dt=0.02,vis=True)\n\n self.reset()\n\n def _reset_cartpole_render(bullet_client, cartpole, x, theta):\n cartpole.slider_to_cart = cartpole.jdict[\"slider_to_cart\"]\n cartpole.cart_to_pole = cartpole.jdict[\"cart_to_pole\"]\n cartpole.slider_to_cart.reset_current_position(x, 0)\n cartpole.cart_to_pole.reset_current_position(theta, 0)\n\n self.reset_cartpole_render = _reset_cartpole_render\n\n\n def _dynamics_fun(y, t, Xtree, I, u, a_grav, parent, jtype, jaxis, NB):\n q = y[0:NB]\n qdot = y[NB:]\n input = (Xtree, I, parent, jtype, jaxis, NB, q, qdot, u, a_grav)\n qddot = forward_dynamics_core(*input)\n ydot = jnp.hstack([qdot, qddot])\n return ydot\n\n self.dynamics_fun = partial(_dynamics_fun, parent=self.parent, jtype=self.jtype, jaxis=self.jaxis, NB=self.NB)\n \n # @partial(jit, static_argnums=0)\n def _dynamics_step(dynamics_fun, y0, *args, sim_dt=self.sim_dt, rtol=1.4e-8, atol=1.4e-8, mxstep=jnp.inf):\n t_eval = jnp.linspace(0, sim_dt, 2)\n y_all = odeint(dynamics_fun, y0, t_eval, *args, rtol=rtol, atol=atol, mxstep=mxstep)\n yT = y_all[-1, :]\n return yT\n\n self._dynamics_step = _dynamics_step\n\n self.dynamics_step = jit(_dynamics_step, static_argnums=0)\n\n\n def _dynamics_step_with_params(dynamics_fun, state, action, *cartpole_params, Xtree=self.Xtree, a_grav=self.a_grav, sim_dt=self.sim_dt, rtol=1.4e-8, atol=1.4e-8, mxstep=jnp.inf):\n m_cart, m_pole, half_pole_length, pole_Ic_params = cartpole_params\n I_cart = init_I(m_cart, jnp.zeros((3,)), jnp.zeros((6,)))\n I_pole = init_I(m_pole, jnp.array([0.0, 0.0, half_pole_length]), pole_Ic_params)\n I = [I_cart, I_pole]\n u = jnp.array([action[0], 0.0])\n dynamics_fun_param = (Xtree, I, u, a_grav)\n next_state = self._dynamics_step(dynamics_fun, state, *dynamics_fun_param, sim_dt=sim_dt, rtol=rtol, atol=atol, mxstep=mxstep)\n return next_state\n\n self._dynamics_step_with_params = _dynamics_step_with_params\n self.dynamics_step_with_params = jit(_dynamics_step_with_params, static_argnums=0)\n\n\n def _done_fun(state, x_threshold=self.x_threshold, theta_threshold=self.theta_threshold):\n x = state[0]\n theta = state[1]\n # done = jax.lax.cond(\n # (jnp.abs(x) > jnp.abs(x_threshold)) + (jnp.abs(theta) > jnp.abs(theta_threshold)),\n # lambda done: True,\n # lambda done: False,\n # None)\n done = jax.lax.cond(\n (jnp.abs(x) > jnp.abs(x_threshold) ),\n lambda done: True,\n lambda done: False,\n None)\n # done = False\n return done\n \n self._done_fun = _done_fun\n\n self.done_fun = jit(_done_fun)\n\n\n \n def _default_reward_fun(state, action, next_state):\n reward = -(next_state[0]**2 + 10 * next_state[1]**2 + next_state[2]**2 + next_state[3]**2)\n return reward\n\n if reward_fun is None:\n self._reward_fun = _default_reward_fun\n self.reward_fun = jit(_default_reward_fun)\n else:\n self._reward_fun = reward_fun\n self.reward_fun = jit(reward_fun)\n\n\n\n @property\n def action_space(self):\n return self._action_space\n\n @property\n def observation_space(self):\n return self._observation_space\n\n \n\n \n\n def _init_params(self, *cart_pole_params):\n self.m_cart, self.m_pole, self.half_pole_length, self.pole_Ic_params = cart_pole_params\n self.I_cart = init_I(self.m_cart, jnp.zeros((3,)), jnp.zeros((6,)))\n self.I_pole = init_I(self.m_pole, jnp.array([0.0, 0.0, self.half_pole_length]), self.pole_Ic_params)\n self.I = [self.I_cart, self.I_pole]\n\n\n def reset(self, m_cart=M_CART, m_pole=M_POLE, half_pole_length=HALF_POLE_LENGTH, pole_Ic_params=POLE_IC_PARAMS, idx_list=None):\n self._init_params(m_cart, m_pole, half_pole_length, pole_Ic_params)\n self.key, subkey = jax.random.split(self.key)\n if self.batch_size == 0:\n self.state = jax.numpy.array(\n [0, jax.random.uniform(key=self.key, shape=(),\n minval=-15.0/360.0*math.pi,\n maxval=15.0/360.0*math.pi), 0, 0])\n self.state = jax.numpy.array(\n [0, math.pi, 0, 0])\n else:\n if idx_list is None:\n self.state = jax.numpy.concatenate([\n jax.numpy.zeros(shape=(self.batch_size, 1)),\n jax.random.uniform(\n self.key, shape=(self.batch_size, 1),\n minval=-15.0/360.0*math.pi,\n maxval=15.0/360.0*math.pi),\n jax.numpy.zeros(shape=(self.batch_size, 1)),\n jax.numpy.zeros(shape=(self.batch_size, 1))], axis=-1)\n else:\n idx_num = len(idx_list)\n self.state = index_update(\n self.state,\n index[idx_list, :],\n jax.numpy.concatenate([\n jax.numpy.zeros(shape=(idx_num, 1)),\n jax.random.uniform(\n self.key, shape=(idx_num, 1),\n minval=-15.0/360.0*math.pi,\n maxval=15.0/360.0*math.pi),\n jax.numpy.zeros(shape=(idx_num, 1)),\n jax.numpy.zeros(shape=(idx_num, 1))], axis=-1)\n )\n self.state = np.array(self.state)\n return self.state\n\n\n\n def step(self, action):\n\n if self.batch_size == 0:\n u = jnp.array([action[0], 0.0])\n dynamics_params = (self.Xtree, self.I, u, self.a_grav)\n next_state = self.dynamics_step(self.dynamics_fun, self.state, *dynamics_params)\n done = self.done_fun(next_state)\n reward = self.reward_fun(self.state, action, next_state)\n self.state = next_state\n else:\n action = jnp.reshape(jnp.array(action), newshape=(self.batch_size, 1))\n u = jnp.concatenate([action, jnp.zeros((self.batch_size, 1))], axis=1)\n dynamics_params = (self.Xtree, self.I, u, self.a_grav)\n next_state = vmap(self.dynamics_step, (None, 0, None, None, 0, None), 0)(self.dynamics_fun, self.state, *dynamics_params)\n done = vmap(self.done_fun)(next_state)\n reward = vmap(self.reward_fun)(self.state, action, next_state)\n self.state = next_state\n next_state = np.array(next_state)\n reward = np.array(reward)\n return next_state, reward, done, {}\n\n def pb_render(self, idx=0):\n if self.render:\n if self.batch_size == 0:\n self.reset_cartpole_render(p, self.cartpole_render, self.state[0], self.state[1])\n else:\n self.reset_cartpole_render(p, self.cartpole_render, self.state[idx, 0], self.state[idx, 1])\n\n def osim_render(self):\n q = [0,0,self.state[0],self.state[1]]\n self.osim.step_theta(q)\n"
] | [
[
"numpy.abs",
"numpy.clip",
"numpy.cos",
"numpy.sin",
"numpy.array"
],
[
"numpy.array",
"numpy.zeros",
"numpy.ones"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
ZeroDesigner/quantum-gan | [
"76b12fe1be25ac2a5e75fdc472947a08d7065c50"
] | [
"utils.py"
] | [
"from sklearn.metrics import classification_report as sk_classification_report\nfrom sklearn.metrics import confusion_matrix\n\nimport pickle\nimport gzip\nfrom rdkit import DataStructs\nfrom rdkit import Chem\nfrom rdkit.Chem import QED\nfrom rdkit.Chem import Crippen\nfrom rdkit.Chem import AllChem\nfrom rdkit.Chem import Draw\n\nimport math\nimport numpy as np\n\nNP_model = pickle.load(gzip.open('data/NP_score.pkl.gz'))\nSA_model = {i[j]: float(i[0]) for i in pickle.load(gzip.open('data/SA_score.pkl.gz')) for j in range(1, len(i))}\n\n\nclass MolecularMetrics(object):\n\n @staticmethod\n def _avoid_sanitization_error(op):\n try:\n return op()\n except ValueError:\n return None\n\n @staticmethod\n def remap(x, x_min, x_max):\n return (x - x_min) / (x_max - x_min)\n\n @staticmethod\n def valid_lambda(x):\n return x is not None and Chem.MolToSmiles(x) != ''\n\n @staticmethod\n def valid_lambda_special(x):\n s = Chem.MolToSmiles(x) if x is not None else ''\n return x is not None and '*' not in s and '.' not in s and s != ''\n\n @staticmethod\n def valid_scores(mols):\n return np.array(list(map(MolecularMetrics.valid_lambda_special, mols)), dtype=np.float32)\n\n @staticmethod\n def valid_filter(mols):\n return list(filter(MolecularMetrics.valid_lambda, mols))\n\n @staticmethod\n def valid_total_score(mols):\n return np.array(list(map(MolecularMetrics.valid_lambda, mols)), dtype=np.float32).mean()\n\n @staticmethod\n def novel_scores(mols, data):\n return np.array(\n list(map(lambda x: MolecularMetrics.valid_lambda(x) and Chem.MolToSmiles(x) not in data.smiles, mols)))\n\n @staticmethod\n def novel_filter(mols, data):\n return list(filter(lambda x: MolecularMetrics.valid_lambda(x) and Chem.MolToSmiles(x) not in data.smiles, mols))\n\n @staticmethod\n def novel_total_score(mols, data):\n return MolecularMetrics.novel_scores(MolecularMetrics.valid_filter(mols), data).mean()\n\n @staticmethod\n def unique_scores(mols):\n smiles = list(map(lambda x: Chem.MolToSmiles(x) if MolecularMetrics.valid_lambda(x) else '', mols))\n return np.clip(\n 0.75 + np.array(list(map(lambda x: 1 / smiles.count(x) if x != '' else 0, smiles)), dtype=np.float32), 0, 1)\n\n @staticmethod\n def unique_total_score(mols):\n v = MolecularMetrics.valid_filter(mols)\n s = set(map(lambda x: Chem.MolToSmiles(x), v))\n return 0 if len(v) == 0 else len(s) / len(v)\n\n # @staticmethod\n # def novel_and_unique_total_score(mols, data):\n # return ((MolecularMetrics.unique_scores(mols) == 1).astype(float) * MolecularMetrics.novel_scores(mols,\n # data)).sum()\n #\n # @staticmethod\n # def reconstruction_scores(data, model, session, sample=False):\n #\n # m0, _, _, a, x, _, f, _, _ = data.next_validation_batch()\n # feed_dict = {model.edges_labels: a, model.nodes_labels: x, model.node_features: f, model.training: False}\n #\n # try:\n # feed_dict.update({model.variational: False})\n # except AttributeError:\n # pass\n #\n # n, e = session.run([model.nodes_gumbel_argmax, model.edges_gumbel_argmax] if sample else [\n # model.nodes_argmax, model.edges_argmax], feed_dict=feed_dict)\n #\n # n, e = np.argmax(n, axis=-1), np.argmax(e, axis=-1)\n #\n # m1 = [data.matrices2mol(n_, e_, strict=True) for n_, e_ in zip(n, e)]\n #\n # return np.mean([float(Chem.MolToSmiles(m0_) == Chem.MolToSmiles(m1_)) if m1_ is not None else 0\n # for m0_, m1_ in zip(m0, m1)])\n\n @staticmethod\n def natural_product_scores(mols, norm=False):\n\n # calculating the score\n scores = [sum(NP_model.get(bit, 0)\n for bit in Chem.rdMolDescriptors.GetMorganFingerprint(mol,\n 2).GetNonzeroElements()) / float(\n mol.GetNumAtoms()) if mol is not None else None\n for mol in mols]\n\n # preventing score explosion for exotic molecules\n scores = list(map(lambda score: score if score is None else (\n 4 + math.log10(score - 4 + 1) if score > 4 else (\n -4 - math.log10(-4 - score + 1) if score < -4 else score)), scores))\n\n scores = np.array(list(map(lambda x: -4 if x is None else x, scores)))\n scores = np.clip(MolecularMetrics.remap(scores, -3, 1), 0.0, 1.0) if norm else scores\n\n return scores\n\n @staticmethod\n def quantitative_estimation_druglikeness_scores(mols, norm=False):\n return np.array(list(map(lambda x: 0 if x is None else x, [\n MolecularMetrics._avoid_sanitization_error(lambda: QED.qed(mol)) if mol is not None else None for mol in\n mols])))\n\n @staticmethod\n def water_octanol_partition_coefficient_scores(mols, norm=False):\n scores = [MolecularMetrics._avoid_sanitization_error(lambda: Crippen.MolLogP(mol)) if mol is not None else None\n for mol in mols]\n scores = np.array(list(map(lambda x: -3 if x is None else x, scores)))\n scores = np.clip(MolecularMetrics.remap(scores, -2.12178879609, 6.0429063424), 0.0, 1.0) if norm else scores\n\n return scores\n\n @staticmethod\n def _compute_SAS(mol):\n fp = Chem.rdMolDescriptors.GetMorganFingerprint(mol, 2)\n fps = fp.GetNonzeroElements()\n score1 = 0.\n nf = 0\n # for bitId, v in fps.items():\n for bitId, v in fps.items():\n nf += v\n sfp = bitId\n score1 += SA_model.get(sfp, -4) * v\n score1 /= nf\n\n # features score\n nAtoms = mol.GetNumAtoms()\n nChiralCenters = len(Chem.FindMolChiralCenters(\n mol, includeUnassigned=True))\n ri = mol.GetRingInfo()\n nSpiro = Chem.rdMolDescriptors.CalcNumSpiroAtoms(mol)\n nBridgeheads = Chem.rdMolDescriptors.CalcNumBridgeheadAtoms(mol)\n nMacrocycles = 0\n for x in ri.AtomRings():\n if len(x) > 8:\n nMacrocycles += 1\n\n sizePenalty = nAtoms ** 1.005 - nAtoms\n stereoPenalty = math.log10(nChiralCenters + 1)\n spiroPenalty = math.log10(nSpiro + 1)\n bridgePenalty = math.log10(nBridgeheads + 1)\n macrocyclePenalty = 0.\n\n # ---------------------------------------\n # This differs from the paper, which defines:\n # macrocyclePenalty = math.log10(nMacrocycles+1)\n # This form generates better results when 2 or more macrocycles are present\n if nMacrocycles > 0:\n macrocyclePenalty = math.log10(2)\n\n score2 = 0. - sizePenalty - stereoPenalty - \\\n spiroPenalty - bridgePenalty - macrocyclePenalty\n\n # correction for the fingerprint density\n # not in the original publication, added in version 1.1\n # to make highly symmetrical molecules easier to synthetise\n score3 = 0.\n if nAtoms > len(fps):\n score3 = math.log(float(nAtoms) / len(fps)) * .5\n\n sascore = score1 + score2 + score3\n\n # need to transform \"raw\" value into scale between 1 and 10\n min = -4.0\n max = 2.5\n sascore = 11. - (sascore - min + 1) / (max - min) * 9.\n # smooth the 10-end\n if sascore > 8.:\n sascore = 8. + math.log(sascore + 1. - 9.)\n if sascore > 10.:\n sascore = 10.0\n elif sascore < 1.:\n sascore = 1.0\n\n return sascore\n\n @staticmethod\n def synthetic_accessibility_score_scores(mols, norm=False):\n scores = [MolecularMetrics._compute_SAS(mol) if mol is not None else None for mol in mols]\n scores = np.array(list(map(lambda x: 10 if x is None else x, scores)))\n scores = np.clip(MolecularMetrics.remap(scores, 5, 1.5), 0.0, 1.0) if norm else scores\n\n return scores\n\n @staticmethod\n def diversity_scores(mols, data):\n rand_mols = np.random.choice(data.data, 100)\n fps = [Chem.rdMolDescriptors.GetMorganFingerprintAsBitVect(mol, 4, nBits=2048) for mol in rand_mols]\n\n scores = np.array(\n list(map(lambda x: MolecularMetrics.__compute_diversity(x, fps) if x is not None else 0, mols)))\n scores = np.clip(MolecularMetrics.remap(scores, 0.9, 0.945), 0.0, 1.0)\n\n return scores\n\n @staticmethod\n def __compute_diversity(mol, fps):\n ref_fps = Chem.rdMolDescriptors.GetMorganFingerprintAsBitVect(mol, 4, nBits=2048)\n dist = DataStructs.BulkTanimotoSimilarity(ref_fps, fps, returnDistance=True)\n score = np.mean(dist)\n return score\n\n @staticmethod\n def drugcandidate_scores(mols, data):\n\n scores = (MolecularMetrics.constant_bump(\n MolecularMetrics.water_octanol_partition_coefficient_scores(mols, norm=True), 0.210,\n 0.945) + MolecularMetrics.synthetic_accessibility_score_scores(mols,\n norm=True) + MolecularMetrics.novel_scores(\n mols, data) + (1 - MolecularMetrics.novel_scores(mols, data)) * 0.3) / 4\n\n return scores\n\n @staticmethod\n def constant_bump(x, x_low, x_high, decay=0.025):\n return np.select(condlist=[x <= x_low, x >= x_high],\n choicelist=[np.exp(- (x - x_low) ** 2 / decay),\n np.exp(- (x - x_high) ** 2 / decay)],\n default=np.ones_like(x))\n\ndef mols2grid_image(mols, molsPerRow):\n mols = [e if e is not None else Chem.RWMol() for e in mols]\n\n for mol in mols:\n AllChem.Compute2DCoords(mol)\n\n return Draw.MolsToGridImage(mols, molsPerRow=molsPerRow, subImgSize=(150, 150))\n\n\ndef classification_report(data, model, session, sample=False):\n _, _, _, a, x, _, f, _, _ = data.next_validation_batch()\n\n n, e = session.run([model.nodes_gumbel_argmax, model.edges_gumbel_argmax] if sample else [\n model.nodes_argmax, model.edges_argmax], feed_dict={model.edges_labels: a, model.nodes_labels: x,\n model.node_features: f, model.training: False,\n model.variational: False})\n n, e = np.argmax(n, axis=-1), np.argmax(e, axis=-1)\n\n y_true = e.flatten()\n y_pred = a.flatten()\n target_names = [str(Chem.rdchem.BondType.values[int(e)]) for e in data.bond_decoder_m.values()]\n\n print('######## Classification Report ########\\n')\n print(sk_classification_report(y_true, y_pred, labels=list(range(len(target_names))),\n target_names=target_names))\n\n print('######## Confusion Matrix ########\\n')\n print(confusion_matrix(y_true, y_pred, labels=list(range(len(target_names)))))\n\n y_true = n.flatten()\n y_pred = x.flatten()\n target_names = [Chem.Atom(e).GetSymbol() for e in data.atom_decoder_m.values()]\n\n print('######## Classification Report ########\\n')\n print(sk_classification_report(y_true, y_pred, labels=list(range(len(target_names))),\n target_names=target_names))\n\n print('\\n######## Confusion Matrix ########\\n')\n print(confusion_matrix(y_true, y_pred, labels=list(range(len(target_names)))))\n\n\ndef reconstructions(data, model, session, batch_dim=10, sample=False):\n m0, _, _, a, x, _, f, _, _ = data.next_train_batch(batch_dim)\n\n n, e = session.run([model.nodes_gumbel_argmax, model.edges_gumbel_argmax] if sample else [\n model.nodes_argmax, model.edges_argmax], feed_dict={model.edges_labels: a, model.nodes_labels: x,\n model.node_features: f, model.training: False,\n model.variational: False})\n n, e = np.argmax(n, axis=-1), np.argmax(e, axis=-1)\n\n m1 = np.array([e if e is not None else Chem.RWMol() for e in [data.matrices2mol(n_, e_, strict=True)\n for n_, e_ in zip(n, e)]])\n\n mols = np.vstack((m0, m1)).T.flatten()\n\n return mols\n\n\ndef samples(data, model, session, embeddings, sample=False):\n n, e = session.run([model.nodes_gumbel_argmax, model.edges_gumbel_argmax] if sample else [\n model.nodes_argmax, model.edges_argmax], feed_dict={\n model.embeddings: embeddings, model.training: False})\n n, e = np.argmax(n, axis=-1), np.argmax(e, axis=-1)\n\n mols = [data.matrices2mol(n_, e_, strict=True) for n_, e_ in zip(n, e)]\n\n return mols\n\n\ndef all_scores(mols, data, norm=False, reconstruction=False):\n m0 = {k: list(filter(lambda e: e is not None, v)) for k, v in {\n 'NP score': MolecularMetrics.natural_product_scores(mols, norm=norm),\n 'QED score': MolecularMetrics.quantitative_estimation_druglikeness_scores(mols),\n 'logP score': MolecularMetrics.water_octanol_partition_coefficient_scores(mols, norm=norm),\n 'SA score': MolecularMetrics.synthetic_accessibility_score_scores(mols, norm=norm),\n 'diversity score': MolecularMetrics.diversity_scores(mols, data),\n 'drugcandidate score': MolecularMetrics.drugcandidate_scores(mols, data)}.items()}\n\n m1 = {'valid score': MolecularMetrics.valid_total_score(mols) * 100,\n 'unique score': MolecularMetrics.unique_total_score(mols) * 100,\n 'novel score': MolecularMetrics.novel_total_score(mols, data) * 100}\n\n return m0, m1\n"
] | [
[
"numpy.ones_like",
"numpy.random.choice",
"numpy.argmax",
"numpy.mean",
"numpy.exp",
"numpy.vstack"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
akaszynski/keepa | [
"ffc35edc2f7a4601408b0f0a22a8856be88dcb3e"
] | [
"keepa/interface.py"
] | [
"\"\"\"Interface module to download Amazon product and history data from\nkeepa.com\n\"\"\"\n\nimport requests\nimport asyncio\nimport datetime\nimport json\nimport logging\nimport time\nfrom functools import wraps\n\nimport aiohttp\nimport numpy as np\nimport pandas as pd\nfrom tqdm import tqdm\n\nfrom keepa.query_keys import DEAL_REQUEST_KEYS, PRODUCT_REQUEST_KEYS\n\n\ndef is_documented_by(original):\n \"\"\"Avoid copying the documentation\"\"\"\n\n def wrapper(target):\n target.__doc__ = original.__doc__\n return target\n\n return wrapper\n\n\nlog = logging.getLogger(__name__)\nlog.setLevel('DEBUG')\n\n# hardcoded ordinal time from\nKEEPA_ST_ORDINAL = np.datetime64('2011-01-01')\n\n# Request limit\nREQUEST_LIMIT = 100\n\n# Status code dictionary/key\nSCODES = {'400': 'REQUEST_REJECTED',\n '402': 'PAYMENT_REQUIRED',\n '405': 'METHOD_NOT_ALLOWED',\n '429': 'NOT_ENOUGH_TOKEN'}\n\n# domain codes\n# Valid values: [ 1: com | 2: co.uk | 3: de | 4: fr | 5:\n# co.jp | 6: ca | 7: cn | 8: it | 9: es | 10: in | 11: com.mx ]\nDCODES = ['RESERVED', 'US', 'GB', 'DE', 'FR', 'JP', 'CA', 'CN', 'IT', 'ES',\n 'IN', 'MX']\n\n# csv indices. used when parsing csv and stats fields.\n# https://github.com/keepacom/api_backend\n # see api_backend/src/main/java/com/keepa/api/backend/structs/Product.java\n # [index in csv, key name, isfloat(is price or rating)]\ncsv_indices = [[0, 'AMAZON', True],\n [1, 'NEW', True],\n [2, 'USED', True],\n [3, 'SALES', False],\n [4, 'LISTPRICE', True],\n [5, 'COLLECTIBLE', True],\n [6, 'REFURBISHED', True],\n [7, 'NEW_FBM_SHIPPING', True],\n [8, 'LIGHTNING_DEAL', True],\n [9, 'WAREHOUSE', True],\n [10, 'NEW_FBA', True],\n [11, 'COUNT_NEW', False],\n [12, 'COUNT_USED', False],\n [13, 'COUNT_REFURBISHED', False],\n [14, 'CollectableOffers', False],\n [15, 'EXTRA_INFO_UPDATES', False],\n [16, 'RATING', True],\n [17, 'COUNT_REVIEWS', False],\n [18, 'BUY_BOX_SHIPPING', True],\n [19, 'USED_NEW_SHIPPING', True],\n [20, 'USED_VERY_GOOD_SHIPPING', True],\n [21, 'USED_GOOD_SHIPPING', True],\n [22, 'USED_ACCEPTABLE_SHIPPING', True],\n [23, 'COLLECTIBLE_NEW_SHIPPING', True],\n [24, 'COLLECTIBLE_VERY_GOOD_SHIPPING', True],\n [25, 'COLLECTIBLE_GOOD_SHIPPING', True],\n [26, 'COLLECTIBLE_ACCEPTABLE_SHIPPING', True],\n [27, 'REFURBISHED_SHIPPING', True],\n [28, 'EBAY_NEW_SHIPPING', True],\n [29, 'EBAY_USED_SHIPPING', True],\n [30, 'TRADE_IN', True],\n [31, 'RENT', False]]\n\n\ndef _parse_stats(stats, to_datetime):\n \"\"\"Parses *numeric* stats object. There is no need to parse strings or list of strings.\\n\n Keepa stats object response documentation: https://keepa.com/#!discuss/t/statistics-object/1308\"\"\"\n\n stats_keys_parse_not_required = {\n 'buyBoxSellerId',\n 'sellerIdsLowestFBA',\n 'sellerIdsLowestFBM',\n 'buyBoxShippingCountry',\n 'buyBoxAvailabilityMessage',\n }\n stats_parsed = {}\n\n for stat_key, stat_value in stats.items():\n if stat_key in stats_keys_parse_not_required:\n stat_value = None\n\n elif isinstance(stat_value, int) and stat_value < 0: # -1 or -2 means not exist. 0 doesn't mean not exist.\n stat_value = None\n\n if stat_value is not None:\n if stat_key == 'lastOffersUpdate':\n stats_parsed[stat_key] = keepa_minutes_to_time([stat_value], to_datetime)[0]\n elif isinstance(stat_value, list) and len(stat_value) > 0:\n stat_value_dict = {}\n convert_time_in_value_pair = any(map(lambda v: v is not None and isinstance(v, list), stat_value))\n\n for ind, key, isfloat in csv_indices:\n stat_value_item = stat_value[ind] if ind < len(stat_value) else None\n\n def normalize_value(v):\n if v < 0:\n return None\n\n if isfloat:\n v = float(v) / 100\n if key == 'RATING':\n v = v * 10\n\n return v\n\n if stat_value_item is not None:\n if convert_time_in_value_pair:\n stat_value_time, stat_value_item = stat_value_item\n stat_value_item = normalize_value(stat_value_item)\n if stat_value_item is not None:\n stat_value_time = keepa_minutes_to_time([stat_value_time], to_datetime)[0]\n stat_value_item = (stat_value_time, stat_value_item)\n else:\n stat_value_item = normalize_value(stat_value_item)\n\n if stat_value_item is not None:\n stat_value_dict[key] = stat_value_item\n\n if len(stat_value_dict) > 0:\n stats_parsed[stat_key] = stat_value_dict\n else:\n stats_parsed[stat_key] = stat_value\n\n return stats_parsed\n\n\n_seller_time_data_keys = ['trackedSince', 'lastUpdate']\n\ndef _parse_seller(seller_raw_response, to_datetime):\n sellers = list(seller_raw_response.values())\n for seller in sellers:\n\n def convert_time_data(key):\n date_val = seller.get(key, None)\n if date_val is not None:\n return (key, keepa_minutes_to_time([date_val], to_datetime)[0])\n else:\n return None\n\n seller.update(filter(lambda p: p is not None, map(convert_time_data, _seller_time_data_keys)))\n\n return dict(map(lambda seller: (seller['sellerId'], seller), sellers))\n\n\ndef parse_csv(csv, to_datetime=True, out_of_stock_as_nan=True):\n \"\"\"Parses csv list from keepa into a python dictionary.\n\n Parameters\n ----------\n csv : list\n csv list from keepa\n\n to_datetime : bool, optional\n Modifies numpy minutes to datetime.datetime values.\n Default True.\n\n out_of_stock_as_nan : bool, optional\n When True, prices are NAN when price category is out of stock.\n When False, prices are -0.01\n Default True\n\n Returns\n -------\n product_data : dict\n Dictionary containing the following fields with timestamps:\n\n AMAZON: Amazon price history\n\n NEW: Marketplace/3rd party New price history - Amazon is\n considered to be part of the marketplace as well, so if\n Amazon has the overall lowest new (!) price, the\n marketplace new price in the corresponding time interval\n will be identical to the Amazon price (except if there is\n only one marketplace offer). Shipping and Handling costs\n not included!\n\n USED: Marketplace/3rd party Used price history\n\n SALES: Sales Rank history. Not every product has a Sales Rank.\n\n LISTPRICE: List Price history\n\n 5 COLLECTIBLE: Collectible Price history\n\n 6 REFURBISHED: Refurbished Price history\n\n 7 NEW_FBM_SHIPPING: 3rd party (not including Amazon) New price\n history including shipping costs, only fulfilled by\n merchant (FBM).\n\n 8 LIGHTNING_DEAL: 3rd party (not including Amazon) New price\n history including shipping costs, only fulfilled by\n merchant (FBM).\n\n 9 WAREHOUSE: Amazon Warehouse Deals price history. Mostly of\n used condition, rarely new.\n\n 10 NEW_FBA: Price history of the lowest 3rd party (not\n including Amazon/Warehouse) New offer that is fulfilled\n by Amazon\n\n 11 COUNT_NEW: New offer count history\n\n 12 COUNT_USED: Used offer count history\n\n 13 COUNT_REFURBISHED: Refurbished offer count history\n\n 14 COUNT_COLLECTIBLE: Collectible offer count history\n\n 16 RATING: The product's rating history. A rating is an\n integer from 0 to 50 (e.g. 45 = 4.5 stars)\n\n 17 COUNT_REVIEWS: The product's review count history.\n\n 18 BUY_BOX_SHIPPING: The price history of the buy box. If no\n offer qualified for the buy box the price has the value\n -1. Including shipping costs. The ``buybox`` parameter\n must be True for this field to be in the data.\n\n 19 USED_NEW_SHIPPING: \"Used - Like New\" price history\n including shipping costs.\n\n 20 USED_VERY_GOOD_SHIPPING: \"Used - Very Good\" price history\n including shipping costs.\n\n 21 USED_GOOD_SHIPPING: \"Used - Good\" price history including\n shipping costs.\n\n 22 USED_ACCEPTABLE_SHIPPING: \"Used - Acceptable\" price history\n including shipping costs.\n\n 23 COLLECTIBLE_NEW_SHIPPING: \"Collectible - Like New\" price\n history including shipping costs.\n\n 24 COLLECTIBLE_VERY_GOOD_SHIPPING: \"Collectible - Very Good\"\n price history including shipping costs.\n\n 25 COLLECTIBLE_GOOD_SHIPPING: \"Collectible - Good\" price\n history including shipping costs.\n\n 26 COLLECTIBLE_ACCEPTABLE_SHIPPING: \"Collectible - Acceptable\"\n price history including shipping costs.\n\n 27 REFURBISHED_SHIPPING: Refurbished price history including\n shipping costs.\n\n 30 TRADE_IN: The trade in price history. Amazon trade-in is\n not available for every locale.\n\n 31 RENT: Rental price history. Requires use of the rental\n and offers parameter. Amazon Rental is only available\n for Amazon US.\n\n Notes\n -----\n Negative prices\n\n \"\"\"\n product_data = {}\n\n for ind, key, isfloat in csv_indices:\n if csv[ind]: # Check if entry it exists\n if 'SHIPPING' in key: # shipping price is included\n # Data goes [time0, value0, shipping0, time1, value1,\n # shipping1, ...]\n times = csv[ind][::3]\n values = np.array(csv[ind][1::3])\n values += np.array(csv[ind][2::3])\n else:\n # Data goes [time0, value0, time1, value1, ...]\n times = csv[ind][::2]\n values = np.array(csv[ind][1::2])\n\n # Convert to float price if applicable\n if isfloat:\n nan_mask = values < 0\n values = values.astype(np.float)/100\n if out_of_stock_as_nan:\n values[nan_mask] = np.nan\n\n if key == 'RATING':\n values *= 10\n\n timeval = keepa_minutes_to_time(times, to_datetime)\n\n product_data['%s_time' % key] = timeval\n product_data[key] = values\n\n # combine time and value into a data frame using time as index\n product_data['df_%s' % key] = pd.DataFrame({'value': values}, index=timeval)\n\n return product_data\n\n\ndef format_items(items):\n \"\"\" Checks if the input items are valid and formats them \"\"\"\n if isinstance(items, list) or isinstance(items, np.ndarray):\n return np.unique(items)\n elif isinstance(items, str):\n return np.asarray([items])\n\n\nclass Keepa():\n \"\"\"Support a synchronous Python interface to keepa server.\n\n Initializes API with access key. Access key can be obtained by\n signing up for a reoccurring or one time plan at:\n https://keepa.com/#!api\n\n Parameters\n ----------\n accesskey : str\n 64 character access key string.\n\n timeout : float, optional\n Default timeout when issuing any request. This is not a time\n limit on the entire response download; rather, an exception is\n raised if the server has not issued a response for timeout\n seconds. Setting this to 0 disables the timeout, but will\n cause any request to hang indefiantly should keepa.com be down\n\n Examples\n --------\n Create the api object\n\n >>> import keepa\n >>> mykey = 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'\n >>> api = keepa.Keepa(mykey)\n\n Request data from two ASINs\n\n >>> products = api.query(['0439064872', '1426208081'])\n\n Print item details\n\n >>> print('Item 1')\n >>> print('\\t ASIN: {:s}'.format(products[0]['asin']))\n >>> print('\\t Title: {:s}'.format(products[0]['title']))\n\n Print item price\n\n >>> usedprice = products[0]['data']['MarketplaceUsed']\n >>> usedtimes = products[0]['data']['MarketplaceUsed_time']\n >>> print('\\t Used price: ${:.2f}'.format(usedprice[-1]))\n >>> print('\\t as of: {:s}'.format(str(usedtimes[-1])))\n \"\"\"\n\n def __init__(self, accesskey, timeout=10):\n self.accesskey = accesskey\n self.status = None\n self.tokens_left = 0\n self._timeout = timeout\n\n # Store user's available tokens\n log.info('Connecting to keepa using key ending in %s', accesskey[-6:])\n self.update_status()\n log.info('%d tokens remain', self.tokens_left)\n\n @property\n def time_to_refill(self):\n \"\"\" Returns the time to refill in seconds \"\"\"\n # Get current timestamp in milliseconds from UNIX epoch\n now = int(time.time() * 1000)\n timeatrefile = self.status['timestamp'] + self.status['refillIn']\n\n # wait plus one second fudge factor\n timetorefil = timeatrefile - now + 1000\n if timetorefil < 0:\n timetorefil = 0\n\n # Account for negative tokens left\n if self.tokens_left < 0:\n timetorefil += (abs(self.tokens_left) / self.status['refillRate']) * 60000\n\n # Return value in seconds\n return timetorefil / 1000.0\n\n def update_status(self):\n \"\"\" Updates available tokens \"\"\"\n self.status = self._request('token', {'key': self.accesskey}, wait=False)\n\n def wait_for_tokens(self):\n \"\"\"Checks any remaining tokens and waits if none are available. \"\"\"\n self.update_status()\n\n # Wait if no tokens available\n if self.tokens_left <= 0:\n tdelay = self.time_to_refill\n log.warning('Waiting %.0f seconds for additional tokens' % tdelay)\n time.sleep(tdelay)\n self.update_status()\n\n def query(self, items, stats=None, domain='US', history=True,\n offers=None, update=None, to_datetime=True,\n rating=False, out_of_stock_as_nan=True, stock=False,\n product_code_is_asin=True, progress_bar=True, buybox=False,\n wait=True, days=None, only_live_offers=None, raw=False):\n \"\"\"Performs a product query of a list, array, or single ASIN.\n\n Returns a list of product data with one entry for each\n product.\n\n Parameters\n ----------\n items : str, list, np.ndarray\n A list, array, or single asin, UPC, EAN, or ISBN-13\n identifying a product. ASINs should be 10 characters and\n match a product on Amazon. Items not matching Amazon\n product or duplicate Items will return no data. When\n using non-ASIN items, set product_code_is_asin to False\n\n stats : int or date, optional\n No extra token cost. If specified the product object will\n have a stats field with quick access to current prices,\n min/max prices and the weighted mean values. If the offers\n parameter was used it will also provide stock counts and\n buy box information.\n\n You can provide the stats parameter in two forms:\n\n Last x days (positive integer value): calculates the stats\n of the last x days, where x is the value of the stats\n parameter. Interval: You can provide a date range for the\n stats calculation. You can specify the range via two\n timestamps (unix epoch time milliseconds) or two date\n strings (ISO8601, with or without time in UTC).\n\n domain : str, optional\n One of the following Amazon domains: RESERVED, US, GB, DE,\n FR, JP, CA, CN, IT, ES, IN, MX Defaults to US.\n\n offers : int, optional\n Adds available offers to product data. Default 0. Must\n be between 20 and 100.\n\n update : int, optional\n if data is older than the input integer, keepa will\n update their database and return live data. If set to 0\n (live data), request may cost an additional token.\n Default None\n\n history : bool, optional\n When set to True includes the price, sales, and offer\n history of a product. Set to False to reduce request time\n if data is not required. Default True\n\n rating : bool, optional\n When set to to True, includes the existing RATING and\n COUNT_REVIEWS history of the csv field. Default False\n\n to_datetime : bool, optional\n Modifies numpy minutes to datetime.datetime values.\n Default True.\n\n out_of_stock_as_nan : bool, optional\n When True, prices are NAN when price category is out of\n stock. When False, prices are -0.01 Default True\n\n stock : bool, optional\n Can only be used if the offers parameter is also True. If\n True, the stock will be collected for all retrieved live\n offers. Note: We can only determine stock up 10 qty. Stock\n retrieval takes additional time, expect the request to\n take longer. Existing stock history will be included\n whether or not the stock parameter is used.\n\n product_code_is_asin : bool, optional\n The type of product code you are requesting. True when\n product code is an ASIN, an Amazon standard identification\n number, or 'code', for UPC, EAN, or ISBN-13 codes.\n\n progress_bar : bool, optional\n Display a progress bar using ``tqdm``. Defaults to\n ``True``.\n\n buybox : bool, optional\n Additional token cost: 2 per product). When true the\n product and statistics object will include all available\n buy box related data:\n\n - current price, price history, and statistical values\n - buyBoxSellerIdHistory\n - all buy box fields in the statistics object\n\n The buybox parameter\n does not trigger a fresh data collection. If the offers\n parameter is used the buybox parameter is ignored, as the\n offers parameter also provides access to all buy box\n related data. To access the statistics object the stats\n parameter is required.\n\n wait : bool, optional\n Wait available token before doing effective query,\n Defaults to ``True``.\n\n only_live_offers : bool, optional\n If set to True, the product object will only include live\n marketplace offers (when used in combination with the\n offers parameter). If you do not need historical offers\n use this to have them removed from the response. This can\n improve processing time and considerably decrease the size\n of the response. Default None\n\n days : int, optional\n Any positive integer value. If specified and has positive\n value X the product object will limit all historical data\n to the recent X days. This includes the csv,\n buyBoxSellerIdHistory, salesRanks, offers and\n offers.offerCSV fields. If you do not need old historical\n data use this to have it removed from the response. This\n can improve processing time and considerably decrease the\n size of the response. The parameter does not use calendar\n days - so 1 day equals the last 24 hours. The oldest data\n point of each field may have a date value which is out of\n the specified range. This means the value of the field has\n not changed since that date and is still active. Default\n ``None``\n\n raw : bool, optional\n When ``True``, return the raw request response. This is\n only available in the non-async class.\n\n Returns\n -------\n list\n List of products when ``raw=False``. Each product\n within the list is a dictionary. The keys of each item\n may vary, so see the keys within each product for further\n details.\n\n Each product should contain at a minimum a \"data\" key\n containing a formatted dictionary. For the available\n fields see the notes section\n\n When ``raw=True``, a list of unparsed responses are\n returned as :class:`requests.models.Response`.\n\n See: https://keepa.com/#!discuss/t/product-object/116\n\n Notes\n -----\n The following are data fields a product dictionary\n\n AMAZON\n Amazon price history\n\n NEW\n Marketplace/3rd party New price history - Amazon is\n considered to be part of the marketplace as well, so if\n Amazon has the overall lowest new (!) price, the\n marketplace new price in the corresponding time interval\n will be identical to the Amazon price (except if there is\n only one marketplace offer). Shipping and Handling costs\n not included!\n\n USED\n Marketplace/3rd party Used price history\n\n SALES\n Sales Rank history. Not every product has a Sales Rank.\n\n LISTPRICE\n List Price history\n\n COLLECTIBLE\n Collectible Price history\n\n REFURBISHED\n Refurbished Price history\n\n NEW_FBM_SHIPPING\n 3rd party (not including Amazon) New price history\n including shipping costs, only fulfilled by merchant\n (FBM).\n\n LIGHTNING_DEAL\n 3rd party (not including Amazon) New price history\n including shipping costs, only fulfilled by merchant\n (FBM).\n\n WAREHOUSE\n Amazon Warehouse Deals price history. Mostly of used\n condition, rarely new.\n\n NEW_FBA\n Price history of the lowest 3rd party (not including\n Amazon/Warehouse) New offer that is fulfilled by Amazon\n\n COUNT_NEW\n New offer count history\n\n COUNT_USED\n Used offer count history\n\n COUNT_REFURBISHED\n Refurbished offer count history\n\n COUNT_COLLECTIBLE\n Collectible offer count history\n\n RATING\n The product's rating history. A rating is an integer from\n 0 to 50 (e.g. 45 = 4.5 stars)\n\n COUNT_REVIEWS\n The product's review count history.\n\n BUY_BOX_SHIPPING\n The price history of the buy box. If no offer qualified\n for the buy box the price has the value -1. Including\n shipping costs.\n\n USED_NEW_SHIPPING\n \"Used - Like New\" price history including shipping costs.\n\n USED_VERY_GOOD_SHIPPING\n \"Used - Very Good\" price history including shipping costs.\n\n USED_GOOD_SHIPPING\n \"Used - Good\" price history including shipping costs.\n\n USED_ACCEPTABLE_SHIPPING\n \"Used - Acceptable\" price history including shipping costs.\n\n COLLECTIBLE_NEW_SHIPPING\n \"Collectible - Like New\" price history including shipping\n costs.\n\n COLLECTIBLE_VERY_GOOD_SHIPPING\n \"Collectible - Very Good\" price history including shipping\n costs.\n\n COLLECTIBLE_GOOD_SHIPPING\n \"Collectible - Good\" price history including shipping\n costs.\n\n COLLECTIBLE_ACCEPTABLE_SHIPPING\n \"Collectible - Acceptable\" price history including\n shipping costs.\n\n REFURBISHED_SHIPPING\n Refurbished price history including shipping costs.\n\n TRADE_IN\n The trade in price history. Amazon trade-in is not\n available for every locale.\n\n BUY_BOX_SHIPPING\n The price history of the buy box. If no offer qualified\n for the buy box the price has the value -1. Including\n shipping costs. The ``buybox`` parameter must be True for\n this field to be in the data.\n \"\"\"\n # Format items into numpy array\n try:\n items = format_items(items)\n except BaseException:\n raise Exception('Invalid product codes input')\n assert len(items), 'No valid product codes'\n\n nitems = len(items)\n if nitems == 1:\n log.debug('Executing single product query')\n else:\n log.debug('Executing %d item product query', nitems)\n\n # check offer input\n if offers:\n if not isinstance(offers, int):\n raise TypeError('Parameter \"offers\" must be an interger')\n\n if offers > 100 or offers < 20:\n raise ValueError('Parameter \"offers\" must be between 20 and 100')\n\n # Report time to completion\n tcomplete = float(nitems - self.tokens_left) / self.status['refillRate'] - (\n 60000 - self.status['refillIn']) / 60000.0\n if tcomplete < 0.0:\n tcomplete = 0.5\n log.debug('Estimated time to complete %d request(s) is %.2f minutes',\n nitems, tcomplete)\n log.debug('\\twith a refill rate of %d token(s) per minute',\n self.status['refillRate'])\n\n # product list\n products = []\n\n pbar = None\n if progress_bar:\n pbar = tqdm(total=nitems)\n\n # Number of requests is dependent on the number of items and\n # request limit. Use available tokens first\n idx = 0 # or number complete\n while idx < nitems:\n nrequest = nitems - idx\n\n # cap request\n if nrequest > REQUEST_LIMIT:\n nrequest = REQUEST_LIMIT\n\n # request from keepa and increment current position\n item_request = items[idx:idx + nrequest]\n response = self._product_query(\n item_request,\n product_code_is_asin,\n stats=stats,\n domain=domain, stock=stock,\n offers=offers, update=update,\n history=history, rating=rating,\n to_datetime=to_datetime,\n out_of_stock_as_nan=out_of_stock_as_nan,\n buybox=buybox,\n wait=wait,\n days=days,\n only_live_offers=only_live_offers,\n raw=raw,\n )\n idx += nrequest\n if raw:\n products.append(response)\n else:\n products.extend(response['products'])\n\n if pbar is not None:\n pbar.update(nrequest)\n\n return products\n\n def _product_query(self, items, product_code_is_asin=True, **kwargs):\n \"\"\"Sends query to keepa server and returns parsed JSON result.\n\n Parameters\n ----------\n items : np.ndarray\n Array of asins. If UPC, EAN, or ISBN-13, as_asin must be\n False. Must be between 1 and 100 ASINs\n\n as_asin : bool, optional\n Interpret product codes as ASINs only.\n\n stats : int or date format\n Set the stats time for get sales rank inside this range\n\n domain : str\n One of the following Amazon domains:\n RESERVED, US, GB, DE, FR, JP, CA, CN, IT, ES, IN, MX\n\n offers : bool, optional\n Adds product offers to product data.\n\n update : int, optional\n If data is older than the input integer, keepa will update\n their database and return live data. If set to 0 (live\n data), then request may cost an additional token.\n\n history : bool, optional\n When set to True includes the price, sales, and offer\n history of a product. Set to False to reduce request time\n if data is not required.\n\n as_asin : bool, optional\n Queries keepa using asin codes. Otherwise, queries using\n the code key.\n\n Returns\n -------\n products : list\n List of products. Length equal to number of successful\n ASINs.\n\n refillIn : float\n Time in milliseconds to the next refill of tokens.\n\n refilRate : float\n Number of tokens refilled per minute\n\n timestamp : float\n\n tokensLeft : int\n Remaining tokens\n\n tz : int\n Timezone. 0 is UTC\n\n \"\"\"\n # ASINs convert to comma joined string\n assert len(items) <= 100\n\n if product_code_is_asin:\n kwargs['asin'] = ','.join(items)\n else:\n kwargs['code'] = ','.join(items)\n\n kwargs['key'] = self.accesskey\n kwargs['domain'] = DCODES.index(kwargs['domain'])\n\n # Convert bool values to 0 and 1.\n kwargs['stock'] = int(kwargs['stock'])\n kwargs['history'] = int(kwargs['history'])\n kwargs['rating'] = int(kwargs['rating'])\n kwargs['buybox'] = int(kwargs['buybox'])\n\n if kwargs['update'] is None:\n del kwargs['update']\n else:\n kwargs['update'] = int(kwargs['update'])\n\n if kwargs['offers'] is None:\n del kwargs['offers']\n else:\n kwargs['offers'] = int(kwargs['offers'])\n\n if kwargs['only_live_offers'] is None:\n del kwargs['only_live_offers']\n else:\n kwargs['only-live-offers'] = int(kwargs.pop('only_live_offers'))\n # Keepa's param actually doesn't use snake_case.\n # I believe using snake case throughout the Keepa interface is better.\n\n if kwargs['days'] is None:\n del kwargs['days']\n else:\n assert kwargs['days'] > 0\n\n if kwargs['stats'] is None:\n del kwargs['stats']\n\n out_of_stock_as_nan = kwargs.pop('out_of_stock_as_nan', True)\n to_datetime = kwargs.pop('to_datetime', True)\n\n # Query and replace csv with parsed data if history enabled\n wait = kwargs.get(\"wait\")\n kwargs.pop(\"wait\", None)\n raw_response = kwargs.pop('raw', False)\n response = self._request('product', kwargs, wait=wait,\n raw_response=raw_response)\n\n if kwargs['history'] and not raw_response:\n for product in response['products']:\n if product['csv']: # if data exists\n product['data'] = parse_csv(product['csv'],\n to_datetime,\n out_of_stock_as_nan)\n\n if kwargs.get('stats', None) and not raw_response:\n for product in response['products']:\n stats = product.get('stats', None)\n if stats:\n product['stats_parsed'] = _parse_stats(stats, to_datetime)\n\n return response\n\n def best_sellers_query(self, category, rank_avg_range=0, domain='US', wait=True):\n \"\"\"\n Retrieve an ASIN list of the most popular products based on\n sales in a specific category or product group. See\n \"search_for_categories\" for information on how to get a\n category.\n\n Root category lists (e.g. \"Home & Kitchen\") or product group\n lists contain up to 100,000 ASINs.\n\n Sub-category lists (e.g. \"Home Entertainment Furniture\")\n contain up to 3,000 ASINs. As we only have access to the\n product's primary sales rank and not the ones of all\n categories it is listed in, the sub-category lists are created\n by us based on the product's primary sales rank and do not\n reflect the actual ordering on Amazon.\n\n Lists are ordered, starting with the best selling product.\n\n Lists are updated daily. If a product does not have an\n accessible sales rank it will not be included in the\n lists. This in particular affects many products in the\n Clothing and Sports & Outdoors categories.\n\n We can not correctly identify the sales rank reference\n category in all cases, so some products may be misplaced.\n\n Parameters\n ----------\n category : str\n The category node id of the category you want to request\n the best sellers list for. You can find category node ids\n via the category search \"search_for_categories\"\n\n domain : str\n Amazon locale you want to access. Must be one of the following\n RESERVED, US, GB, DE, FR, JP, CA, CN, IT, ES, IN, MX\n Default US\n\n wait : bool, optional\n Wait available token before doing effective query.\n Defaults to ``True``.\n\n Returns\n -------\n best_sellers : list\n List of best seller ASINs\n \"\"\"\n assert domain in DCODES, 'Invalid domain code'\n\n payload = {'key': self.accesskey,\n 'domain': DCODES.index(domain),\n 'category': category,\n 'range': rank_avg_range}\n\n response = self._request('bestsellers', payload, wait=wait)\n if 'bestSellersList' in response:\n return response['bestSellersList']['asinList']\n else: # pragma: no cover\n log.info('Best sellers search results not yet available')\n\n def search_for_categories(self, searchterm, domain='US', wait=True):\n \"\"\"Searches for categories from Amazon.\n\n Parameters\n ----------\n searchterm : str\n Input search term.\n\n wait : bool, optional\n Wait available token before doing effective query.\n Defaults to ``True``.\n\n Returns\n -------\n categories : list\n The response contains a categories list with all matching\n categories.\n\n Examples\n --------\n Print all categories from science\n\n >>> categories = api.search_for_categories('science')\n >>> for cat_id in categories:\n >>> print(cat_id, categories[cat_id]['name'])\n\n \"\"\"\n assert domain in DCODES, 'Invalid domain code'\n\n payload = {'key': self.accesskey,\n 'domain': DCODES.index(domain),\n 'type': 'category',\n 'term': searchterm}\n\n response = self._request('search', payload, wait=wait)\n if response['categories'] == {}: # pragma no cover\n raise Exception('Categories search results not yet available ' +\n 'or no search terms found.')\n else:\n return response['categories']\n\n def category_lookup(self, category_id, domain='US',\n include_parents=0, wait=True):\n \"\"\"\n Return root categories given a categoryId.\n\n Parameters\n ----------\n category_id : int\n ID for specific category or 0 to return a list of root\n categories.\n\n domain : str\n Amazon locale you want to access. Must be one of the following\n RESERVED, US, GB, DE, FR, JP, CA, CN, IT, ES, IN, MX\n Default US\n\n include_parents : int\n Include parents.\n\n wait : bool, optional\n Wait available token before doing effective query.\n Defaults to ``True``.\n\n Returns\n -------\n categories : list\n Output format is the same as search_for_categories.\n\n Examples\n --------\n Use 0 to return all root categories\n >>> categories = api.category_lookup(0)\n\n Print all root categories\n >>> for cat_id in categories:\n >>> print(cat_id, categories[cat_id]['name'])\n \"\"\"\n assert domain in DCODES, 'Invalid domain code'\n\n payload = {'key': self.accesskey,\n 'domain': DCODES.index(domain),\n 'category': category_id,\n 'parents': include_parents}\n\n response = self._request('category', payload, wait=wait)\n if response['categories'] == {}: # pragma no cover\n raise Exception('Category lookup results not yet available or no' +\n 'match found.')\n else:\n return response['categories']\n\n def seller_query(self, seller_id, domain='US', to_datetime=True, \n storefront=False, update=None, wait=True):\n \"\"\"Receives seller information for a given seller id. If a\n seller is not found no tokens will be consumed.\n\n Token cost: 1 per requested seller\n\n Parameters\n ----------\n seller_id : str or list\n The seller id of the merchant you want to request. For\n batch requests, you may submit a list of 100 seller_ids.\n The seller id can also be found on Amazon on seller\n profile pages in the seller parameter of the URL as well\n as in the offers results from a product query.\n\n domain : str, optional\n One of the following Amazon domains: RESERVED, US, GB, DE,\n FR, JP, CA, CN, IT, ES, IN, MX Defaults to US.\n\n storefront : bool, optional\n If specified the seller object will contain additional\n information about what items the seller is listing on Amazon.\n This includes a list of ASINs as well as the total amount of\n items the seller has listed. The following seller object\n fields will be set if data is available: asinList,\n asinListLastSeen, totalStorefrontAsinsCSV. If no data is\n available no additional tokens will be consumed. The ASIN\n list can contain up to 100,000 items. As using the storefront\n parameter does not trigger any new collection it does not\n increase the processing time of the request, though the\n response may be much bigger in size. The total storefront\n ASIN count will not be updated, only historical data will\n be provided (when available).\n\n update : int, optional\n Positive integer value. If the last live data collection from\n the Amazon storefront page is older than update hours force a\n new collection. Use this parameter in conjunction with the\n storefront parameter. Token cost will only be applied if a new\n collection is triggered.\n\n Using this parameter you can achieve the following:\n\n - Retrieve data from Amazon: a storefront ASIN list\n containing up to 2,400 ASINs, in addition to all ASINs\n already collected through our database.\n - Force a refresh: Always retrieve live data with the\n value 0.\n - Retrieve the total number of listings of this seller:\n the totalStorefrontAsinsCSV field of the seller object\n will be updated.\n\n wait : bool, optional\n Wait available token before doing effective query.\n Defaults to ``True``.\n\n Returns\n -------\n seller_info : dict\n Dictionary containing one entry per input ``seller_id``.\n\n Examples\n --------\n >>> seller_info = api.seller_query('A2L77EE7U53NWQ', 'US')\n\n Notes\n -----\n Seller data is not available for Amazon China.\n \"\"\"\n if isinstance(seller_id, list):\n if len(seller_id) > 100:\n err_str = 'seller_id can contain at maximum 100 sellers'\n raise RuntimeError(err_str)\n seller = ','.join(seller_id)\n else:\n seller = seller_id\n\n payload = {'key': self.accesskey,\n 'domain': DCODES.index(domain),\n 'seller': seller}\n\n if storefront:\n payload[\"storefront\"] = int(storefront)\n if update:\n payload[\"update\"] = update\n\n response = self._request('seller', payload, wait=wait)\n return _parse_seller(response['sellers'], to_datetime)\n\n def product_finder(self, product_parms, domain='US', wait=True):\n \"\"\"Query the keepa product database to find products matching\n your criteria. Almost all product fields can be searched for\n and sorted by.\n\n Parameters\n ----------\n product_parms : dict\n Dictionary containing one or more of the following keys:\n\n - ``'author': str``\n - ``'availabilityAmazon': int``\n - ``'avg180_AMAZON_lte': int``\n - ``'avg180_AMAZON_gte': int``\n - ``'avg180_BUY_BOX_SHIPPING_lte': int``\n - ``'avg180_BUY_BOX_SHIPPING_gte': int``\n - ``'avg180_COLLECTIBLE_lte': int``\n - ``'avg180_COLLECTIBLE_gte': int``\n - ``'avg180_COUNT_COLLECTIBLE_lte': int``\n - ``'avg180_COUNT_COLLECTIBLE_gte': int``\n - ``'avg180_COUNT_NEW_lte': int``\n - ``'avg180_COUNT_NEW_gte': int``\n - ``'avg180_COUNT_REFURBISHED_lte': int``\n - ``'avg180_COUNT_REFURBISHED_gte': int``\n - ``'avg180_COUNT_REVIEWS_lte': int``\n - ``'avg180_COUNT_REVIEWS_gte': int``\n - ``'avg180_COUNT_USED_lte': int``\n - ``'avg180_COUNT_USED_gte': int``\n - ``'avg180_EBAY_NEW_SHIPPING_lte': int``\n - ``'avg180_EBAY_NEW_SHIPPING_gte': int``\n - ``'avg180_EBAY_USED_SHIPPING_lte': int``\n - ``'avg180_EBAY_USED_SHIPPING_gte': int``\n - ``'avg180_LIGHTNING_DEAL_lte': int``\n - ``'avg180_LIGHTNING_DEAL_gte': int``\n - ``'avg180_LISTPRICE_lte': int``\n - ``'avg180_LISTPRICE_gte': int``\n - ``'avg180_NEW_lte': int``\n - ``'avg180_NEW_gte': int``\n - ``'avg180_NEW_FBA_lte': int``\n - ``'avg180_NEW_FBA_gte': int``\n - ``'avg180_NEW_FBM_SHIPPING_lte': int``\n - ``'avg180_NEW_FBM_SHIPPING_gte': int``\n - ``'avg180_RATING_lte': int``\n - ``'avg180_RATING_gte': int``\n - ``'avg180_REFURBISHED_lte': int``\n - ``'avg180_REFURBISHED_gte': int``\n - ``'avg180_REFURBISHED_SHIPPING_lte': int``\n - ``'avg180_REFURBISHED_SHIPPING_gte': int``\n - ``'avg180_RENT_lte': int``\n - ``'avg180_RENT_gte': int``\n - ``'avg180_SALES_lte': int``\n - ``'avg180_SALES_gte': int``\n - ``'avg180_TRADE_IN_lte': int``\n - ``'avg180_TRADE_IN_gte': int``\n - ``'avg180_USED_lte': int``\n - ``'avg180_USED_gte': int``\n - ``'avg180_USED_ACCEPTABLE_SHIPPING_lte': int``\n - ``'avg180_USED_ACCEPTABLE_SHIPPING_gte': int``\n - ``'avg180_USED_GOOD_SHIPPING_lte': int``\n - ``'avg180_USED_GOOD_SHIPPING_gte': int``\n - ``'avg180_USED_NEW_SHIPPING_lte': int``\n - ``'avg180_USED_NEW_SHIPPING_gte': int``\n - ``'avg180_USED_VERY_GOOD_SHIPPING_lte': int``\n - ``'avg180_USED_VERY_GOOD_SHIPPING_gte': int``\n - ``'avg180_WAREHOUSE_lte': int``\n - ``'avg180_WAREHOUSE_gte': int``\n - ``'avg1_AMAZON_lte': int``\n - ``'avg1_AMAZON_gte': int``\n - ``'avg1_BUY_BOX_SHIPPING_lte': int``\n - ``'avg1_BUY_BOX_SHIPPING_gte': int``\n - ``'avg1_COLLECTIBLE_lte': int``\n - ``'avg1_COLLECTIBLE_gte': int``\n - ``'avg1_COUNT_COLLECTIBLE_lte': int``\n - ``'avg1_COUNT_COLLECTIBLE_gte': int``\n - ``'avg1_COUNT_NEW_lte': int``\n - ``'avg1_COUNT_NEW_gte': int``\n - ``'avg1_COUNT_REFURBISHED_lte': int``\n - ``'avg1_COUNT_REFURBISHED_gte': int``\n - ``'avg1_COUNT_REVIEWS_lte': int``\n - ``'avg1_COUNT_REVIEWS_gte': int``\n - ``'avg1_COUNT_USED_lte': int``\n - ``'avg1_COUNT_USED_gte': int``\n - ``'avg1_EBAY_NEW_SHIPPING_lte': int``\n - ``'avg1_EBAY_NEW_SHIPPING_gte': int``\n - ``'avg1_EBAY_USED_SHIPPING_lte': int``\n - ``'avg1_EBAY_USED_SHIPPING_gte': int``\n - ``'avg1_LIGHTNING_DEAL_lte': int``\n - ``'avg1_LIGHTNING_DEAL_gte': int``\n - ``'avg1_LISTPRICE_lte': int``\n - ``'avg1_LISTPRICE_gte': int``\n - ``'avg1_NEW_lte': int``\n - ``'avg1_NEW_gte': int``\n - ``'avg1_NEW_FBA_lte': int``\n - ``'avg1_NEW_FBA_gte': int``\n - ``'avg1_NEW_FBM_SHIPPING_lte': int``\n - ``'avg1_NEW_FBM_SHIPPING_gte': int``\n - ``'avg1_RATING_lte': int``\n - ``'avg1_RATING_gte': int``\n - ``'avg1_REFURBISHED_lte': int``\n - ``'avg1_REFURBISHED_gte': int``\n - ``'avg1_REFURBISHED_SHIPPING_lte': int``\n - ``'avg1_REFURBISHED_SHIPPING_gte': int``\n - ``'avg1_RENT_lte': int``\n - ``'avg1_RENT_gte': int``\n - ``'avg1_SALES_lte': int``\n - ``'avg1_SALES_lte': int``\n - ``'avg1_SALES_gte': int``\n - ``'avg1_TRADE_IN_lte': int``\n - ``'avg1_TRADE_IN_gte': int``\n - ``'avg1_USED_lte': int``\n - ``'avg1_USED_gte': int``\n - ``'avg1_USED_ACCEPTABLE_SHIPPING_lte': int``\n - ``'avg1_USED_ACCEPTABLE_SHIPPING_gte': int``\n - ``'avg1_USED_GOOD_SHIPPING_lte': int``\n - ``'avg1_USED_GOOD_SHIPPING_gte': int``\n - ``'avg1_USED_NEW_SHIPPING_lte': int``\n - ``'avg1_USED_NEW_SHIPPING_gte': int``\n - ``'avg1_USED_VERY_GOOD_SHIPPING_lte': int``\n - ``'avg1_USED_VERY_GOOD_SHIPPING_gte': int``\n - ``'avg1_WAREHOUSE_lte': int``\n - ``'avg1_WAREHOUSE_gte': int``\n - ``'avg30_AMAZON_lte': int``\n - ``'avg30_AMAZON_gte': int``\n - ``'avg30_BUY_BOX_SHIPPING_lte': int``\n - ``'avg30_BUY_BOX_SHIPPING_gte': int``\n - ``'avg30_COLLECTIBLE_lte': int``\n - ``'avg30_COLLECTIBLE_gte': int``\n - ``'avg30_COUNT_COLLECTIBLE_lte': int``\n - ``'avg30_COUNT_COLLECTIBLE_gte': int``\n - ``'avg30_COUNT_NEW_lte': int``\n - ``'avg30_COUNT_NEW_gte': int``\n - ``'avg30_COUNT_REFURBISHED_lte': int``\n - ``'avg30_COUNT_REFURBISHED_gte': int``\n - ``'avg30_COUNT_REVIEWS_lte': int``\n - ``'avg30_COUNT_REVIEWS_gte': int``\n - ``'avg30_COUNT_USED_lte': int``\n - ``'avg30_COUNT_USED_gte': int``\n - ``'avg30_EBAY_NEW_SHIPPING_lte': int``\n - ``'avg30_EBAY_NEW_SHIPPING_gte': int``\n - ``'avg30_EBAY_USED_SHIPPING_lte': int``\n - ``'avg30_EBAY_USED_SHIPPING_gte': int``\n - ``'avg30_LIGHTNING_DEAL_lte': int``\n - ``'avg30_LIGHTNING_DEAL_gte': int``\n - ``'avg30_LISTPRICE_lte': int``\n - ``'avg30_LISTPRICE_gte': int``\n - ``'avg30_NEW_lte': int``\n - ``'avg30_NEW_gte': int``\n - ``'avg30_NEW_FBA_lte': int``\n - ``'avg30_NEW_FBA_gte': int``\n - ``'avg30_NEW_FBM_SHIPPING_lte': int``\n - ``'avg30_NEW_FBM_SHIPPING_gte': int``\n - ``'avg30_RATING_lte': int``\n - ``'avg30_RATING_gte': int``\n - ``'avg30_REFURBISHED_lte': int``\n - ``'avg30_REFURBISHED_gte': int``\n - ``'avg30_REFURBISHED_SHIPPING_lte': int``\n - ``'avg30_REFURBISHED_SHIPPING_gte': int``\n - ``'avg30_RENT_lte': int``\n - ``'avg30_RENT_gte': int``\n - ``'avg30_SALES_lte': int``\n - ``'avg30_SALES_gte': int``\n - ``'avg30_TRADE_IN_lte': int``\n - ``'avg30_TRADE_IN_gte': int``\n - ``'avg30_USED_lte': int``\n - ``'avg30_USED_gte': int``\n - ``'avg30_USED_ACCEPTABLE_SHIPPING_lte': int``\n - ``'avg30_USED_ACCEPTABLE_SHIPPING_gte': int``\n - ``'avg30_USED_GOOD_SHIPPING_lte': int``\n - ``'avg30_USED_GOOD_SHIPPING_gte': int``\n - ``'avg30_USED_NEW_SHIPPING_lte': int``\n - ``'avg30_USED_NEW_SHIPPING_gte': int``\n - ``'avg30_USED_VERY_GOOD_SHIPPING_lte': int``\n - ``'avg30_USED_VERY_GOOD_SHIPPING_gte': int``\n - ``'avg30_WAREHOUSE_lte': int``\n - ``'avg30_WAREHOUSE_gte': int``\n - ``'avg7_AMAZON_lte': int``\n - ``'avg7_AMAZON_gte': int``\n - ``'avg7_BUY_BOX_SHIPPING_lte': int``\n - ``'avg7_BUY_BOX_SHIPPING_gte': int``\n - ``'avg7_COLLECTIBLE_lte': int``\n - ``'avg7_COLLECTIBLE_gte': int``\n - ``'avg7_COUNT_COLLECTIBLE_lte': int``\n - ``'avg7_COUNT_COLLECTIBLE_gte': int``\n - ``'avg7_COUNT_NEW_lte': int``\n - ``'avg7_COUNT_NEW_gte': int``\n - ``'avg7_COUNT_REFURBISHED_lte': int``\n - ``'avg7_COUNT_REFURBISHED_gte': int``\n - ``'avg7_COUNT_REVIEWS_lte': int``\n - ``'avg7_COUNT_REVIEWS_gte': int``\n - ``'avg7_COUNT_USED_lte': int``\n - ``'avg7_COUNT_USED_gte': int``\n - ``'avg7_EBAY_NEW_SHIPPING_lte': int``\n - ``'avg7_EBAY_NEW_SHIPPING_gte': int``\n - ``'avg7_EBAY_USED_SHIPPING_lte': int``\n - ``'avg7_EBAY_USED_SHIPPING_gte': int``\n - ``'avg7_LIGHTNING_DEAL_lte': int``\n - ``'avg7_LIGHTNING_DEAL_gte': int``\n - ``'avg7_LISTPRICE_lte': int``\n - ``'avg7_LISTPRICE_gte': int``\n - ``'avg7_NEW_lte': int``\n - ``'avg7_NEW_gte': int``\n - ``'avg7_NEW_FBA_lte': int``\n - ``'avg7_NEW_FBA_gte': int``\n - ``'avg7_NEW_FBM_SHIPPING_lte': int``\n - ``'avg7_NEW_FBM_SHIPPING_gte': int``\n - ``'avg7_RATING_lte': int``\n - ``'avg7_RATING_gte': int``\n - ``'avg7_REFURBISHED_lte': int``\n - ``'avg7_REFURBISHED_gte': int``\n - ``'avg7_REFURBISHED_SHIPPING_lte': int``\n - ``'avg7_REFURBISHED_SHIPPING_gte': int``\n - ``'avg7_RENT_lte': int``\n - ``'avg7_RENT_gte': int``\n - ``'avg7_SALES_lte': int``\n - ``'avg7_SALES_gte': int``\n - ``'avg7_TRADE_IN_lte': int``\n - ``'avg7_TRADE_IN_gte': int``\n - ``'avg7_USED_lte': int``\n - ``'avg7_USED_gte': int``\n - ``'avg7_USED_ACCEPTABLE_SHIPPING_lte': int``\n - ``'avg7_USED_ACCEPTABLE_SHIPPING_gte': int``\n - ``'avg7_USED_GOOD_SHIPPING_lte': int``\n - ``'avg7_USED_GOOD_SHIPPING_gte': int``\n - ``'avg7_USED_NEW_SHIPPING_lte': int``\n - ``'avg7_USED_NEW_SHIPPING_gte': int``\n - ``'avg7_USED_VERY_GOOD_SHIPPING_lte': int``\n - ``'avg7_USED_VERY_GOOD_SHIPPING_gte': int``\n - ``'avg7_WAREHOUSE_lte': int``\n - ``'avg7_WAREHOUSE_gte': int``\n - ``'avg90_AMAZON_lte': int``\n - ``'avg90_AMAZON_gte': int``\n - ``'avg90_BUY_BOX_SHIPPING_lte': int``\n - ``'avg90_BUY_BOX_SHIPPING_gte': int``\n - ``'avg90_COLLECTIBLE_lte': int``\n - ``'avg90_COLLECTIBLE_gte': int``\n - ``'avg90_COUNT_COLLECTIBLE_lte': int``\n - ``'avg90_COUNT_COLLECTIBLE_gte': int``\n - ``'avg90_COUNT_NEW_lte': int``\n - ``'avg90_COUNT_NEW_gte': int``\n - ``'avg90_COUNT_REFURBISHED_lte': int``\n - ``'avg90_COUNT_REFURBISHED_gte': int``\n - ``'avg90_COUNT_REVIEWS_lte': int``\n - ``'avg90_COUNT_REVIEWS_gte': int``\n - ``'avg90_COUNT_USED_lte': int``\n - ``'avg90_COUNT_USED_gte': int``\n - ``'avg90_EBAY_NEW_SHIPPING_lte': int``\n - ``'avg90_EBAY_NEW_SHIPPING_gte': int``\n - ``'avg90_EBAY_USED_SHIPPING_lte': int``\n - ``'avg90_EBAY_USED_SHIPPING_gte': int``\n - ``'avg90_LIGHTNING_DEAL_lte': int``\n - ``'avg90_LIGHTNING_DEAL_gte': int``\n - ``'avg90_LISTPRICE_lte': int``\n - ``'avg90_LISTPRICE_gte': int``\n - ``'avg90_NEW_lte': int``\n - ``'avg90_NEW_gte': int``\n - ``'avg90_NEW_FBA_lte': int``\n - ``'avg90_NEW_FBA_gte': int``\n - ``'avg90_NEW_FBM_SHIPPING_lte': int``\n - ``'avg90_NEW_FBM_SHIPPING_gte': int``\n - ``'avg90_RATING_lte': int``\n - ``'avg90_RATING_gte': int``\n - ``'avg90_REFURBISHED_lte': int``\n - ``'avg90_REFURBISHED_gte': int``\n - ``'avg90_REFURBISHED_SHIPPING_lte': int``\n - ``'avg90_REFURBISHED_SHIPPING_gte': int``\n - ``'avg90_RENT_lte': int``\n - ``'avg90_RENT_gte': int``\n - ``'avg90_SALES_lte': int``\n - ``'avg90_SALES_gte': int``\n - ``'avg90_TRADE_IN_lte': int``\n - ``'avg90_TRADE_IN_gte': int``\n - ``'avg90_USED_lte': int``\n - ``'avg90_USED_gte': int``\n - ``'avg90_USED_ACCEPTABLE_SHIPPING_lte': int``\n - ``'avg90_USED_ACCEPTABLE_SHIPPING_gte': int``\n - ``'avg90_USED_GOOD_SHIPPING_lte': int``\n - ``'avg90_USED_GOOD_SHIPPING_gte': int``\n - ``'avg90_USED_NEW_SHIPPING_lte': int``\n - ``'avg90_USED_NEW_SHIPPING_gte': int``\n - ``'avg90_USED_VERY_GOOD_SHIPPING_lte': int``\n - ``'avg90_USED_VERY_GOOD_SHIPPING_gte': int``\n - ``'avg90_WAREHOUSE_lte': int``\n - ``'avg90_WAREHOUSE_gte': int``\n - ``'backInStock_AMAZON': bool``\n - ``'backInStock_BUY_BOX_SHIPPING': bool``\n - ``'backInStock_COLLECTIBLE': bool``\n - ``'backInStock_COUNT_COLLECTIBLE': bool``\n - ``'backInStock_COUNT_NEW': bool``\n - ``'backInStock_COUNT_REFURBISHED': bool``\n - ``'backInStock_COUNT_REVIEWS': bool``\n - ``'backInStock_COUNT_USED': bool``\n - ``'backInStock_EBAY_NEW_SHIPPING': bool``\n - ``'backInStock_EBAY_USED_SHIPPING': bool``\n - ``'backInStock_LIGHTNING_DEAL': bool``\n - ``'backInStock_LISTPRICE': bool``\n - ``'backInStock_NEW': bool``\n - ``'backInStock_NEW_FBA': bool``\n - ``'backInStock_NEW_FBM_SHIPPING': bool``\n - ``'backInStock_RATING': bool``\n - ``'backInStock_REFURBISHED': bool``\n - ``'backInStock_REFURBISHED_SHIPPING': bool``\n - ``'backInStock_RENT': bool``\n - ``'backInStock_SALES': bool``\n - ``'backInStock_TRADE_IN': bool``\n - ``'backInStock_USED': bool``\n - ``'backInStock_USED_ACCEPTABLE_SHIPPING': bool``\n - ``'backInStock_USED_GOOD_SHIPPING': bool``\n - ``'backInStock_USED_NEW_SHIPPING': bool``\n - ``'backInStock_USED_VERY_GOOD_SHIPPING': bool``\n - ``'backInStock_WAREHOUSE': bool``\n - ``'binding': str``\n - ``'brand': str``\n - ``'buyBoxSellerId': str``\n - ``'color': str``\n - ``'couponOneTimeAbsolute_lte': int``\n - ``'couponOneTimeAbsolute_gte': int``\n - ``'couponOneTimePercent_lte': int``\n - ``'couponOneTimePercent_gte': int``\n - ``'couponSNSAbsolute_lte': int``\n - ``'couponSNSAbsolute_gte': int``\n - ``'couponSNSPercent_lte': int``\n - ``'couponSNSPercent_gte': int``\n - ``'current_AMAZON_lte': int``\n - ``'current_AMAZON_gte': int``\n - ``'current_BUY_BOX_SHIPPING_lte': int``\n - ``'current_BUY_BOX_SHIPPING_gte': int``\n - ``'current_COLLECTIBLE_lte': int``\n - ``'current_COLLECTIBLE_gte': int``\n - ``'current_COUNT_COLLECTIBLE_lte': int``\n - ``'current_COUNT_COLLECTIBLE_gte': int``\n - ``'current_COUNT_NEW_lte': int``\n - ``'current_COUNT_NEW_gte': int``\n - ``'current_COUNT_REFURBISHED_lte': int``\n - ``'current_COUNT_REFURBISHED_gte': int``\n - ``'current_COUNT_REVIEWS_lte': int``\n - ``'current_COUNT_REVIEWS_gte': int``\n - ``'current_COUNT_USED_lte': int``\n - ``'current_COUNT_USED_gte': int``\n - ``'current_EBAY_NEW_SHIPPING_lte': int``\n - ``'current_EBAY_NEW_SHIPPING_gte': int``\n - ``'current_EBAY_USED_SHIPPING_lte': int``\n - ``'current_EBAY_USED_SHIPPING_gte': int``\n - ``'current_LIGHTNING_DEAL_lte': int``\n - ``'current_LIGHTNING_DEAL_gte': int``\n - ``'current_LISTPRICE_lte': int``\n - ``'current_LISTPRICE_gte': int``\n - ``'current_NEW_lte': int``\n - ``'current_NEW_gte': int``\n - ``'current_NEW_FBA_lte': int``\n - ``'current_NEW_FBA_gte': int``\n - ``'current_NEW_FBM_SHIPPING_lte': int``\n - ``'current_NEW_FBM_SHIPPING_gte': int``\n - ``'current_RATING_lte': int``\n - ``'current_RATING_gte': int``\n - ``'current_REFURBISHED_lte': int``\n - ``'current_REFURBISHED_gte': int``\n - ``'current_REFURBISHED_SHIPPING_lte': int``\n - ``'current_REFURBISHED_SHIPPING_gte': int``\n - ``'current_RENT_lte': int``\n - ``'current_RENT_gte': int``\n - ``'current_SALES_lte': int``\n - ``'current_SALES_gte': int``\n - ``'current_TRADE_IN_lte': int``\n - ``'current_TRADE_IN_gte': int``\n - ``'current_USED_lte': int``\n - ``'current_USED_gte': int``\n - ``'current_USED_ACCEPTABLE_SHIPPING_lte': int``\n - ``'current_USED_ACCEPTABLE_SHIPPING_gte': int``\n - ``'current_USED_GOOD_SHIPPING_lte': int``\n - ``'current_USED_GOOD_SHIPPING_gte': int``\n - ``'current_USED_NEW_SHIPPING_lte': int``\n - ``'current_USED_NEW_SHIPPING_gte': int``\n - ``'current_USED_VERY_GOOD_SHIPPING_lte': int``\n - ``'current_USED_VERY_GOOD_SHIPPING_gte': int``\n - ``'current_WAREHOUSE_lte': int``\n - ``'current_WAREHOUSE_gte': int``\n - ``'delta1_AMAZON_lte': int``\n - ``'delta1_AMAZON_gte': int``\n - ``'delta1_BUY_BOX_SHIPPING_lte': int``\n - ``'delta1_BUY_BOX_SHIPPING_gte': int``\n - ``'delta1_COLLECTIBLE_lte': int``\n - ``'delta1_COLLECTIBLE_gte': int``\n - ``'delta1_COUNT_COLLECTIBLE_lte': int``\n - ``'delta1_COUNT_COLLECTIBLE_gte': int``\n - ``'delta1_COUNT_NEW_lte': int``\n - ``'delta1_COUNT_NEW_gte': int``\n - ``'delta1_COUNT_REFURBISHED_lte': int``\n - ``'delta1_COUNT_REFURBISHED_gte': int``\n - ``'delta1_COUNT_REVIEWS_lte': int``\n - ``'delta1_COUNT_REVIEWS_gte': int``\n - ``'delta1_COUNT_USED_lte': int``\n - ``'delta1_COUNT_USED_gte': int``\n - ``'delta1_EBAY_NEW_SHIPPING_lte': int``\n - ``'delta1_EBAY_NEW_SHIPPING_gte': int``\n - ``'delta1_EBAY_USED_SHIPPING_lte': int``\n - ``'delta1_EBAY_USED_SHIPPING_gte': int``\n - ``'delta1_LIGHTNING_DEAL_lte': int``\n - ``'delta1_LIGHTNING_DEAL_gte': int``\n - ``'delta1_LISTPRICE_lte': int``\n - ``'delta1_LISTPRICE_gte': int``\n - ``'delta1_NEW_lte': int``\n - ``'delta1_NEW_gte': int``\n - ``'delta1_NEW_FBA_lte': int``\n - ``'delta1_NEW_FBA_gte': int``\n - ``'delta1_NEW_FBM_SHIPPING_lte': int``\n - ``'delta1_NEW_FBM_SHIPPING_gte': int``\n - ``'delta1_RATING_lte': int``\n - ``'delta1_RATING_gte': int``\n - ``'delta1_REFURBISHED_lte': int``\n - ``'delta1_REFURBISHED_gte': int``\n - ``'delta1_REFURBISHED_SHIPPING_lte': int``\n - ``'delta1_REFURBISHED_SHIPPING_gte': int``\n - ``'delta1_RENT_lte': int``\n - ``'delta1_RENT_gte': int``\n - ``'delta1_SALES_lte': int``\n - ``'delta1_SALES_gte': int``\n - ``'delta1_TRADE_IN_lte': int``\n - ``'delta1_TRADE_IN_gte': int``\n - ``'delta1_USED_lte': int``\n - ``'delta1_USED_gte': int``\n - ``'delta1_USED_ACCEPTABLE_SHIPPING_lte': int``\n - ``'delta1_USED_ACCEPTABLE_SHIPPING_gte': int``\n - ``'delta1_USED_GOOD_SHIPPING_lte': int``\n - ``'delta1_USED_GOOD_SHIPPING_gte': int``\n - ``'delta1_USED_NEW_SHIPPING_lte': int``\n - ``'delta1_USED_NEW_SHIPPING_gte': int``\n - ``'delta1_USED_VERY_GOOD_SHIPPING_lte': int``\n - ``'delta1_USED_VERY_GOOD_SHIPPING_gte': int``\n - ``'delta1_WAREHOUSE_lte': int``\n - ``'delta1_WAREHOUSE_gte': int``\n - ``'delta30_AMAZON_lte': int``\n - ``'delta30_AMAZON_gte': int``\n - ``'delta30_BUY_BOX_SHIPPING_lte': int``\n - ``'delta30_BUY_BOX_SHIPPING_gte': int``\n - ``'delta30_COLLECTIBLE_lte': int``\n - ``'delta30_COLLECTIBLE_gte': int``\n - ``'delta30_COUNT_COLLECTIBLE_lte': int``\n - ``'delta30_COUNT_COLLECTIBLE_gte': int``\n - ``'delta30_COUNT_NEW_lte': int``\n - ``'delta30_COUNT_NEW_gte': int``\n - ``'delta30_COUNT_REFURBISHED_lte': int``\n - ``'delta30_COUNT_REFURBISHED_gte': int``\n - ``'delta30_COUNT_REVIEWS_lte': int``\n - ``'delta30_COUNT_REVIEWS_gte': int``\n - ``'delta30_COUNT_USED_lte': int``\n - ``'delta30_COUNT_USED_gte': int``\n - ``'delta30_EBAY_NEW_SHIPPING_lte': int``\n - ``'delta30_EBAY_NEW_SHIPPING_gte': int``\n - ``'delta30_EBAY_USED_SHIPPING_lte': int``\n - ``'delta30_EBAY_USED_SHIPPING_gte': int``\n - ``'delta30_LIGHTNING_DEAL_lte': int``\n - ``'delta30_LIGHTNING_DEAL_gte': int``\n - ``'delta30_LISTPRICE_lte': int``\n - ``'delta30_LISTPRICE_gte': int``\n - ``'delta30_NEW_lte': int``\n - ``'delta30_NEW_gte': int``\n - ``'delta30_NEW_FBA_lte': int``\n - ``'delta30_NEW_FBA_gte': int``\n - ``'delta30_NEW_FBM_SHIPPING_lte': int``\n - ``'delta30_NEW_FBM_SHIPPING_gte': int``\n - ``'delta30_RATING_lte': int``\n - ``'delta30_RATING_gte': int``\n - ``'delta30_REFURBISHED_lte': int``\n - ``'delta30_REFURBISHED_gte': int``\n - ``'delta30_REFURBISHED_SHIPPING_lte': int``\n - ``'delta30_REFURBISHED_SHIPPING_gte': int``\n - ``'delta30_RENT_lte': int``\n - ``'delta30_RENT_gte': int``\n - ``'delta30_SALES_lte': int``\n - ``'delta30_SALES_gte': int``\n - ``'delta30_TRADE_IN_lte': int``\n - ``'delta30_TRADE_IN_gte': int``\n - ``'delta30_USED_lte': int``\n - ``'delta30_USED_gte': int``\n - ``'delta30_USED_ACCEPTABLE_SHIPPING_lte': int``\n - ``'delta30_USED_ACCEPTABLE_SHIPPING_gte': int``\n - ``'delta30_USED_GOOD_SHIPPING_lte': int``\n - ``'delta30_USED_GOOD_SHIPPING_gte': int``\n - ``'delta30_USED_NEW_SHIPPING_lte': int``\n - ``'delta30_USED_NEW_SHIPPING_gte': int``\n - ``'delta30_USED_VERY_GOOD_SHIPPING_lte': int``\n - ``'delta30_USED_VERY_GOOD_SHIPPING_gte': int``\n - ``'delta30_WAREHOUSE_lte': int``\n - ``'delta30_WAREHOUSE_gte': int``\n - ``'delta7_AMAZON_lte': int``\n - ``'delta7_AMAZON_gte': int``\n - ``'delta7_BUY_BOX_SHIPPING_lte': int``\n - ``'delta7_BUY_BOX_SHIPPING_gte': int``\n - ``'delta7_COLLECTIBLE_lte': int``\n - ``'delta7_COLLECTIBLE_gte': int``\n - ``'delta7_COUNT_COLLECTIBLE_lte': int``\n - ``'delta7_COUNT_COLLECTIBLE_gte': int``\n - ``'delta7_COUNT_NEW_lte': int``\n - ``'delta7_COUNT_NEW_gte': int``\n - ``'delta7_COUNT_REFURBISHED_lte': int``\n - ``'delta7_COUNT_REFURBISHED_gte': int``\n - ``'delta7_COUNT_REVIEWS_lte': int``\n - ``'delta7_COUNT_REVIEWS_gte': int``\n - ``'delta7_COUNT_USED_lte': int``\n - ``'delta7_COUNT_USED_gte': int``\n - ``'delta7_EBAY_NEW_SHIPPING_lte': int``\n - ``'delta7_EBAY_NEW_SHIPPING_gte': int``\n - ``'delta7_EBAY_USED_SHIPPING_lte': int``\n - ``'delta7_EBAY_USED_SHIPPING_gte': int``\n - ``'delta7_LIGHTNING_DEAL_lte': int``\n - ``'delta7_LIGHTNING_DEAL_gte': int``\n - ``'delta7_LISTPRICE_lte': int``\n - ``'delta7_LISTPRICE_gte': int``\n - ``'delta7_NEW_lte': int``\n - ``'delta7_NEW_gte': int``\n - ``'delta7_NEW_FBA_lte': int``\n - ``'delta7_NEW_FBA_gte': int``\n - ``'delta7_NEW_FBM_SHIPPING_lte': int``\n - ``'delta7_NEW_FBM_SHIPPING_gte': int``\n - ``'delta7_RATING_lte': int``\n - ``'delta7_RATING_gte': int``\n - ``'delta7_REFURBISHED_lte': int``\n - ``'delta7_REFURBISHED_gte': int``\n - ``'delta7_REFURBISHED_SHIPPING_lte': int``\n - ``'delta7_REFURBISHED_SHIPPING_gte': int``\n - ``'delta7_RENT_lte': int``\n - ``'delta7_RENT_gte': int``\n - ``'delta7_SALES_lte': int``\n - ``'delta7_SALES_gte': int``\n - ``'delta7_TRADE_IN_lte': int``\n - ``'delta7_TRADE_IN_gte': int``\n - ``'delta7_USED_lte': int``\n - ``'delta7_USED_gte': int``\n - ``'delta7_USED_ACCEPTABLE_SHIPPING_lte': int``\n - ``'delta7_USED_ACCEPTABLE_SHIPPING_gte': int``\n - ``'delta7_USED_GOOD_SHIPPING_lte': int``\n - ``'delta7_USED_GOOD_SHIPPING_gte': int``\n - ``'delta7_USED_NEW_SHIPPING_lte': int``\n - ``'delta7_USED_NEW_SHIPPING_gte': int``\n - ``'delta7_USED_VERY_GOOD_SHIPPING_lte': int``\n - ``'delta7_USED_VERY_GOOD_SHIPPING_gte': int``\n - ``'delta7_WAREHOUSE_lte': int``\n - ``'delta7_WAREHOUSE_gte': int``\n - ``'delta90_AMAZON_lte': int``\n - ``'delta90_AMAZON_gte': int``\n - ``'delta90_BUY_BOX_SHIPPING_lte': int``\n - ``'delta90_BUY_BOX_SHIPPING_gte': int``\n - ``'delta90_COLLECTIBLE_lte': int``\n - ``'delta90_COLLECTIBLE_gte': int``\n - ``'delta90_COUNT_COLLECTIBLE_lte': int``\n - ``'delta90_COUNT_COLLECTIBLE_gte': int``\n - ``'delta90_COUNT_NEW_lte': int``\n - ``'delta90_COUNT_NEW_gte': int``\n - ``'delta90_COUNT_REFURBISHED_lte': int``\n - ``'delta90_COUNT_REFURBISHED_gte': int``\n - ``'delta90_COUNT_REVIEWS_lte': int``\n - ``'delta90_COUNT_REVIEWS_gte': int``\n - ``'delta90_COUNT_USED_lte': int``\n - ``'delta90_COUNT_USED_gte': int``\n - ``'delta90_EBAY_NEW_SHIPPING_lte': int``\n - ``'delta90_EBAY_NEW_SHIPPING_gte': int``\n - ``'delta90_EBAY_USED_SHIPPING_lte': int``\n - ``'delta90_EBAY_USED_SHIPPING_gte': int``\n - ``'delta90_LIGHTNING_DEAL_lte': int``\n - ``'delta90_LIGHTNING_DEAL_gte': int``\n - ``'delta90_LISTPRICE_lte': int``\n - ``'delta90_LISTPRICE_gte': int``\n - ``'delta90_NEW_lte': int``\n - ``'delta90_NEW_gte': int``\n - ``'delta90_NEW_FBA_lte': int``\n - ``'delta90_NEW_FBA_gte': int``\n - ``'delta90_NEW_FBM_SHIPPING_lte': int``\n - ``'delta90_NEW_FBM_SHIPPING_gte': int``\n - ``'delta90_RATING_lte': int``\n - ``'delta90_RATING_gte': int``\n - ``'delta90_REFURBISHED_lte': int``\n - ``'delta90_REFURBISHED_gte': int``\n - ``'delta90_REFURBISHED_SHIPPING_lte': int``\n - ``'delta90_REFURBISHED_SHIPPING_gte': int``\n - ``'delta90_RENT_lte': int``\n - ``'delta90_RENT_gte': int``\n - ``'delta90_SALES_lte': int``\n - ``'delta90_SALES_gte': int``\n - ``'delta90_TRADE_IN_lte': int``\n - ``'delta90_TRADE_IN_gte': int``\n - ``'delta90_USED_lte': int``\n - ``'delta90_USED_gte': int``\n - ``'delta90_USED_ACCEPTABLE_SHIPPING_lte': int``\n - ``'delta90_USED_ACCEPTABLE_SHIPPING_gte': int``\n - ``'delta90_USED_GOOD_SHIPPING_lte': int``\n - ``'delta90_USED_GOOD_SHIPPING_gte': int``\n - ``'delta90_USED_NEW_SHIPPING_lte': int``\n - ``'delta90_USED_NEW_SHIPPING_gte': int``\n - ``'delta90_USED_VERY_GOOD_SHIPPING_lte': int``\n - ``'delta90_USED_VERY_GOOD_SHIPPING_gte': int``\n - ``'delta90_WAREHOUSE_lte': int``\n - ``'delta90_WAREHOUSE_gte': int``\n - ``'deltaLast_AMAZON_lte': int``\n - ``'deltaLast_AMAZON_gte': int``\n - ``'deltaLast_BUY_BOX_SHIPPING_lte': int``\n - ``'deltaLast_BUY_BOX_SHIPPING_gte': int``\n - ``'deltaLast_COLLECTIBLE_lte': int``\n - ``'deltaLast_COLLECTIBLE_gte': int``\n - ``'deltaLast_COUNT_COLLECTIBLE_lte': int``\n - ``'deltaLast_COUNT_COLLECTIBLE_gte': int``\n - ``'deltaLast_COUNT_NEW_lte': int``\n - ``'deltaLast_COUNT_NEW_gte': int``\n - ``'deltaLast_COUNT_REFURBISHED_lte': int``\n - ``'deltaLast_COUNT_REFURBISHED_gte': int``\n - ``'deltaLast_COUNT_REVIEWS_lte': int``\n - ``'deltaLast_COUNT_REVIEWS_gte': int``\n - ``'deltaLast_COUNT_USED_lte': int``\n - ``'deltaLast_COUNT_USED_gte': int``\n - ``'deltaLast_EBAY_NEW_SHIPPING_lte': int``\n - ``'deltaLast_EBAY_NEW_SHIPPING_gte': int``\n - ``'deltaLast_EBAY_USED_SHIPPING_lte': int``\n - ``'deltaLast_EBAY_USED_SHIPPING_gte': int``\n - ``'deltaLast_LIGHTNING_DEAL_lte': int``\n - ``'deltaLast_LIGHTNING_DEAL_gte': int``\n - ``'deltaLast_LISTPRICE_lte': int``\n - ``'deltaLast_LISTPRICE_gte': int``\n - ``'deltaLast_NEW_lte': int``\n - ``'deltaLast_NEW_gte': int``\n - ``'deltaLast_NEW_FBA_lte': int``\n - ``'deltaLast_NEW_FBA_gte': int``\n - ``'deltaLast_NEW_FBM_SHIPPING_lte': int``\n - ``'deltaLast_NEW_FBM_SHIPPING_gte': int``\n - ``'deltaLast_RATING_lte': int``\n - ``'deltaLast_RATING_gte': int``\n - ``'deltaLast_REFURBISHED_lte': int``\n - ``'deltaLast_REFURBISHED_gte': int``\n - ``'deltaLast_REFURBISHED_SHIPPING_lte': int``\n - ``'deltaLast_REFURBISHED_SHIPPING_gte': int``\n - ``'deltaLast_RENT_lte': int``\n - ``'deltaLast_RENT_gte': int``\n - ``'deltaLast_SALES_lte': int``\n - ``'deltaLast_SALES_gte': int``\n - ``'deltaLast_TRADE_IN_lte': int``\n - ``'deltaLast_TRADE_IN_gte': int``\n - ``'deltaLast_USED_lte': int``\n - ``'deltaLast_USED_gte': int``\n - ``'deltaLast_USED_ACCEPTABLE_SHIPPING_lte': int``\n - ``'deltaLast_USED_ACCEPTABLE_SHIPPING_gte': int``\n - ``'deltaLast_USED_GOOD_SHIPPING_lte': int``\n - ``'deltaLast_USED_GOOD_SHIPPING_gte': int``\n - ``'deltaLast_USED_NEW_SHIPPING_lte': int``\n - ``'deltaLast_USED_NEW_SHIPPING_gte': int``\n - ``'deltaLast_USED_VERY_GOOD_SHIPPING_lte': int``\n - ``'deltaLast_USED_VERY_GOOD_SHIPPING_gte': int``\n - ``'deltaLast_WAREHOUSE_lte': int``\n - ``'deltaLast_WAREHOUSE_gte': int``\n - ``'deltaPercent1_AMAZON_lte': int``\n - ``'deltaPercent1_AMAZON_gte': int``\n - ``'deltaPercent1_BUY_BOX_SHIPPING_lte': int``\n - ``'deltaPercent1_BUY_BOX_SHIPPING_gte': int``\n - ``'deltaPercent1_COLLECTIBLE_lte': int``\n - ``'deltaPercent1_COLLECTIBLE_gte': int``\n - ``'deltaPercent1_COUNT_COLLECTIBLE_lte': int``\n - ``'deltaPercent1_COUNT_COLLECTIBLE_gte': int``\n - ``'deltaPercent1_COUNT_NEW_lte': int``\n - ``'deltaPercent1_COUNT_NEW_gte': int``\n - ``'deltaPercent1_COUNT_REFURBISHED_lte': int``\n - ``'deltaPercent1_COUNT_REFURBISHED_gte': int``\n - ``'deltaPercent1_COUNT_REVIEWS_lte': int``\n - ``'deltaPercent1_COUNT_REVIEWS_gte': int``\n - ``'deltaPercent1_COUNT_USED_lte': int``\n - ``'deltaPercent1_COUNT_USED_gte': int``\n - ``'deltaPercent1_EBAY_NEW_SHIPPING_lte': int``\n - ``'deltaPercent1_EBAY_NEW_SHIPPING_gte': int``\n - ``'deltaPercent1_EBAY_USED_SHIPPING_lte': int``\n - ``'deltaPercent1_EBAY_USED_SHIPPING_gte': int``\n - ``'deltaPercent1_LIGHTNING_DEAL_lte': int``\n - ``'deltaPercent1_LIGHTNING_DEAL_gte': int``\n - ``'deltaPercent1_LISTPRICE_lte': int``\n - ``'deltaPercent1_LISTPRICE_gte': int``\n - ``'deltaPercent1_NEW_lte': int``\n - ``'deltaPercent1_NEW_gte': int``\n - ``'deltaPercent1_NEW_FBA_lte': int``\n - ``'deltaPercent1_NEW_FBA_gte': int``\n - ``'deltaPercent1_NEW_FBM_SHIPPING_lte': int``\n - ``'deltaPercent1_NEW_FBM_SHIPPING_gte': int``\n - ``'deltaPercent1_RATING_lte': int``\n - ``'deltaPercent1_RATING_gte': int``\n - ``'deltaPercent1_REFURBISHED_lte': int``\n - ``'deltaPercent1_REFURBISHED_gte': int``\n - ``'deltaPercent1_REFURBISHED_SHIPPING_lte': int``\n - ``'deltaPercent1_REFURBISHED_SHIPPING_gte': int``\n - ``'deltaPercent1_RENT_lte': int``\n - ``'deltaPercent1_RENT_gte': int``\n - ``'deltaPercent1_SALES_lte': int``\n - ``'deltaPercent1_SALES_gte': int``\n - ``'deltaPercent1_TRADE_IN_lte': int``\n - ``'deltaPercent1_TRADE_IN_gte': int``\n - ``'deltaPercent1_USED_lte': int``\n - ``'deltaPercent1_USED_gte': int``\n - ``'deltaPercent1_USED_ACCEPTABLE_SHIPPING_lte': int``\n - ``'deltaPercent1_USED_ACCEPTABLE_SHIPPING_gte': int``\n - ``'deltaPercent1_USED_GOOD_SHIPPING_lte': int``\n - ``'deltaPercent1_USED_GOOD_SHIPPING_gte': int``\n - ``'deltaPercent1_USED_NEW_SHIPPING_lte': int``\n - ``'deltaPercent1_USED_NEW_SHIPPING_gte': int``\n - ``'deltaPercent1_USED_VERY_GOOD_SHIPPING_lte': int``\n - ``'deltaPercent1_USED_VERY_GOOD_SHIPPING_gte': int``\n - ``'deltaPercent1_WAREHOUSE_lte': int``\n - ``'deltaPercent1_WAREHOUSE_gte': int``\n - ``'deltaPercent30_AMAZON_lte': int``\n - ``'deltaPercent30_AMAZON_gte': int``\n - ``'deltaPercent30_BUY_BOX_SHIPPING_lte': int``\n - ``'deltaPercent30_BUY_BOX_SHIPPING_gte': int``\n - ``'deltaPercent30_COLLECTIBLE_lte': int``\n - ``'deltaPercent30_COLLECTIBLE_gte': int``\n - ``'deltaPercent30_COUNT_COLLECTIBLE_lte': int``\n - ``'deltaPercent30_COUNT_COLLECTIBLE_gte': int``\n - ``'deltaPercent30_COUNT_NEW_lte': int``\n - ``'deltaPercent30_COUNT_NEW_gte': int``\n - ``'deltaPercent30_COUNT_REFURBISHED_lte': int``\n - ``'deltaPercent30_COUNT_REFURBISHED_gte': int``\n - ``'deltaPercent30_COUNT_REVIEWS_lte': int``\n - ``'deltaPercent30_COUNT_REVIEWS_gte': int``\n - ``'deltaPercent30_COUNT_USED_lte': int``\n - ``'deltaPercent30_COUNT_USED_gte': int``\n - ``'deltaPercent30_EBAY_NEW_SHIPPING_lte': int``\n - ``'deltaPercent30_EBAY_NEW_SHIPPING_gte': int``\n - ``'deltaPercent30_EBAY_USED_SHIPPING_lte': int``\n - ``'deltaPercent30_EBAY_USED_SHIPPING_gte': int``\n - ``'deltaPercent30_LIGHTNING_DEAL_lte': int``\n - ``'deltaPercent30_LIGHTNING_DEAL_gte': int``\n - ``'deltaPercent30_LISTPRICE_lte': int``\n - ``'deltaPercent30_LISTPRICE_gte': int``\n - ``'deltaPercent30_NEW_lte': int``\n - ``'deltaPercent30_NEW_gte': int``\n - ``'deltaPercent30_NEW_FBA_lte': int``\n - ``'deltaPercent30_NEW_FBA_gte': int``\n - ``'deltaPercent30_NEW_FBM_SHIPPING_lte': int``\n - ``'deltaPercent30_NEW_FBM_SHIPPING_gte': int``\n - ``'deltaPercent30_RATING_lte': int``\n - ``'deltaPercent30_RATING_gte': int``\n - ``'deltaPercent30_REFURBISHED_lte': int``\n - ``'deltaPercent30_REFURBISHED_gte': int``\n - ``'deltaPercent30_REFURBISHED_SHIPPING_lte': int``\n - ``'deltaPercent30_REFURBISHED_SHIPPING_gte': int``\n - ``'deltaPercent30_RENT_lte': int``\n - ``'deltaPercent30_RENT_gte': int``\n - ``'deltaPercent30_SALES_lte': int``\n - ``'deltaPercent30_SALES_gte': int``\n - ``'deltaPercent30_TRADE_IN_lte': int``\n - ``'deltaPercent30_TRADE_IN_gte': int``\n - ``'deltaPercent30_USED_lte': int``\n - ``'deltaPercent30_USED_gte': int``\n - ``'deltaPercent30_USED_ACCEPTABLE_SHIPPING_lte': int``\n - ``'deltaPercent30_USED_ACCEPTABLE_SHIPPING_gte': int``\n - ``'deltaPercent30_USED_GOOD_SHIPPING_lte': int``\n - ``'deltaPercent30_USED_GOOD_SHIPPING_gte': int``\n - ``'deltaPercent30_USED_NEW_SHIPPING_lte': int``\n - ``'deltaPercent30_USED_NEW_SHIPPING_gte': int``\n - ``'deltaPercent30_USED_VERY_GOOD_SHIPPING_lte': int``\n - ``'deltaPercent30_USED_VERY_GOOD_SHIPPING_gte': int``\n - ``'deltaPercent30_WAREHOUSE_lte': int``\n - ``'deltaPercent30_WAREHOUSE_gte': int``\n - ``'deltaPercent7_AMAZON_lte': int``\n - ``'deltaPercent7_AMAZON_gte': int``\n - ``'deltaPercent7_BUY_BOX_SHIPPING_lte': int``\n - ``'deltaPercent7_BUY_BOX_SHIPPING_gte': int``\n - ``'deltaPercent7_COLLECTIBLE_lte': int``\n - ``'deltaPercent7_COLLECTIBLE_gte': int``\n - ``'deltaPercent7_COUNT_COLLECTIBLE_lte': int``\n - ``'deltaPercent7_COUNT_COLLECTIBLE_gte': int``\n - ``'deltaPercent7_COUNT_NEW_lte': int``\n - ``'deltaPercent7_COUNT_NEW_gte': int``\n - ``'deltaPercent7_COUNT_REFURBISHED_lte': int``\n - ``'deltaPercent7_COUNT_REFURBISHED_gte': int``\n - ``'deltaPercent7_COUNT_REVIEWS_lte': int``\n - ``'deltaPercent7_COUNT_REVIEWS_gte': int``\n - ``'deltaPercent7_COUNT_USED_lte': int``\n - ``'deltaPercent7_COUNT_USED_gte': int``\n - ``'deltaPercent7_EBAY_NEW_SHIPPING_lte': int``\n - ``'deltaPercent7_EBAY_NEW_SHIPPING_gte': int``\n - ``'deltaPercent7_EBAY_USED_SHIPPING_lte': int``\n - ``'deltaPercent7_EBAY_USED_SHIPPING_gte': int``\n - ``'deltaPercent7_LIGHTNING_DEAL_lte': int``\n - ``'deltaPercent7_LIGHTNING_DEAL_gte': int``\n - ``'deltaPercent7_LISTPRICE_lte': int``\n - ``'deltaPercent7_LISTPRICE_gte': int``\n - ``'deltaPercent7_NEW_lte': int``\n - ``'deltaPercent7_NEW_gte': int``\n - ``'deltaPercent7_NEW_FBA_lte': int``\n - ``'deltaPercent7_NEW_FBA_gte': int``\n - ``'deltaPercent7_NEW_FBM_SHIPPING_lte': int``\n - ``'deltaPercent7_NEW_FBM_SHIPPING_gte': int``\n - ``'deltaPercent7_RATING_lte': int``\n - ``'deltaPercent7_RATING_gte': int``\n - ``'deltaPercent7_REFURBISHED_lte': int``\n - ``'deltaPercent7_REFURBISHED_gte': int``\n - ``'deltaPercent7_REFURBISHED_SHIPPING_lte': int``\n - ``'deltaPercent7_REFURBISHED_SHIPPING_gte': int``\n - ``'deltaPercent7_RENT_lte': int``\n - ``'deltaPercent7_RENT_gte': int``\n - ``'deltaPercent7_SALES_lte': int``\n - ``'deltaPercent7_SALES_gte': int``\n - ``'deltaPercent7_TRADE_IN_lte': int``\n - ``'deltaPercent7_TRADE_IN_gte': int``\n - ``'deltaPercent7_USED_lte': int``\n - ``'deltaPercent7_USED_gte': int``\n - ``'deltaPercent7_USED_ACCEPTABLE_SHIPPING_lte': int``\n - ``'deltaPercent7_USED_ACCEPTABLE_SHIPPING_gte': int``\n - ``'deltaPercent7_USED_GOOD_SHIPPING_lte': int``\n - ``'deltaPercent7_USED_GOOD_SHIPPING_gte': int``\n - ``'deltaPercent7_USED_NEW_SHIPPING_lte': int``\n - ``'deltaPercent7_USED_NEW_SHIPPING_gte': int``\n - ``'deltaPercent7_USED_VERY_GOOD_SHIPPING_lte': int``\n - ``'deltaPercent7_USED_VERY_GOOD_SHIPPING_gte': int``\n - ``'deltaPercent7_WAREHOUSE_lte': int``\n - ``'deltaPercent7_WAREHOUSE_gte': int``\n - ``'deltaPercent90_AMAZON_lte': int``\n - ``'deltaPercent90_AMAZON_gte': int``\n - ``'deltaPercent90_BUY_BOX_SHIPPING_lte': int``\n - ``'deltaPercent90_BUY_BOX_SHIPPING_gte': int``\n - ``'deltaPercent90_COLLECTIBLE_lte': int``\n - ``'deltaPercent90_COLLECTIBLE_gte': int``\n - ``'deltaPercent90_COUNT_COLLECTIBLE_lte': int``\n - ``'deltaPercent90_COUNT_COLLECTIBLE_gte': int``\n - ``'deltaPercent90_COUNT_NEW_lte': int``\n - ``'deltaPercent90_COUNT_NEW_gte': int``\n - ``'deltaPercent90_COUNT_REFURBISHED_lte': int``\n - ``'deltaPercent90_COUNT_REFURBISHED_gte': int``\n - ``'deltaPercent90_COUNT_REVIEWS_lte': int``\n - ``'deltaPercent90_COUNT_REVIEWS_gte': int``\n - ``'deltaPercent90_COUNT_USED_lte': int``\n - ``'deltaPercent90_COUNT_USED_gte': int``\n - ``'deltaPercent90_EBAY_NEW_SHIPPING_lte': int``\n - ``'deltaPercent90_EBAY_NEW_SHIPPING_gte': int``\n - ``'deltaPercent90_EBAY_USED_SHIPPING_lte': int``\n - ``'deltaPercent90_EBAY_USED_SHIPPING_gte': int``\n - ``'deltaPercent90_LIGHTNING_DEAL_lte': int``\n - ``'deltaPercent90_LIGHTNING_DEAL_gte': int``\n - ``'deltaPercent90_LISTPRICE_lte': int``\n - ``'deltaPercent90_LISTPRICE_gte': int``\n - ``'deltaPercent90_NEW_lte': int``\n - ``'deltaPercent90_NEW_gte': int``\n - ``'deltaPercent90_NEW_FBA_lte': int``\n - ``'deltaPercent90_NEW_FBA_gte': int``\n - ``'deltaPercent90_NEW_FBM_SHIPPING_lte': int``\n - ``'deltaPercent90_NEW_FBM_SHIPPING_gte': int``\n - ``'deltaPercent90_RATING_lte': int``\n - ``'deltaPercent90_RATING_gte': int``\n - ``'deltaPercent90_REFURBISHED_lte': int``\n - ``'deltaPercent90_REFURBISHED_gte': int``\n - ``'deltaPercent90_REFURBISHED_SHIPPING_lte': int``\n - ``'deltaPercent90_REFURBISHED_SHIPPING_gte': int``\n - ``'deltaPercent90_RENT_lte': int``\n - ``'deltaPercent90_RENT_gte': int``\n - ``'deltaPercent90_SALES_lte': int``\n - ``'deltaPercent90_SALES_gte': int``\n - ``'deltaPercent90_TRADE_IN_lte': int``\n - ``'deltaPercent90_TRADE_IN_gte': int``\n - ``'deltaPercent90_USED_lte': int``\n - ``'deltaPercent90_USED_gte': int``\n - ``'deltaPercent90_USED_ACCEPTABLE_SHIPPING_lte': int``\n - ``'deltaPercent90_USED_ACCEPTABLE_SHIPPING_gte': int``\n - ``'deltaPercent90_USED_GOOD_SHIPPING_lte': int``\n - ``'deltaPercent90_USED_GOOD_SHIPPING_gte': int``\n - ``'deltaPercent90_USED_NEW_SHIPPING_lte': int``\n - ``'deltaPercent90_USED_NEW_SHIPPING_gte': int``\n - ``'deltaPercent90_USED_VERY_GOOD_SHIPPING_lte': int``\n - ``'deltaPercent90_USED_VERY_GOOD_SHIPPING_gte': int``\n - ``'deltaPercent90_WAREHOUSE_lte': int``\n - ``'deltaPercent90_WAREHOUSE_gte': int``\n - ``'department': str``\n - ``'edition': str``\n - ``'fbaFees_lte': int``\n - ``'fbaFees_gte': int``\n - ``'format': str``\n - ``'genre': str``\n - ``'hasParentASIN': bool``\n - ``'hasReviews': bool``\n - ``'hazardousMaterialType_lte': int``\n - ``'hazardousMaterialType_gte': int``\n - ``'isAdultProduct': bool``\n - ``'isEligibleForSuperSaverShipping': bool``\n - ``'isEligibleForTradeIn': bool``\n - ``'isHighestOffer': bool``\n - ``'isHighest_AMAZON': bool``\n - ``'isHighest_BUY_BOX_SHIPPING': bool``\n - ``'isHighest_COLLECTIBLE': bool``\n - ``'isHighest_COUNT_COLLECTIBLE': bool``\n - ``'isHighest_COUNT_NEW': bool``\n - ``'isHighest_COUNT_REFURBISHED': bool``\n - ``'isHighest_COUNT_REVIEWS': bool``\n - ``'isHighest_COUNT_USED': bool``\n - ``'isHighest_EBAY_NEW_SHIPPING': bool``\n - ``'isHighest_EBAY_USED_SHIPPING': bool``\n - ``'isHighest_LIGHTNING_DEAL': bool``\n - ``'isHighest_LISTPRICE': bool``\n - ``'isHighest_NEW': bool``\n - ``'isHighest_NEW_FBA': bool``\n - ``'isHighest_NEW_FBM_SHIPPING': bool``\n - ``'isHighest_RATING': bool``\n - ``'isHighest_REFURBISHED': bool``\n - ``'isHighest_REFURBISHED_SHIPPING': bool``\n - ``'isHighest_RENT': bool``\n - ``'isHighest_SALES': bool``\n - ``'isHighest_TRADE_IN': bool``\n - ``'isHighest_USED': bool``\n - ``'isHighest_USED_ACCEPTABLE_SHIPPING': bool``\n - ``'isHighest_USED_GOOD_SHIPPING': bool``\n - ``'isHighest_USED_NEW_SHIPPING': bool``\n - ``'isHighest_USED_VERY_GOOD_SHIPPING': bool``\n - ``'isHighest_WAREHOUSE': bool``\n - ``'isLowestOffer': bool``\n - ``'isLowest_AMAZON': bool``\n - ``'isLowest_BUY_BOX_SHIPPING': bool``\n - ``'isLowest_COLLECTIBLE': bool``\n - ``'isLowest_COUNT_COLLECTIBLE': bool``\n - ``'isLowest_COUNT_NEW': bool``\n - ``'isLowest_COUNT_REFURBISHED': bool``\n - ``'isLowest_COUNT_REVIEWS': bool``\n - ``'isLowest_COUNT_USED': bool``\n - ``'isLowest_EBAY_NEW_SHIPPING': bool``\n - ``'isLowest_EBAY_USED_SHIPPING': bool``\n - ``'isLowest_LIGHTNING_DEAL': bool``\n - ``'isLowest_LISTPRICE': bool``\n - ``'isLowest_NEW': bool``\n - ``'isLowest_NEW_FBA': bool``\n - ``'isLowest_NEW_FBM_SHIPPING': bool``\n - ``'isLowest_RATING': bool``\n - ``'isLowest_REFURBISHED': bool``\n - ``'isLowest_REFURBISHED_SHIPPING': bool``\n - ``'isLowest_RENT': bool``\n - ``'isLowest_SALES': bool``\n - ``'isLowest_TRADE_IN': bool``\n - ``'isLowest_USED': bool``\n - ``'isLowest_USED_ACCEPTABLE_SHIPPING': bool``\n - ``'isLowest_USED_GOOD_SHIPPING': bool``\n - ``'isLowest_USED_NEW_SHIPPING': bool``\n - ``'isLowest_USED_VERY_GOOD_SHIPPING': bool``\n - ``'isLowest_WAREHOUSE': bool``\n - ``'isPrimeExclusive': bool``\n - ``'isSNS': bool``\n - ``'label': str``\n - ``'languages': str``\n - ``'lastOffersUpdate_lte': int``\n - ``'lastOffersUpdate_gte': int``\n - ``'lastPriceChange_lte': int``\n - ``'lastPriceChange_gte': int``\n - ``'lastRatingUpdate_lte': int``\n - ``'lastRatingUpdate_gte': int``\n - ``'lastUpdate_lte': int``\n - ``'lastUpdate_gte': int``\n - ``'lightningEnd_lte': int``\n - ``'lightningEnd_gte': int``\n - ``'lightningStart_lte': int``\n - ``'lightningStart_gte': int``\n - ``'listedSince_lte': int``\n - ``'listedSince_gte': int``\n - ``'manufacturer': str``\n - ``'model': str``\n - ``'newPriceIsMAP': bool``\n - ``'nextUpdate_lte': int``\n - ``'nextUpdate_gte': int``\n - ``'numberOfItems_lte': int``\n - ``'numberOfItems_gte': int``\n - ``'numberOfPages_lte': int``\n - ``'numberOfPages_gte': int``\n - ``'numberOfTrackings_lte': int``\n - ``'numberOfTrackings_gte': int``\n - ``'offerCountFBA_lte': int``\n - ``'offerCountFBA_gte': int``\n - ``'offerCountFBM_lte': int``\n - ``'offerCountFBM_gte': int``\n - ``'outOfStockPercentageInInterval_lte': int``\n - ``'outOfStockPercentageInInterval_gte': int``\n - ``'packageDimension_lte': int``\n - ``'packageDimension_gte': int``\n - ``'packageHeight_lte': int``\n - ``'packageHeight_gte': int``\n - ``'packageLength_lte': int``\n - ``'packageLength_gte': int``\n - ``'packageQuantity_lte': int``\n - ``'packageQuantity_gte': int``\n - ``'packageWeight_lte': int``\n - ``'packageWeight_gte': int``\n - ``'packageWidth_lte': int``\n - ``'packageWidth_gte': int``\n - ``'partNumber': str``\n - ``'platform': str``\n - ``'productGroup': str``\n - ``'productType': int``\n - ``'promotions': int``\n - ``'publicationDate_lte': int``\n - ``'publicationDate_gte': int``\n - ``'publisher': str``\n - ``'releaseDate_lte': int``\n - ``'releaseDate_gte': int``\n - ``'rootCategory': int``\n - ``'sellerIds': str``\n - ``'sellerIdsLowestFBA': str``\n - ``'sellerIdsLowestFBM': str``\n - ``'size': str``\n - ``'salesRankDrops180_lte': int``\n - ``'salesRankDrops180_gte': int``\n - ``'salesRankDrops90_lte': int``\n - ``'salesRankDrops90_gte': int``\n - ``'salesRankDrops30_lte': int``\n - ``'salesRankDrops30_gte': int``\n - ``'stockAmazon_lte': int``\n - ``'stockAmazon_gte': int``\n - ``'stockBuyBox_lte': int``\n - ``'stockBuyBox_gte': int``\n - ``'studio': str``\n - ``'title': str``\n - ``'title_flag': str``\n - ``'trackingSince_lte': int``\n - ``'trackingSince_gte': int``\n - ``'type': str``\n - ``'mpn': str``\n - ``'outOfStockPercentage90_lte': int``\n - ``'outOfStockPercentage90_gte': int``\n - ``'categories_include': int``\n - ``'categories_exclude': int``\n\n domain : str, optional\n One of the following Amazon domains: RESERVED, US, GB, DE,\n FR, JP, CA, CN, IT, ES, IN, MX Defaults to US.\n\n wait : bool, optional\n Wait available token before doing effective query, Defaults to ``True``.\n\n Examples\n --------\n Query for all of Jim Butcher's books\n\n >>> import keepa\n >>> api = keepa.AsyncKeepa('ENTER_ACTUAL_KEY_HERE')\n >>> product_parms = {'author': 'jim butcher'}\n >>> products = api.product_finder(product_parms)\n \"\"\"\n # verify valid keys\n for key in product_parms:\n if key not in PRODUCT_REQUEST_KEYS:\n raise RuntimeError('Invalid key \"%s\"' % key)\n\n # verify json type\n key_type = PRODUCT_REQUEST_KEYS[key]\n product_parms[key] = key_type(product_parms[key])\n\n payload = {'key': self.accesskey,\n 'domain': DCODES.index(domain),\n 'selection': json.dumps(product_parms)}\n\n response = self._request('query', payload, wait=wait)\n return response['asinList']\n\n def deals(self, deal_parms, domain='US', wait=True):\n \"\"\"Query the Keepa API for product deals.\n\n You can find products that recently changed and match your\n search criteria. A single request will return a maximum of\n 150 deals. Try out the deals page to first get accustomed to\n the options:\n https://keepa.com/#!deals\n\n For more details please visit:\n https://keepa.com/#!discuss/t/browsing-deals/338\n\n Parameters\n ----------\n deal_parms : dict\n Dictionary containing one or more of the following keys:\n\n - ``\"page\"``: int\n - ``\"domainId\"``: int\n - ``\"excludeCategories\"``: list\n - ``\"includeCategories\"``: list\n - ``\"priceTypes\"``: list\n - ``\"deltaRange\"``: list\n - ``\"deltaPercentRange\"``: list\n - ``\"deltaLastRange\"``: list\n - ``\"salesRankRange\"``: list\n - ``\"currentRange\"``: list\n - ``\"minRating\"``: int\n - ``\"isLowest\"``: bool\n - ``\"isLowestOffer\"``: bool\n - ``\"isOutOfStock\"``: bool\n - ``\"titleSearch\"``: String\n - ``\"isRangeEnabled\"``: bool\n - ``\"isFilterEnabled\"``: bool\n - ``\"hasReviews\"``: bool\n - ``\"filterErotic\"``: bool\n - ``\"sortType\"``: int\n - ``\"dateRange\"``: int\n\n domain : str, optional\n One of the following Amazon domains: RESERVED, US, GB, DE,\n FR, JP, CA, CN, IT, ES, IN, MX Defaults to US.\n\n wait : bool, optional\n Wait available token before doing effective query, Defaults to ``True``.\n\n Examples\n --------\n >>> import keepa\n >>> api = keepa.AsyncKeepa('ENTER_YOUR_KEY_HERE')\n >>> deal_parms = {\"page\": 0,\n \"domainId\": 1,\n \"excludeCategories\": [1064954, 11091801],\n \"includeCategories\": [16310101]}\n >>> deals = api.deals(deal_parms)\n >>> print(deals[:5])\n ['B00U20FN1Y', 'B078HR932T', 'B00L88ERK2',\n 'B07G5TDMZ7', 'B00GYMQAM0']\n \"\"\"\n # verify valid keys\n for key in deal_parms:\n if key not in DEAL_REQUEST_KEYS:\n raise RuntimeError('Invalid key \"%s\"' % key)\n\n # verify json type\n key_type = DEAL_REQUEST_KEYS[key]\n deal_parms[key] = key_type(deal_parms[key])\n\n payload = {'key': self.accesskey,\n 'domain': DCODES.index(domain),\n 'selection': json.dumps(deal_parms)}\n\n response = self._request('query', payload, wait=wait)\n return response['asinList']\n\n def _request(self, request_type, payload, wait=True, raw_response=False):\n \"\"\"Queries keepa api server. \n\n Parses raw response from keepa into a json format. Handles\n errors and waits for available tokens if allowed.\n \"\"\"\n if wait:\n self.wait_for_tokens()\n\n while True:\n raw = requests.get(f'https://api.keepa.com/{request_type}/?', payload,\n timeout=self._timeout)\n status_code = str(raw.status_code)\n if status_code != '200':\n if status_code in SCODES:\n if status_code == '429' and wait:\n print('Response from server: %s' % SCODES[status_code])\n self.wait_for_tokens()\n continue\n else:\n raise Exception(SCODES[status_code])\n else:\n raise Exception('REQUEST_FAILED')\n break\n\n response = raw.json()\n\n if 'tokensConsumed' in response:\n log.debug('%d tokens consumed', response['tokensConsumed'])\n\n if 'error' in response:\n if response['error']:\n raise Exception(response['error']['message'])\n\n # always update tokens\n self.tokens_left = response['tokensLeft']\n\n if raw_response:\n return raw\n return response\n\n\nclass AsyncKeepa():\n \"\"\"Class to support an asynchronous Python interface to keepa server.\n\n Initializes API with access key. Access key can be obtained by\n signing up for a reoccurring or one time plan at:\n https://keepa.com/#!api\n\n Parameters\n ----------\n accesskey : str\n 64 character access key string.\n\n timeout : float, optional\n Default timeout when issuing any request. This is not a time\n limit on the entire response download; rather, an exception is\n raised if the server has not issued a response for timeout\n seconds. Setting this to 0 disables the timeout, but will\n cause any request to hang indefiantly should keepa.com be down\n\n Examples\n --------\n Create the api object\n\n >>> import keepa\n >>> mykey = 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'\n >>> api = await keepa.AsyncKeepa.create(mykey)\n\n Request data from two ASINs\n\n >>> products = await api.query(['0439064872', '1426208081'])\n\n Print item details\n\n >>> print('Item 1')\n >>> print('\\t ASIN: {:s}'.format(products[0]['asin']))\n >>> print('\\t Title: {:s}'.format(products[0]['title']))\n\n Print item price\n\n >>> usedprice = products[0]['data']['MarketplaceUsed']\n >>> usedtimes = products[0]['data']['MarketplaceUsed_time']\n >>> print('\\t Used price: ${:.2f}'.format(usedprice[-1]))\n >>> print('\\t as of: {:s}'.format(str(usedtimes[-1])))\n \"\"\"\n\n @classmethod\n async def create(cls, accesskey, timeout=10):\n self = AsyncKeepa()\n self.accesskey = accesskey\n self.status = None\n self.tokens_left = 0\n self._timeout = timeout\n\n # Store user's available tokens\n log.info('Connecting to keepa using key ending in %s', accesskey[-6:])\n await self.update_status()\n log.info('%d tokens remain', self.tokens_left)\n return self\n\n @property\n def time_to_refill(self):\n \"\"\" Returns the time to refill in seconds \"\"\"\n # Get current timestamp in milliseconds from UNIX epoch\n now = int(time.time() * 1000)\n timeatrefile = self.status['timestamp'] + self.status['refillIn']\n\n # wait plus one second fudge factor\n timetorefil = timeatrefile - now + 1000\n if timetorefil < 0:\n timetorefil = 0\n\n # Account for negative tokens left\n if self.tokens_left < 0:\n timetorefil += (abs(self.tokens_left) / self.status['refillRate']) * 60000\n\n # Return value in seconds\n return timetorefil / 1000.0\n\n async def update_status(self):\n \"\"\" Updates available tokens \"\"\"\n self.status = await self._request('token', {'key': self.accesskey}, wait=False)\n\n async def wait_for_tokens(self):\n \"\"\"Checks any remaining tokens and waits if none are available. \"\"\"\n await self.update_status()\n\n # Wait if no tokens available\n if self.tokens_left <= 0:\n tdelay = self.time_to_refill\n log.warning('Waiting %.0f seconds for additional tokens' % tdelay)\n await asyncio.sleep(tdelay)\n await self.update_status()\n\n @is_documented_by(Keepa.query)\n async def query(self, items, stats=None, domain='US', history=True,\n offers=None, update=None, to_datetime=True,\n rating=False, out_of_stock_as_nan=True, stock=False,\n product_code_is_asin=True, progress_bar=True, buybox=False,\n wait=True, days=None, only_live_offers=None, raw=False):\n if raw:\n raise ValueError('Raw response is only available in the non-async class')\n\n # Format items into numpy array\n try:\n items = format_items(items)\n except BaseException:\n raise Exception('Invalid product codes input')\n assert len(items), 'No valid product codes'\n\n nitems = len(items)\n if nitems == 1:\n log.debug('Executing single product query')\n else:\n log.debug('Executing %d item product query', nitems)\n\n # check offer input\n if offers:\n if not isinstance(offers, int):\n raise TypeError('Parameter \"offers\" must be an interger')\n\n if offers > 100 or offers < 20:\n raise ValueError('Parameter \"offers\" must be between 20 and 100')\n\n # Report time to completion\n tcomplete = float(nitems - self.tokens_left) / self.status['refillRate'] - (\n 60000 - self.status['refillIn']) / 60000.0\n if tcomplete < 0.0:\n tcomplete = 0.5\n log.debug('Estimated time to complete %d request(s) is %.2f minutes',\n nitems, tcomplete)\n log.debug('\\twith a refill rate of %d token(s) per minute',\n self.status['refillRate'])\n\n # product list\n products = []\n\n pbar = None\n if progress_bar:\n pbar = tqdm(total=nitems)\n\n # Number of requests is dependent on the number of items and\n # request limit. Use available tokens first\n idx = 0 # or number complete\n while idx < nitems:\n nrequest = nitems - idx\n\n # cap request\n if nrequest > REQUEST_LIMIT:\n nrequest = REQUEST_LIMIT\n\n # request from keepa and increment current position\n item_request = items[idx:idx + nrequest]\n response = await self._product_query(\n item_request,\n product_code_is_asin,\n stats=stats,\n domain=domain, stock=stock,\n offers=offers, update=update,\n history=history, rating=rating,\n to_datetime=to_datetime,\n out_of_stock_as_nan=out_of_stock_as_nan,\n buybox=buybox,\n wait=wait,\n days=days,\n only_live_offers=only_live_offers,\n )\n idx += nrequest\n products.extend(response['products'])\n\n if pbar is not None:\n pbar.update(nrequest)\n\n return products\n\n @is_documented_by(Keepa._product_query)\n async def _product_query(self, items, product_code_is_asin=True, **kwargs):\n # ASINs convert to comma joined string\n assert len(items) <= 100\n\n if product_code_is_asin:\n kwargs['asin'] = ','.join(items)\n else:\n kwargs['code'] = ','.join(items)\n\n kwargs['key'] = self.accesskey\n kwargs['domain'] = DCODES.index(kwargs['domain'])\n\n # Convert bool values to 0 and 1.\n kwargs['stock'] = int(kwargs['stock'])\n kwargs['history'] = int(kwargs['history'])\n kwargs['rating'] = int(kwargs['rating'])\n kwargs['buybox'] = int(kwargs['buybox'])\n\n if kwargs['update'] is None:\n del kwargs['update']\n else:\n kwargs['update'] = int(kwargs['update'])\n\n if kwargs['offers'] is None:\n del kwargs['offers']\n else:\n kwargs['offers'] = int(kwargs['offers'])\n\n if kwargs['only_live_offers'] is None:\n del kwargs['only_live_offers']\n else:\n kwargs['only-live-offers'] = int(kwargs.pop('only_live_offers'))\n # Keepa's param actually doesn't use snake_case.\n # I believe using snake case throughout the Keepa interface is better.\n\n if kwargs['days'] is None:\n del kwargs['days']\n else:\n assert kwargs['days'] > 0\n\n if kwargs['stats'] is None:\n del kwargs['stats']\n\n out_of_stock_as_nan = kwargs.pop('out_of_stock_as_nan', True)\n to_datetime = kwargs.pop('to_datetime', True)\n\n # Query and replace csv with parsed data if history enabled\n wait = kwargs.get(\"wait\")\n kwargs.pop(\"wait\", None)\n response = await self._request('product', kwargs, wait=wait)\n if kwargs['history']:\n for product in response['products']:\n if product['csv']: # if data exists\n product['data'] = parse_csv(product['csv'],\n to_datetime,\n out_of_stock_as_nan)\n\n if kwargs.get('stats', None):\n for product in response['products']:\n stats = product.get('stats', None)\n if stats:\n product['stats_parsed'] = _parse_stats(stats, to_datetime)\n\n return response\n\n @is_documented_by(Keepa.best_sellers_query)\n async def best_sellers_query(self, category, rank_avg_range=0,\n domain='US', wait=True):\n assert domain in DCODES, 'Invalid domain code'\n\n payload = {'key': self.accesskey,\n 'domain': DCODES.index(domain),\n 'category': category,\n 'range': rank_avg_range}\n\n response = await self._request('bestsellers', payload, wait=wait)\n if 'bestSellersList' in response:\n return response['bestSellersList']['asinList']\n else: # pragma: no cover\n log.info('Best sellers search results not yet available')\n\n @is_documented_by(Keepa.search_for_categories)\n async def search_for_categories(self, searchterm, domain='US', wait=True):\n assert domain in DCODES, 'Invalid domain code'\n\n payload = {'key': self.accesskey,\n 'domain': DCODES.index(domain),\n 'type': 'category',\n 'term': searchterm}\n\n response = await self._request('search', payload, wait=wait)\n if response['categories'] == {}: # pragma no cover\n raise Exception('Categories search results not yet available ' +\n 'or no search terms found.')\n else:\n return response['categories']\n\n @is_documented_by(Keepa.category_lookup)\n async def category_lookup(self, category_id, domain='US',\n include_parents=0, wait=True):\n assert domain in DCODES, 'Invalid domain code'\n\n payload = {'key': self.accesskey,\n 'domain': DCODES.index(domain),\n 'category': category_id,\n 'parents': include_parents}\n\n response = await self._request('category', payload, wait=wait)\n if response['categories'] == {}: # pragma no cover\n raise Exception('Category lookup results not yet available or no' +\n 'match found.')\n else:\n return response['categories']\n\n @is_documented_by(Keepa.seller_query)\n async def seller_query(self, seller_id, domain='US', to_datetime=True, \n storefront=False, update=None, wait=True):\n if isinstance(seller_id, list):\n if len(seller_id) > 100:\n err_str = 'seller_id can contain at maximum 100 sellers'\n raise RuntimeError(err_str)\n seller = ','.join(seller_id)\n else:\n seller = seller_id\n\n payload = {'key': self.accesskey,\n 'domain': DCODES.index(domain),\n 'seller': seller}\n\n if storefront:\n payload[\"storefront\"] = int(storefront)\n if update:\n payload[\"update\"] = update\n\n response = await self._request('seller', payload, wait=wait)\n return _parse_seller(response['sellers'], to_datetime)\n\n @is_documented_by(Keepa.product_finder)\n async def product_finder(self, product_parms, domain='US', wait=True):\n # verify valid keys\n for key in product_parms:\n if key not in PRODUCT_REQUEST_KEYS:\n raise RuntimeError('Invalid key \"%s\"' % key)\n\n # verify json type\n key_type = PRODUCT_REQUEST_KEYS[key]\n product_parms[key] = key_type(product_parms[key])\n\n payload = {'key': self.accesskey,\n 'domain': DCODES.index(domain),\n 'selection': json.dumps(product_parms)}\n\n response = await self._request('query', payload, wait=wait)\n return response['asinList']\n\n @is_documented_by(Keepa.deals)\n async def deals(self, deal_parms, domain='US', wait=True):\n # verify valid keys\n for key in deal_parms:\n if key not in DEAL_REQUEST_KEYS:\n raise RuntimeError('Invalid key \"%s\"' % key)\n\n # verify json type\n key_type = DEAL_REQUEST_KEYS[key]\n deal_parms[key] = key_type(deal_parms[key])\n\n payload = {'key': self.accesskey,\n 'domain': DCODES.index(domain),\n 'selection': json.dumps(deal_parms)}\n\n response = await self._request('query', payload, wait=wait)\n return response['asinList']\n\n async def _request(self, request_type, payload, wait=True):\n \"\"\"Queries keepa api server. Parses raw response from keepa\n into a json format. Handles errors and waits for available\n tokens if allowed.\n \"\"\"\n\n while True:\n async with aiohttp.ClientSession() as session:\n async with session.get(\n f'https://api.keepa.com/{request_type}/?', params=payload,\n timeout=self._timeout\n ) as raw:\n status_code = str(raw.status)\n if status_code != '200':\n if status_code in SCODES:\n if status_code == '429' and wait:\n await self.wait_for_tokens()\n continue\n else:\n raise Exception(SCODES[status_code])\n else:\n raise Exception('REQUEST_FAILED')\n\n response = await raw.json()\n\n if 'error' in response:\n if response['error']:\n raise Exception(response['error']['message'])\n\n # always update tokens\n self.tokens_left = response['tokensLeft']\n return response\n break\n\n\ndef convert_offer_history(csv, to_datetime=True):\n \"\"\"Converts an offer history to human readable values.\n\n Parameters\n ----------\n csv : list\n Offer list csv obtained from ``['offerCSV']``\n\n to_datetime : bool, optional\n Modifies ``numpy`` minutes to ``datetime.datetime`` values.\n Default ``True``.\n\n Returns\n -------\n times : numpy.ndarray\n List of time values for an offer history.\n\n prices : numpy.ndarray\n Price (including shipping) of an offer for each time at an\n index of times.\n\n \"\"\"\n # convert these values to numpy arrays\n times = csv[::3]\n values = np.array(csv[1::3])\n values += np.array(csv[2::3]) # add in shipping\n\n # convert to dollars and datetimes\n times = keepa_minutes_to_time(times, to_datetime)\n prices = values/100.0\n return times, prices\n\n\ndef keepa_minutes_to_time(minutes, to_datetime=True):\n \"\"\"Accepts an array or list of minutes and converts it to a numpy\n datetime array. Assumes that keepa time is from keepa minutes\n from ordinal.\n \"\"\"\n\n # Convert to timedelta64 and shift\n dt = np.array(minutes, dtype='timedelta64[m]')\n dt = dt + KEEPA_ST_ORDINAL # shift from ordinal\n\n # Convert to datetime if requested\n if to_datetime:\n return dt.astype(datetime.datetime)\n else:\n return dt\n\n\ndef run_and_get(coro):\n try:\n loop = asyncio.get_event_loop()\n except RuntimeError:\n loop = asyncio.new_event_loop()\n task = loop.create_task(coro)\n loop.run_until_complete(task)\n return task.result()\n"
] | [
[
"numpy.unique",
"numpy.asarray",
"pandas.DataFrame",
"numpy.datetime64",
"numpy.array"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"0.23",
"0.21",
"2.0",
"1.4",
"0.19",
"1.1",
"1.5",
"1.2",
"0.24",
"0.20",
"1.0",
"0.25",
"1.3"
],
"scipy": [],
"tensorflow": []
}
] |
se-hwan/MIT_Driverless | [
"05e416fb26f968300826f0deb0953be9afb22bfe"
] | [
"mpc/kmpc_casadi/utility/casadi-example_pack-v3.4.4/python/vdp_collocation2.py"
] | [
"#\n# This file is part of CasADi.\n#\n# CasADi -- A symbolic framework for dynamic optimization.\n# Copyright (C) 2010-2014 Joel Andersson, Joris Gillis, Moritz Diehl,\n# K.U. Leuven. All rights reserved.\n# Copyright (C) 2011-2014 Greg Horn\n#\n# CasADi is free software; you can redistribute it and/or\n# modify it under the terms of the GNU Lesser General Public\n# License as published by the Free Software Foundation; either\n# version 3 of the License, or (at your option) any later version.\n#\n# CasADi is distributed in the hope that it will be useful,\n# but WITHOUT ANY WARRANTY; without even the implied warranty of\n# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n# Lesser General Public License for more details.\n#\n# You should have received a copy of the GNU Lesser General Public\n# License along with CasADi; if not, write to the Free Software\n# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n#\n#\n# -*- coding: utf-8 -*-\nfrom casadi import *\nfrom casadi.tools import *\n\nimport numpy as NP\nimport matplotlib.pyplot as plt\n\nnk = 20 # Control discretization\ntf = 10.0 # End time\n\n# Declare variables (use scalar graph)\nt = SX.sym(\"t\") # time\nu = SX.sym(\"u\") # control\n\nstates = struct_symSX([\n entry('x',shape=2), # vdp oscillator states\n entry('L') # helper state: Langrange integrand\n ])\n\n# Create a structure for the right hand side\nrhs = struct_SX(states)\nx = states['x']\nrhs[\"x\"] = vertcat((1 - x[1]*x[1])*x[0] - x[1] + u, x[0])\nrhs[\"L\"] = x[0]*x[0] + x[1]*x[1] + u*u\n\n# ODE right hand side function\nf = Function('f', [t,states,u],[rhs])\n\n# Objective function (meyer term)\nm = Function('m', [t,states,u],[states[\"L\"]])\n\n# Control bounds\nu_min = -0.75\nu_max = 1.0\nu_init = 0.0\n\nu_lb = NP.array([u_min])\nu_ub = NP.array([u_max])\nu_init = NP.array([u_init])\n\n# State bounds and initial guess\nx_min = [-inf, -inf, -inf]\nx_max = [ inf, inf, inf]\nxi_min = [ 0.0, 1.0, 0.0]\nxi_max = [ 0.0, 1.0, 0.0]\nxf_min = [ 0.0, 0.0, -inf]\nxf_max = [ 0.0, 0.0, inf]\nx_init = [ 0.0, 0.0, 0.0]\n\n# Dimensions\nnx = 3\nnu = 1\n\n# Choose collocation points\ntau_root = [0] + collocation_points(3,\"radau\")\n\n# Degree of interpolating polynomial\nd = len(tau_root)-1\n\n# Size of the finite elements\nh = tf/nk\n\n# Coefficients of the collocation equation\nC = NP.zeros((d+1,d+1))\n\n# Coefficients of the continuity equation\nD = NP.zeros(d+1)\n\n# Dimensionless time inside one control interval\ntau = SX.sym(\"tau\")\n\n# All collocation time points\nT = NP.zeros((nk,d+1))\nfor k in range(nk):\n for j in range(d+1):\n T[k,j] = h*(k + tau_root[j])\n\n# For all collocation points\nfor j in range(d+1):\n # Construct Lagrange polynomials to get the polynomial basis at the collocation point\n L = 1\n for r in range(d+1):\n if r != j:\n L *= (tau-tau_root[r])/(tau_root[j]-tau_root[r])\n\n # Evaluate the polynomial at the final time to get the coefficients of the continuity equation\n lfcn = Function('lfcn', [tau],[L])\n D[j] = lfcn(1.0)\n\n # Evaluate the time derivative of the polynomial at all collocation points to get the coefficients of the continuity equation\n tfcn = Function('tfcn', [tau],[tangent(L,tau)])\n for r in range(d+1):\n C[j,r] = tfcn(tau_root[r])\n\n# Structure holding NLP variables\nV = struct_symMX([\n (\n entry(\"X\",repeat=[nk+1,d+1],struct=states),\n entry(\"U\",repeat=[nk],shape=nu)\n )\n ])\n\nvars_lb = V()\nvars_ub = V()\nvars_init = V()\n\n# Set states and its bounds\nvars_init[\"X\",:,:] = repeated(repeated(x_init))\nvars_lb[\"X\",:,:] = repeated(repeated(x_min))\nvars_ub[\"X\",:,:] = repeated(repeated(x_max))\n\n# Set controls and its bounds\nvars_init[\"U\",:] = repeated(u_init)\nvars_lb[\"U\",:] = repeated(u_min)\nvars_ub[\"U\",:] = repeated(u_max)\n\n# State at initial time\nvars_lb[\"X\",0,0] = xi_min\nvars_ub[\"X\",0,0] = xi_max\n\n# State at end time\nvars_lb[\"X\",-1,0] = xf_min\nvars_ub[\"X\",-1,0] = xf_max\n\n# Constraint function for the NLP\ng = []\nlbg = []\nubg = []\n\n# For all finite elements\nfor k in range(nk):\n\n # For all collocation points\n for j in range(1,d+1):\n\n # Get an expression for the state derivative at the collocation point\n xp_jk = 0\n for r in range (d+1):\n xp_jk += C[r,j]*V[\"X\",k,r]\n\n # Add collocation equations to the NLP\n fk = f(T[k][j], V[\"X\",k,j], V[\"U\",k])\n g.append(h*fk - xp_jk)\n lbg.append(NP.zeros(nx)) # equality constraints\n ubg.append(NP.zeros(nx)) # equality constraints\n\n # Get an expression for the state at the end of the finite element\n xf_k = 0\n for r in range(d+1):\n xf_k += D[r]*V[\"X\",k,r]\n\n # Add continuity equation to NLP\n g.append(V[\"X\",k+1,0] - xf_k)\n lbg.append(NP.zeros(nx))\n ubg.append(NP.zeros(nx))\n\n# Concatenate constraints\ng = vertcat(*g)\n\n# Objective function\nf = m(T[nk-1][d],V[\"X\",nk,0],V[\"U\",nk-1])\n\n# NLP\nnlp = {'x':V, 'f':f, 'g':g}\n\n## ----\n## SOLVE THE NLP\n## ----\n\n# Set options\nopts = {}\nopts[\"expand\"] = True\n#opts[\"ipopt.max_iter\"] = 4\nopts[\"ipopt.linear_solver\"] = 'ma27'\n\n# Allocate an NLP solver\nsolver = nlpsol(\"solver\", \"ipopt\", nlp, opts)\narg = {}\n\n# Initial condition\narg[\"x0\"] = vars_init\n\n# Bounds on x\narg[\"lbx\"] = vars_lb\narg[\"ubx\"] = vars_ub\n\n# Bounds on g\narg[\"lbg\"] = NP.concatenate(lbg)\narg[\"ubg\"] = NP.concatenate(ubg)\n\n# Solve the problem\nres = solver(**arg)\n\n# Print the optimal cost\nprint(\"optimal cost: \", float(res[\"f\"]))\n\n# Retrieve the solution\nopt = V(res[\"x\"])\n\n# Get values at the beginning of each finite element\nx0_opt = opt[\"X\",:,0,\"x\",0]\nx1_opt = opt[\"X\",:,0,\"x\",1]\nx2_opt = opt[\"X\",:,0,\"L\"]\n\nu_opt = opt[\"U\",:,0]\n\ntgrid = NP.linspace(0,tf,nk+1)\ntgrid_u = NP.linspace(0,tf,nk)\n\n# Plot the results\nplt.figure(1)\nplt.clf()\nplt.plot(tgrid,x0_opt,'--')\nplt.plot(tgrid,x1_opt,'-.')\nplt.step(tgrid_u,u_opt,'-')\nplt.title(\"Van der Pol optimization\")\nplt.xlabel('time')\nplt.legend(['x[0] trajectory','x[1] trajectory','u trajectory'])\nplt.grid()\nplt.show()\n"
] | [
[
"matplotlib.pyplot.legend",
"numpy.linspace",
"matplotlib.pyplot.title",
"matplotlib.pyplot.step",
"numpy.concatenate",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.clf",
"matplotlib.pyplot.grid",
"matplotlib.pyplot.xlabel",
"numpy.array",
"numpy.zeros",
"matplotlib.pyplot.show",
"matplotlib.pyplot.figure"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
ghiffaryr/grplot | [
"43ea08febac4ffecbce0a6a3d679850f5013aa28"
] | [
"grplot/features/plot/treemaps.py"
] | [
"# Squarified Treemap Layout\n# Implements algorithm from Bruls, Huizing, van Wijk, \"Squarified Treemaps\" and Laserson with some modifications\n# (but not using their pseudocode)\n\n\n# INTERNAL FUNCTIONS not meant to be used by the user\n\n\ndef pad_rectangle(rect):\n if rect[\"dx\"] > 2:\n rect[\"x\"] += 1\n rect[\"dx\"] -= 2\n if rect[\"dy\"] > 2:\n rect[\"y\"] += 1\n rect[\"dy\"] -= 2\n\n\ndef layoutrow(sizes, x, y, dx, dy):\n # generate rects for each size in sizes\n # dx >= dy\n # they will fill up height dy, and width will be determined by their area\n # sizes should be pre-normalized wrt dx * dy (i.e., they should be same units)\n covered_area = sum(sizes)\n width = covered_area / dy\n rects = []\n for size in sizes:\n rects.append({\"x\": x, \"y\": y, \"dx\": width, \"dy\": size / width})\n y += size / width\n return rects\n\n\ndef layoutcol(sizes, x, y, dx, dy):\n # generate rects for each size in sizes\n # dx < dy\n # they will fill up width dx, and height will be determined by their area\n # sizes should be pre-normalized wrt dx * dy (i.e., they should be same units)\n covered_area = sum(sizes)\n height = covered_area / dx\n rects = []\n for size in sizes:\n rects.append({\"x\": x, \"y\": y, \"dx\": size / height, \"dy\": height})\n x += size / height\n return rects\n\n\ndef layout(sizes, x, y, dx, dy):\n return (\n layoutrow(sizes, x, y, dx, dy) if dx >= dy else layoutcol(sizes, x, y, dx, dy)\n )\n\n\ndef leftoverrow(sizes, x, y, dx, dy):\n # compute remaining area when dx >= dy\n covered_area = sum(sizes)\n width = covered_area / dy\n leftover_x = x + width\n leftover_y = y\n leftover_dx = dx - width\n leftover_dy = dy\n return (leftover_x, leftover_y, leftover_dx, leftover_dy)\n\n\ndef leftovercol(sizes, x, y, dx, dy):\n # compute remaining area when dx >= dy\n covered_area = sum(sizes)\n height = covered_area / dx\n leftover_x = x\n leftover_y = y + height\n leftover_dx = dx\n leftover_dy = dy - height\n return (leftover_x, leftover_y, leftover_dx, leftover_dy)\n\n\ndef leftover(sizes, x, y, dx, dy):\n return (\n leftoverrow(sizes, x, y, dx, dy)\n if dx >= dy\n else leftovercol(sizes, x, y, dx, dy)\n )\n\n\ndef worst_ratio(sizes, x, y, dx, dy):\n return max(\n [\n max(rect[\"dx\"] / rect[\"dy\"], rect[\"dy\"] / rect[\"dx\"])\n for rect in layout(sizes, x, y, dx, dy)\n ]\n )\n\n\n# PUBLIC API\n\n\ndef squarify(sizes, x, y, dx, dy):\n \"\"\"Compute treemap rectangles.\n Given a set of values, computes a treemap layout in the specified geometry\n using an algorithm based on Bruls, Huizing, van Wijk, \"Squarified Treemaps\".\n See README for example usage.\n Parameters\n ----------\n sizes : list-like of numeric values\n The set of values to compute a treemap for. `sizes` must be positive\n values sorted in descending order and they should be normalized to the\n total area (i.e., `dx * dy == sum(sizes)`)\n x, y : numeric\n The coordinates of the \"origin\".\n dx, dy : numeric\n The full width (`dx`) and height (`dy`) of the treemap.\n Returns\n -------\n list[dict]\n Each dict in the returned list represents a single rectangle in the\n treemap. The order corresponds to the input order.\n \"\"\"\n sizes = list(map(float, sizes))\n\n if len(sizes) == 0:\n return []\n\n if len(sizes) == 1:\n return layout(sizes, x, y, dx, dy)\n\n # figure out where 'split' should be\n i = 1\n while i < len(sizes) and worst_ratio(sizes[:i], x, y, dx, dy) >= worst_ratio(\n sizes[: (i + 1)], x, y, dx, dy\n ):\n i += 1\n current = sizes[:i]\n remaining = sizes[i:]\n\n (leftover_x, leftover_y, leftover_dx, leftover_dy) = leftover(current, x, y, dx, dy)\n return layout(current, x, y, dx, dy) + squarify(\n remaining, leftover_x, leftover_y, leftover_dx, leftover_dy\n )\n\n\ndef padded_squarify(sizes, x, y, dx, dy):\n \"\"\"Compute padded treemap rectangles.\n See `squarify` docstring for details. The only difference is that the\n returned rectangles have been \"padded\" to allow for a visible border.\n \"\"\"\n rects = squarify(sizes, x, y, dx, dy)\n for rect in rects:\n pad_rectangle(rect)\n return rects\n\n\ndef normalize_sizes(sizes, dx, dy):\n \"\"\"Normalize list of values.\n Normalizes a list of numeric values so that `sum(sizes) == dx * dy`.\n Parameters\n ----------\n sizes : list-like of numeric values\n Input list of numeric values to normalize.\n dx, dy : numeric\n The dimensions of the full rectangle to normalize total values to.\n Returns\n -------\n list[numeric]\n The normalized values.\n \"\"\"\n total_size = sum(sizes)\n total_area = dx * dy\n sizes = map(float, sizes)\n sizes = map(lambda size: size * total_area / total_size, sizes)\n return list(sizes)\n\n\ndef plot(\n sizes,\n norm_x=100,\n norm_y=100,\n color=None,\n label=None,\n value=None,\n ax=None,\n pad=False,\n bar_kwargs=None,\n text_kwargs=None,\n **kwargs\n):\n \"\"\"Plotting with Matplotlib.\n Parameters\n ----------\n sizes\n input for squarify\n norm_x, norm_y\n x and y values for normalization\n color\n color string or list-like (see Matplotlib documentation for details)\n label\n list-like used as label text\n value\n list-like used as value text (in most cases identical with sizes argument)\n ax\n Matplotlib Axes instance\n pad\n draw rectangles with a small gap between them\n bar_kwargs : dict\n keyword arguments passed to matplotlib.Axes.bar\n text_kwargs : dict\n keyword arguments passed to matplotlib.Axes.text\n **kwargs\n Any additional kwargs are merged into `bar_kwargs`. Explicitly provided\n kwargs here will take precedence.\n Returns\n -------\n matplotlib.axes.Axes\n Matplotlib Axes\n \"\"\"\n\n import matplotlib.pyplot as plt\n from math import ceil\n\n if ax is None:\n ax = plt.gca()\n\n if color is None:\n color_cycle = plt.rcParams['axes.prop_cycle'].by_key()['color']\n if len(sizes) > len(color_cycle):\n color_cycle = color_cycle * ceil(len(color_cycle)/len(sizes))\n color = color_cycle[:len(sizes)]\n\n if bar_kwargs is None:\n bar_kwargs = {}\n if text_kwargs is None:\n text_kwargs = {}\n if len(kwargs) > 0:\n bar_kwargs.update(kwargs)\n\n normed = normalize_sizes(sizes, norm_x, norm_y)\n\n if pad:\n rects = padded_squarify(normed, 0, 0, norm_x, norm_y)\n else:\n rects = squarify(normed, 0, 0, norm_x, norm_y)\n\n x = [rect[\"x\"] for rect in rects]\n y = [rect[\"y\"] for rect in rects]\n dx = [rect[\"dx\"] for rect in rects]\n dy = [rect[\"dy\"] for rect in rects]\n\n ax.bar(\n x, dy, width=dx, bottom=y, color=color, label=label, align=\"edge\", **bar_kwargs\n )\n\n if value is not None:\n va = \"center\" if label is None else \"top\"\n\n for v, r in zip(value, rects):\n x, y, dx, dy = r[\"x\"], r[\"y\"], r[\"dx\"], r[\"dy\"]\n ax.text(x + dx / 2, y + dy / 2, v, va=va, ha=\"center\", **text_kwargs)\n\n if label is not None:\n va = \"center\" if value is None else \"bottom\"\n for l, r in zip(label, rects):\n x, y, dx, dy = r[\"x\"], r[\"y\"], r[\"dx\"], r[\"dy\"]\n ax.text(x + dx / 2, y + dy / 2, l, va=va, ha=\"center\", **text_kwargs)\n\n ax.set_xlim(0, norm_x)\n ax.set_ylim(0, norm_y)\n ax.axis('off')\n\n return ax"
] | [
[
"matplotlib.pyplot.gca"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
bkktimber/gluon-nlp | [
"205acce13a83b30eabd7a638e4773e7a4f91059a"
] | [
"tests/unittest/test_sampler.py"
] | [
"import pytest\nimport numpy as np\nfrom mxnet.gluon import data\nimport gluonnlp as nlp\nfrom gluonnlp.data import sampler as s\n\n\nN = 1000\ndef test_sorted_sampler():\n dataset = data.SimpleDataset([np.random.normal(0, 1, (np.random.randint(10, 100), 1, 1))\n for _ in range(N)])\n gt_sample_id = sorted(range(len(dataset)), key=lambda i: dataset[i].shape, reverse=True)\n sample_ret = list(s.SortedSampler([ele.shape[0] for ele in dataset]))\n for lhs, rhs in zip(gt_sample_id, sample_ret):\n assert lhs == rhs\n\[email protected]('seq_lengths', [[np.random.randint(10, 100) for _ in range(N)],\n [(np.random.randint(10, 100), np.random.randint(10, 100))\n for _ in range(N)]])\[email protected]('ratio', [0.0, 0.5])\[email protected]('shuffle', [False, True])\[email protected]('num_buckets', [1, 10, 100, 5000])\[email protected]('bucket_scheme', [s.ConstWidthBucket(),\n s.LinearWidthBucket(),\n s.ExpWidthBucket()])\[email protected]('use_average_length', [False, True])\[email protected]('num_shards', range(4))\ndef test_fixed_bucket_sampler(seq_lengths, ratio, shuffle, num_buckets, bucket_scheme,\n use_average_length, num_shards):\n sampler = s.FixedBucketSampler(seq_lengths,\n batch_size=8,\n num_buckets=num_buckets,\n ratio=ratio, shuffle=shuffle,\n use_average_length=use_average_length,\n bucket_scheme=bucket_scheme,\n num_shards=num_shards)\n print(sampler.stats())\n total_sampled_ids = []\n for batch_sample_ids in sampler:\n if num_shards > 0:\n assert len(batch_sample_ids) == num_shards\n else:\n total_sampled_ids.extend(batch_sample_ids)\n if num_shards == 0:\n assert len(set(total_sampled_ids)) == len(total_sampled_ids) == N\n\[email protected]('bucket_keys', [[1, 5, 10, 100], [10, 100], [200]])\[email protected]('ratio', [0.0, 0.5])\[email protected]('shuffle', [False, True])\ndef test_fixed_bucket_sampler_with_single_key(bucket_keys, ratio, shuffle):\n seq_lengths = [np.random.randint(10, 100) for _ in range(N)]\n sampler = s.FixedBucketSampler(seq_lengths, batch_size=8, num_buckets=None,\n bucket_keys=bucket_keys, ratio=ratio, shuffle=shuffle)\n print(sampler.stats())\n total_sampled_ids = []\n for batch_sample_ids in sampler:\n total_sampled_ids.extend(batch_sample_ids)\n assert len(set(total_sampled_ids)) == len(total_sampled_ids) == N\n\[email protected]('bucket_keys', [[(1, 1), (5, 10), (10, 20), (20, 10), (100, 100)],\n [(20, 20), (30, 15), (100, 100)],\n [(100, 200)]])\[email protected]('ratio', [0.0, 0.5])\[email protected]('shuffle', [False, True])\ndef test_fixed_bucket_sampler_with_single_key(bucket_keys, ratio, shuffle):\n seq_lengths = [(np.random.randint(10, 100), np.random.randint(10, 100)) for _ in range(N)]\n sampler = s.FixedBucketSampler(seq_lengths, batch_size=8, num_buckets=None,\n bucket_keys=bucket_keys, ratio=ratio, shuffle=shuffle)\n print(sampler.stats())\n total_sampled_ids = []\n for batch_sample_ids in sampler:\n total_sampled_ids.extend(batch_sample_ids)\n assert len(set(total_sampled_ids)) == len(total_sampled_ids) == N\n\n\ndef test_fixed_bucket_sampler_compactness():\n samples = list(\n s.FixedBucketSampler(\n np.arange(16, 32), 8, num_buckets=2,\n bucket_scheme=nlp.data.ConstWidthBucket()))\n assert len(samples) == 2\n\n\[email protected]('seq_lengths', [[np.random.randint(10, 100) for _ in range(N)],\n [(np.random.randint(10, 100), np.random.randint(10, 100))\n for _ in range(N)]])\[email protected]('mult', [10, 100])\[email protected]('batch_size', [5, 7])\[email protected]('shuffle', [False, True])\ndef test_sorted_bucket_sampler(seq_lengths, mult, batch_size, shuffle):\n sampler = s.SortedBucketSampler(sort_keys=seq_lengths,\n batch_size=batch_size,\n mult=mult, shuffle=shuffle)\n total_sampled_ids = []\n for batch_sample_ids in sampler:\n total_sampled_ids.extend(batch_sample_ids)\n assert len(set(total_sampled_ids)) == len(total_sampled_ids) == N\n"
] | [
[
"numpy.arange",
"numpy.random.randint"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
jun2tong/bnp-anomaly | [
"c7fa106b5bb29ed6688a3d91e3f302a0a130b896",
"c7fa106b5bb29ed6688a3d91e3f302a0a130b896",
"c7fa106b5bb29ed6688a3d91e3f302a0a130b896",
"c7fa106b5bb29ed6688a3d91e3f302a0a130b896",
"c7fa106b5bb29ed6688a3d91e3f302a0a130b896",
"c7fa106b5bb29ed6688a3d91e3f302a0a130b896",
"c7fa106b5bb29ed6688a3d91e3f302a0a130b896",
"c7fa106b5bb29ed6688a3d91e3f302a0a130b896"
] | [
"tests/endtoend/TestRealRandomGroupXData.py",
"tests/zzz_deprecated_unmaintained/allocmodel/hmm/TestHMMMergeConstructGlobals.py",
"tests/suffstats/TestSuffStatBag.py",
"bnpy/datasets/zzz_unsupported/Monks.py",
"bnpy/obsmodel/GaussRegressYFromFixedXObsModel.py",
"bnpy/callbacks/InferHeldoutTopics.py",
"bnpy/datasets/zzz_unsupported/ToyMMSBK6.py",
"third-party/anchorwordtopics/random_projection.py"
] | [
"import numpy as np\nimport unittest\nfrom collections import OrderedDict\n\nimport bnpy\nfrom AbstractEndToEndTest import AbstractEndToEndTest\n\n\nclass TestEndToEnd(AbstractEndToEndTest):\n __test__ = True\n\n def setUp(self):\n \"\"\" Create the dataset\n \"\"\"\n rng = np.random.RandomState(0)\n X = rng.rand(100, 2)\n doc_range = [0, 20, 40, 50, 100]\n self.Data = bnpy.data.GroupXData(X=X, doc_range=doc_range)\n\n self.possibleAllocModelNames = [\"FiniteMixtureModel\",\n \"FiniteTopicModel\",\n \"HDPTopicModel\",\n ]\n self.possibleObsModelNames = [\"Gauss\",\n \"DiagGauss\",\n \"ZeroMeanGauss\",\n ]\n self.possibleInitNames = [\"randexamples\",\n \"randexamplesbydist\",\n ]\n\n self.possibleLearnAlgsForAllocModel = dict(\n FiniteMixtureModel=[\"EM\", \"VB\", \"soVB\", \"moVB\"],\n FiniteTopicModel=[\"VB\", \"soVB\", \"moVB\"],\n HDPTopicModel=[\"VB\", \"soVB\", \"moVB\"],\n )\n\n def nextAllocKwArgsForVB(self):\n for aName in self.possibleAllocModelNames:\n kwargs = OrderedDict()\n kwargs['name'] = aName\n if aName == 'FiniteMixtureModel':\n for gamma in [0.1, 1.0, 9.9]:\n kwargs['gamma'] = gamma\n yield kwargs\n elif aName == 'DPMixtureModel':\n for gamma0 in [1.0, 9.9]:\n kwargs['gamma0'] = gamma0\n yield kwargs\n elif aName == 'FiniteTopicModel':\n for alpha in [0.1, 0.5, 22]:\n kwargs['alpha'] = alpha\n yield kwargs\n elif aName == 'HDPTopicModel':\n for alpha in [0.1, 0.5]:\n for gamma in [1.0, 5.0]:\n kwargs['gamma'] = gamma\n yield kwargs\n\n def nextObsKwArgsForVB(self, aName):\n for oName in self.possibleObsModelNames:\n for sF in [0.5, 1.0, 5.0]:\n for ECovMat in ['eye', 'covdata']:\n kwargs = OrderedDict()\n kwargs['name'] = oName\n kwargs['ECovMat'] = ECovMat\n kwargs['sF'] = sF\n yield kwargs\n\n def nextInitKwArgs(self, aName, oName):\n for iName in self.possibleInitNames:\n for K in [5, 10]:\n kwargs = OrderedDict()\n kwargs['initname'] = iName\n kwargs['K'] = K\n yield kwargs\n",
"import copy\nimport numpy as np\nimport unittest\nimport bnpy\nrho2beta_active = bnpy.util.StickBreakUtil.rho2beta_active\n\nM_K4 = np.asarray([\n [100, 5, 5, 5],\n [5, 100, 5, 5],\n [5, 5, 100, 5],\n [5, 5, 5, 100],\n])\nNfirst_K4 = np.asarray([1., 1., 1., 1.])\n\n\ndef pprintVec(xvec, fmt='%.3f'):\n print(' '.join([fmt % (x) for x in xvec]))\n\n\nclass TestHMMMergeConstructGlobals(unittest.TestCase):\n\n def shortDescription(self):\n return None\n\n def setUp(self):\n self.origK4_SS = bnpy.suffstats.SuffStatBag(K=4)\n self.origK4_SS.setField('TransStateCount', M_K4, dims=('K', 'K'))\n self.origK4_SS.setField('StartStateCount', Nfirst_K4, dims=('K'))\n\n self.origK4_aModel = bnpy.allocmodel.hmm.HDPHMM.HDPHMM(\n 'VB',\n dict(gamma=10.0, alpha=1.0))\n self.origK4_aModel.update_global_params(self.origK4_SS)\n\n # Now perform a merge of the last two states (at indices 2 and 3)\n kA = 2\n kB = 3\n self.propK3_SS = self.origK4_SS.copy()\n self.propK3_SS.mergeComps(kA, kB)\n self.propK3_aModel = copy.deepcopy(self.origK4_aModel)\n self.propK3_aModel.update_global_params(self.propK3_SS, mergeCompA=kA,\n mergeCompB=kB)\n\n def test_verify_rho_valid(self):\n ''' Verify that the merge value of rho is sensible\n '''\n assert self.propK3_aModel.rho.size == 3\n assert np.all(self.propK3_aModel.rho >= 0)\n assert np.all(self.propK3_aModel.rho <= 1)\n\n def test_aaa_show_original_rho_beta(self):\n print('')\n print('rho')\n pprintVec(self.origK4_aModel.rho)\n print('')\n print('beta')\n pprintVec(rho2beta_active(self.origK4_aModel.rho))\n print('')\n print('omega')\n pprintVec(self.origK4_aModel.omega)\n\n def test_aaa_show_proposed_rho_beta(self):\n print('')\n print('rho')\n pprintVec(self.propK3_aModel.rho)\n print('')\n print('beta')\n pprintVec(rho2beta_active(self.propK3_aModel.rho))\n print('')\n print('omega')\n pprintVec(self.propK3_aModel.omega)\n\n def test_show__convergence_rho(self):\n ''' Observe what happens if we run several consecutive global updates\n\n Seems that in general, rho/omega/theta require many iters to be\n absolutely sure of convergence.\n '''\n print('')\n\n for iter in range(10):\n print(' rho after %d global updates' % (iter))\n pprintVec(self.propK3_aModel.rho)\n\n self.propK3_aModel.update_global_params(self.propK3_SS)\n print((\n ' ' * 10) + '%.3f' % (self.propK3_aModel.OptimizerInfo['fval']))\n\n def test_show__convergence_rho_update_rho_only(self):\n ''' Observe what happens if we run several consecutive optimizer updates\n\n Seems that the optimizer does consistently find a fixed point\n '''\n print('')\n\n fval_orig = self.propK3_aModel.OptimizerInfo['fval']\n print((' ' * 10) + '%.3f' % (fval_orig))\n\n fvals = np.zeros(10)\n for iter in range(10):\n print(' rho after %d optimizer updates' % (iter))\n pprintVec(self.propK3_aModel.rho)\n\n self.propK3_aModel.find_optimum_rhoOmega()\n fval = self.propK3_aModel.OptimizerInfo['fval']\n print((' ' * 10) + '%.3f' % (fval))\n fvals[iter] = fval\n\n # Verify that subsequent updates only improve on original fval\n assert fval_orig >= fvals[0]\n\n # Verify that we've converged\n assert np.allclose(fvals[0], fvals[1:])\n",
"'''\nUnit-tests for SuffStatBag\n'''\n\nfrom bnpy.suffstats.SuffStatBag import SuffStatBag\nimport numpy as np\nimport unittest\n\n\nclass TestSuffStatBag(unittest.TestCase):\n\n def shortDescription(self):\n return None\n\n def test_copy(self, K=2, D=2):\n SS = self.makeSuffStatBagAndFillWithOnes(K, D)\n self.addELBOtoSuffStatBag(SS, K)\n SS2 = SS.copy()\n assert SS2.s == SS.s\n assert np.all(SS2.N == SS.N)\n assert np.all(SS2.getELBOTerm('Elogz') == SS.getELBOTerm('Elogz'))\n assert id(SS2.s) != id(SS.s)\n assert id(SS2.N) != id(SS.N)\n\n def test_removeELBO_and_restoreELBO(self, K=2, D=2):\n SS = self.makeSuffStatBagAndFillWithOnes(K, D)\n self.addELBOtoSuffStatBag(SS, K)\n tmpSS = SS.copy()\n\n E = tmpSS.removeELBOTerms()\n assert SS.hasELBOTerms()\n assert not tmpSS.hasELBOTerms()\n with self.assertRaises(AttributeError):\n tmpSS.getELBOTerm('Elogz')\n\n assert hasattr(E, 'Elogz')\n tmpSS.restoreELBOTerms(E)\n\n for key in E._FieldDims:\n assert np.allclose(SS.getELBOTerm(key), tmpSS.getELBOTerm(key))\n\n def test_ampFactor(self, K=2, D=2):\n SS = self.makeSuffStatBagAndFillWithOnes(K, D)\n SS.applyAmpFactor(3.0)\n assert np.allclose(SS.s, 3.0)\n assert np.allclose(SS.N, 3.0 * np.ones(K))\n assert np.allclose(SS.x, 3.0 * np.ones((K, D)))\n assert np.allclose(SS.xxT, 3.0 * np.ones((K, D, D)))\n assert SS.hasAmpFactor()\n assert SS.ampF == 3.0\n\n def makeSuffStatBagAndFillWithOnes(self, K, D):\n SS = SuffStatBag(K=K, D=D)\n s = 1.0\n N = np.ones(K)\n x = np.ones((K, D))\n xxT = np.ones((K, D, D))\n SS.setField('s', s)\n SS.setField('N', N, dims='K')\n SS.setField('x', x, dims=('K', 'D'))\n SS.setField('xxT', xxT, dims=('K', 'D', 'D'))\n return SS\n\n def addELBOtoSuffStatBag(self, SS, K):\n SS.setELBOTerm('Elogz', np.ones(K), dims='K')\n SS.setELBOTerm('Econst', 1.0, dims=None)\n SS.setMergeTerm('Elogz', 2 * np.ones((K, K)), dims=('K', 'K'))\n return SS\n\n def getExpectedMergedFields(self, K, D, kA=0):\n s = 1.0\n N = np.ones(K - 1)\n N[kA] = 2\n x = np.ones((K - 1, D))\n x[kA] = 2\n xxT = np.ones((K - 1, D, D))\n xxT[kA] = 2\n return s, N, x, xxT\n\n def test_mergeComps_K2_D3_noELBO(self, K=2, D=3):\n SS = self.makeSuffStatBagAndFillWithOnes(K=K, D=D)\n SS.mergeComps(0, 1)\n\n assert SS.K == K - 1\n assert np.allclose(SS.s, 1)\n assert np.allclose(SS.N, 2)\n assert np.allclose(SS.x, 2 * np.ones(D))\n assert np.allclose(SS.xxT, 2 * np.ones((D, D)))\n\n def test_mergeComps_K2_D3_withELBO(self, K=2, D=3):\n SS = self.makeSuffStatBagAndFillWithOnes(K, D)\n self.addELBOtoSuffStatBag(SS, K)\n SS.mergeComps(0, 1)\n\n assert SS.K == K - 1\n assert np.allclose(SS.s, 1)\n assert np.allclose(SS.N, 2)\n assert np.allclose(SS.x, 2 * np.ones(D))\n assert np.allclose(SS.xxT, 2 * np.ones((D, D)))\n\n assert np.allclose(SS.getELBOTerm('Elogz'), 2.0)\n assert np.allclose(SS.getELBOTerm('Econst'), 1.0)\n assert SS._ELBOTerms.K == K - 1\n assert SS._MergeTerms.K == K - 1\n\n def test_mergeComps_K5_D3_withELBO_kA0(self, K=5, D=3):\n SS = self.makeSuffStatBagAndFillWithOnes(K, D)\n self.addELBOtoSuffStatBag(SS, K)\n SS.mergeComps(0, 1)\n s, N, x, xxT = self.getExpectedMergedFields(K, D)\n\n assert SS.K == K - 1\n assert SS._ELBOTerms.K == K - 1\n assert SS._MergeTerms.K == K - 1\n\n assert np.allclose(SS.s, s)\n assert np.allclose(SS.N, N)\n assert np.allclose(SS.x, x)\n assert np.allclose(SS.xxT, xxT)\n\n assert np.allclose(SS.getELBOTerm('Elogz'), [2., 1, 1, 1])\n assert np.allclose(SS.getELBOTerm('Econst'), 1.0)\n assert np.all(np.isnan(SS._MergeTerms.Elogz[0, 1:]))\n assert np.all(np.isnan(SS._MergeTerms.Elogz[:0, 0]))\n\n def test_mergeComps_K5_D3_withELBO_kA3(self, K=5, D=3):\n SS = self.makeSuffStatBagAndFillWithOnes(K, D)\n self.addELBOtoSuffStatBag(SS, K)\n SS.mergeComps(3, 4)\n s, N, x, xxT = self.getExpectedMergedFields(K, D, kA=3)\n\n assert SS.K == K - 1\n assert SS._ELBOTerms.K == K - 1\n assert SS._MergeTerms.K == K - 1\n\n assert np.allclose(SS.s, s)\n assert np.allclose(SS.N, N)\n assert np.allclose(SS.x, x)\n assert np.allclose(SS.xxT, xxT)\n\n assert np.allclose(SS.getELBOTerm('Elogz'), [1., 1, 1, 2.])\n assert np.allclose(SS.getELBOTerm('Econst'), 1.0)\n assert np.all(np.isnan(SS._MergeTerms.Elogz[3, 4:]))\n assert np.all(np.isnan(SS._MergeTerms.Elogz[:3, 3]))\n\n def test_mergeComps_K5_D3_withELBO_back2back(self, K=5, D=3):\n SS = self.makeSuffStatBagAndFillWithOnes(K, D)\n self.addELBOtoSuffStatBag(SS, K)\n SS.mergeComps(3, 4)\n SS.mergeComps(0, 1)\n\n assert SS.K == K - 2\n assert SS._ELBOTerms.K == K - 2\n assert SS._MergeTerms.K == K - 2\n\n def test_removeMerge_and_restoreMerge(self, K=2, D=2):\n SS = self.makeSuffStatBagAndFillWithOnes(K, D)\n self.addELBOtoSuffStatBag(SS, K)\n tmpSS = SS.copy()\n\n M = tmpSS.removeMergeTerms()\n assert SS.hasMergeTerms()\n assert not tmpSS.hasMergeTerms()\n with self.assertRaises(AttributeError):\n tmpSS.getMergeTerm('Elogz')\n\n assert hasattr(M, 'Elogz')\n tmpSS.restoreMergeTerms(M)\n\n for key in M._FieldDims:\n assert np.allclose(SS.getMergeTerm(key), tmpSS.getMergeTerm(key))\n\n def test_only_good_uids_can_add(self, K=2, D=2):\n SS = self.makeSuffStatBagAndFillWithOnes(K, D)\n SS2 = self.makeSuffStatBagAndFillWithOnes(K, D)\n SS2.setUIDs([3,4])\n\n assert np.allclose(SS.uids, [0,1])\n try:\n SS + SS2\n assert False\n except ValueError as e:\n assert 'uid' in str(e).lower()\n",
"'''\nMonks.py\n\nThe dataset was gathered during a period of political turmoil in the cloister.\nThe true labels (nodeZ) reflect the \"faction labels\" of each monk:\n 0 = Young Turks (rebel group)\n 1 = Loyal Opposition (monks who followed tradition and remained loyal),\n 2 = Outcasts (Monks who were not accepted by either faction),\n 3 = Waverers (Monks who couldn't decide on a group).\n\nResources\n---------\nData Source: http://moreno.ss.uci.edu/sampson.dat\n'''\n\nimport numpy as np\nimport scipy.io\nimport os\n\nfrom bnpy.data import GraphXData\n\n\n# monkNames : order copied from the header of sampson.dat\nmonkNames = [\n 'Ramuald',\n 'Bonaventure',\n 'Ambrose',\n 'Berthold',\n 'Peter',\n 'Louis', \n 'Victor',\n 'Winfrid',\n 'John_Bosco',\n 'Gregory',\n 'Hugh',\n 'Boniface',\n 'Mark',\n 'Albert',\n 'Amand',\n 'Basil',\n 'Elias',\n 'Simplicius',\n ]\n\nrelationLabels = [\n 'like_phase1',\n 'like_phase2',\n 'like_phase3',\n 'dislike_phase3',\n 'esteem_phase3',\n 'disesteem_phase3',\n 'posinfluence_phase3',\n 'neginfluence_phase3',\n 'praise_phase3',\n 'negpraise_phase3',\n ]\n\n# Get path to the .mat file with the data\ndatasetdir = os.path.sep.join(\n os.path.abspath(__file__).split(os.path.sep)[:-1])\nif not os.path.isdir(datasetdir):\n raise ValueError('Cannot find Monks dataset directory:\\n' + datasetdir)\n\ndatfilepath = os.path.join(datasetdir, 'rawData', 'sampson.dat')\nif not os.path.isfile(datfilepath):\n raise ValueError('Cannot find Monks dataset file:\\n' + datfilepath)\n\n\ndef get_data(relationName='esteem', phase='3', **kwargs):\n DataLines = list()\n with open(datfilepath, 'r') as f:\n doRecord = 0\n for line in f.readlines():\n line = line.strip()\n if doRecord:\n DataLines.append(np.asarray(\n line.split(' '), dtype=np.int32)>0)\n if line.startswith('DATA:'):\n doRecord = 1\n AdjMatStack = np.vstack(DataLines)\n AdjMatStack[AdjMatStack > 0] = 1\n # AdjMatStack is 180 x 18, where each set of 18 rows\n # corresponds to one of the 10 relations.\n\n # Crop out set of 18 contig rows\n # specified by the relation keyword \n matchID = -1\n matchrelLabel = relationName + '_phase' + str(phase)\n for relID, relLabel in enumerate(relationLabels):\n if relLabel == matchrelLabel:\n matchID = relID\n break\n if matchID < 0:\n raise ValueError(\n \"Cannot find desired relation: %s\" % matchrelLabel)\n AdjMat = AdjMatStack[matchID*18:(matchID+1)*18]\n\n MonkNameToIDMap = dict()\n for uid, name in enumerate(monkNames):\n MonkNameToIDMap[name] = uid\n\n MonkIDToLabelIDMap = dict()\n labelfilepath = datfilepath.replace('sampson.dat', 'sampson_labels.txt')\n with open(labelfilepath, 'r') as f:\n header = f.readline()\n LabelNames = header.strip().split()\n for line in f.readlines():\n line = line.strip()\n if len(line) == 0:\n break\n # \"John_Bosco 1\" >> \"John_Bosco\", \"1\"\n keyval = line.split(' ')\n name = keyval[0]\n labelID = int(keyval[1])\n monkID = MonkNameToIDMap[name]\n MonkIDToLabelIDMap[monkID] = labelID\n nodeZ = np.asarray([\n MonkIDToLabelIDMap[MonkNameToIDMap[mName]]\n for mName in monkNames], dtype=np.int32)\n \n Data = GraphXData(AdjMat=AdjMat,\n nodeNames=monkNames, nodeZ=nodeZ)\n Data.summary = get_data_info()\n Data.name = get_short_name()\n Data.relationName = matchrelLabel\n return Data\n\n\ndef get_data_info():\n return 'Sampson Monks dataset'\n\n\ndef get_short_name():\n return 'Monks'\n\nif __name__ == '__main__':\n from matplotlib import pylab;\n\n import argparse\n parser = argparse.ArgumentParser()\n parser.add_argument('--relationName', default='esteem', type=str)\n parser.add_argument('--phase', default='3', type=str)\n args = parser.parse_args()\n\n print(\"Loading Sampson Monks dataset with relationName=%s at phase=%s\" % (\n args.relationName, args.phase))\n # Fetch data and plot the adjacency matrix\n Data = get_data(relationName=args.relationName, phase=args.phase)\n Xdisp = np.squeeze(Data.toAdjacencyMatrix())\n sortids = np.argsort(Data.TrueParams['nodeZ'])\n Xdisp = Xdisp[sortids, :]\n Xdisp = Xdisp[:, sortids]\n nodeNames = [Data.nodeNames[s] for s in sortids]\n\n pylab.imshow(\n Xdisp, cmap='Greys', interpolation='nearest',\n vmin=0, vmax=1)\n pylab.gca().set_yticks(np.arange(len(nodeNames)))\n pylab.gca().set_yticklabels(nodeNames)\n pylab.title('Adj. matrix: %s' % (Data.relationName))\n pylab.ylabel('Monks (sorted by true label)')\n\n pylab.show()\n\n",
"from builtins import *\nimport numpy as np\nimport scipy.linalg\nfrom scipy.special import gammaln, digamma\n\nfrom bnpy.suffstats import ParamBag, SuffStatBag\nfrom bnpy.util import LOGTWO, LOGPI, LOGTWOPI, EPS\nfrom bnpy.util import dotATA, dotATB, dotABT\nfrom bnpy.util import as1D, as2D, as3D, toCArray, np2flatstr\nfrom bnpy.util import numpyToSharedMemArray, fillSharedMemArray\nfrom bnpy.util.SparseRespStatsUtil import calcSpRXXT\nfrom .AbstractObsModel import AbstractObsModel\n\nclass GaussRegressYFromFixedXObsModel(AbstractObsModel):\n\n ''' Model for producing 1D observations from fixed covariates\n\n Attributes for Prior\n --------------------\n w_E : 1D array, size E\n mean of the regression weights\n P_EE : 2D array, size E x E\n precision matrix for regression weights\n pnu : positive float\n effective sample size of prior on regression precision\n ptau : positive float\n effective scale parameter of prior on regression precision\n\n Attributes for Point Estimation\n -------------------------------\n TODO\n\n Attributes for Approximate Posterior\n ------------------------------------\n w_E : 1D array, size E\n P_EE : 2D array, size E x E\n pnu : positive float\n ptau : positive float\n '''\n\n def __init__(self, inferType='VB', D=0, Data=None, **PriorArgs):\n ''' Initialize bare obsmodel with valid prior hyperparameters.\n\n Returns\n -------\n obsmodel : bare observation model\n Resulting object lacks either EstParams or Post attributes.\n which must be created separately (see init_global_params).\n '''\n if Data is not None:\n self.D = Data.dim\n else:\n self.D = int(D)\n self.E = self.D + 1\n self.K = 0\n self.inferType = inferType\n self.Prior = createParamBagForPrior(Data, **PriorArgs)\n self.Cache = dict()\n\n def get_name(self):\n return 'GaussRegressYFromFixedX'\n\n def get_info_string(self):\n return 'Gaussian regression model for 1D output y from fixed input x'\n\n def get_info_string_prior(self):\n return getStringSummaryOfPrior(self.Prior)\n\n\n def setPostFactors(self, obsModel=None, SS=None, LP=None, Data=None,\n **param_kwargs):\n ''' Set attribute Post to provided values.\n '''\n self.ClearCache()\n if obsModel is not None:\n if hasattr(obsModel, 'Post'):\n self.Post = obsModel.Post.copy()\n self.K = self.Post.K\n else:\n self.setPostFromEstParams(obsModel.EstParams)\n return\n\n if LP is not None and Data is not None:\n SS = self.calcSummaryStats(Data, None, LP)\n if SS is not None:\n self.updatePost(SS)\n else:\n self.Post = packParamBagForPost(**param_kwargs)\n self.K = self.Post.K\n\n def calcSummaryStats(self, Data, SS, LP, **kwargs):\n ''' Calculate summary statistics for given dataset and local parameters\n\n Returns\n --------\n SS : SuffStatBag object, with K components.\n '''\n return calcSummaryStats(Data, SS, LP, **kwargs)\n\n def getDatasetScale(self, SS):\n ''' Get number of observed scalars in dataset from suff stats.\n\n Used for normalizing the ELBO so it has reasonable range.\n\n Returns\n ---------\n s : scalar positive integer\n '''\n return SS.N.sum()\n\n def calcLogSoftEvMatrix_FromPost(self, Data, **kwargs):\n ''' Compute expected log soft evidence of each item under each cluster\n\n Returns\n -------\n E_log_soft_ev_NK : 2D array, size N x K\n '''\n return calcLogSoftEvMatrix_FromPost(\n Data,\n pnu_K=self.Post.pnu_K,\n ptau_K=self.Post.ptau_K,\n w_KE=self.Post.w_KE,\n P_KEE=self.Post.P_KEE,\n **kwargs)\n\n def updatePost(self, SS):\n ''' Update attribute Post for all comps given suff stats.\n\n Optimizes the variational objective for approximating the posterior\n\n Post Condition\n --------------\n Attributes K and Post updated in-place.\n '''\n self.ClearCache()\n if not hasattr(self, 'Post') or self.Post.K != SS.K:\n self.Post = ParamBag(K=SS.K, D=SS.D, E=SS.D+1)\n self.Post = calcPostParamsFromSS(\n SS=SS, Prior=self.Prior, returnParamBag=True)\n self.K = SS.K\n\n\n def calcELBO_Memoized(self, SS, returnVec=0, afterMStep=False, **kwargs):\n \"\"\" Calculate obsModel's objective using suff stats SS and Post.\n\n Args\n -------\n SS : bnpy SuffStatBag\n afterMStep : boolean flag\n if 1, elbo calculated assuming M-step just completed\n\n Returns\n -------\n elbo_K : scalar float\n Equal to E[ log p(x) + log p(phi) - log q(phi)]\n \"\"\"\n return calcELBOFromSSAndPost(\n SS=SS,\n Post=self.Post,\n Prior=self.Prior,\n returnVec=returnVec,\n afterMStep=afterMStep)\n\n def _unpack_params(self, k=None):\n ''' Unpack internal attributes into dict of parameters\n\n Args\n ----\n k : int or None\n if None, use Prior\n otherwise, use specific cluster identified by k\n\n Returns\n -------\n pdict : dict, with fields\n pnu, ptau, w_E, P_EE\n '''\n if k is None:\n pnu = self.Prior.pnu\n ptau = self.Prior.ptau\n w_E = self.Prior.w_E\n P_EE = self.Prior.P_EE\n else:\n pnu = self.Post.pnu_K[k]\n ptau = self.Post.ptau_K[k]\n w_E = self.Post.w_KE[k]\n P_EE = self.Post.P_KEE[k]\n return dict(pnu=pnu, ptau=ptau, w_E=w_E, P_EE=P_EE)\n\n def _E_log_d(self, k=None):\n ''' Cacheable function computing expectation of log delta\n\n Returns\n -------\n scalar\n '''\n pdict = self._unpack_params(k=k)\n return E_log_d(**pdict)\n\n def _E_d(self, k=None):\n ''' Cacheable function computing expectation of delta\n\n Returns\n -------\n scalar\n '''\n pdict = self._unpack_params(k=k)\n return E_d(**pdict)\n\n def _E_d_w(self, k=None):\n ''' Cacheable function computing expectation of delta * weight vector\n\n Returns\n -------\n val_E : 1D array\n '''\n pdict = self._unpack_params(k=k)\n return E_d_w(**pdict)\n\n def _E_d_w_wT(self, k=None):\n ''' Cacheable function computing expectation of delta * outer product\n\n Returns\n -------\n val_EE : 2D array, size E x E\n '''\n pdict = self._unpack_params(k=k)\n return E_d_w_wT(**pdict)\n\n def calcHardMergeGap(self, SS, kA, kB):\n ''' Calculate change in ELBO after a hard merge applied to this model\n\n Returns\n ---------\n gap : scalar real, indicates change in ELBO after merge of kA, kB\n '''\n gap, _, _ = calcHardMergeGapForPair(\n SS=SS, Post=self.Post, Prior=self.Prior, kA=kA, kB=kB)\n return gap\n\n def calcHardMergeGap_SpecificPairs(self, SS, PairList):\n ''' Calc change in ELBO for specific list of candidate hard merge pairs\n\n Returns\n ---------\n Gaps : 1D array, size L\n Gap[j] : scalar change in ELBO after merge of pair in PairList[j]\n '''\n Gaps = np.zeros(len(PairList))\n cPrior = None\n cPost_K = [None for k in range(SS.K)]\n for ii, (kA, kB) in enumerate(PairList):\n Gaps[ii], cPost_K, cPrior = calcHardMergeGapForPair(\n SS=SS, Post=self.Post, Prior=self.Prior, kA=kA, kB=kB,\n cPrior=cPrior, cPost_K=cPost_K)\n return Gaps\n\ndef calcLocalParams(Dslice, **kwargs):\n E_log_soft_ev_NK = calcLogSoftEvMatrix_FromPost(Dslice, **kwargs)\n LP = dict(E_log_soft_ev=E_log_soft_ev_NK)\n return LP\n\ndef calcLogSoftEvMatrix_FromPost(\n Dslice,\n Post=None,\n E_log_d_K=None,\n E_d_K=None,\n pnu_K=None,\n ptau_K=None,\n w_KE=None,\n P_KEE=None,\n chol_P_KEE=None,\n E_log_soft_ev_NK=None,\n **kwargs):\n ''' Calculate expected log soft ev matrix under approximate posterior\n\n Returns\n -------\n E_log_soft_ev_NK : 2D array, size N x K\n '''\n if not hasattr(Dslice, 'X_NE'):\n Dslice.X_NE = np.hstack([Dslice.X, np.ones(Dslice.nObs)[:,np.newaxis]])\n\n if Post is not None:\n pnu_K = Post.pnu_K\n ptau_K = Post.ptau_K\n w_KE = Post.w_KE\n P_KEE = Post.P_KEE\n\n if E_log_d_K is None:\n K = pnu_K.size\n E_log_d_K = np.zeros(K)\n for k in range(K):\n E_log_d_K[k] = E_log_d(pnu=pnu_K[k], ptau=ptau_K[k])\n E_d_K = np.zeros(K)\n for k in range(K):\n E_d_K[k] = E_d(pnu=pnu_K[k], ptau=ptau_K[k])\n else:\n K = E_log_d_K.size\n\n if E_log_soft_ev_NK is None:\n E_log_soft_ev_NK = np.zeros((Dslice.nObs, K))\n assert E_log_soft_ev_NK.shape == (Dslice.nObs, K)\n\n for k in range(K):\n E_log_soft_ev_NK[:, k] += (\n - 0.5 * LOGTWOPI \\\n + 0.5 * E_log_d_K[k]\n - 0.5 * E_mahal_dist_N(\n Dslice.Y, Dslice.X_NE,\n E_d=E_d_K[k],\n w_E=w_KE[k],\n P_EE=P_KEE[k],\n )\n )\n return E_log_soft_ev_NK\n\ndef E_mahal_dist_N(Y_N, X_NE,\n E_d=None,\n pnu=None,\n ptau=None,\n w_E=None,\n P_EE=None,\n chol_P_EE=None):\n ''' Calculate expected mahalanobis distance under regression model\n\n For each data index n, computes expected distance using provided\n cluster-specific parameters:\n $$\n d_n = E[ delta_k (y_n - w_k^T x_n)^2 ]\n $$\n\n Returns\n -------\n d_N : 1D array, size N\n '''\n if E_d is None:\n E_d = E_d(pnu=pnu, ptau=ptau)\n if chol_P_EE is None:\n chol_P_EE = scipy.linalg.cholesky(P_EE, lower=True)\n\n # Squared diff term\n sq_diff_YX_N = Y_N[:,0] - np.dot(X_NE, w_E)\n sq_diff_YX_N *= sq_diff_YX_N\n sq_diff_YX_N *= E_d\n\n xPx_EN = np.linalg.solve(chol_P_EE, X_NE.T)\n xPx_EN *= xPx_EN\n xPx_N = np.sum(xPx_EN, axis=0)\n\n E_mahal_dist_N = sq_diff_YX_N\n E_mahal_dist_N += xPx_N\n try:\n assert E_mahal_dist_N.min() > -1e-9\n except AssertionError:\n from IPython import embed; embed()\n return E_mahal_dist_N\n\ndef calcSummaryStats(Data, SS, LP, **kwargs):\n ''' Calculate summary statistics for given dataset and local parameters\n\n Returns\n --------\n SS : SuffStatBag object, with K components.\n '''\n if not hasattr(Data, 'X_NE'):\n Data.X_NE = np.hstack([Data.X, np.ones(Data.nObs)[:,np.newaxis]])\n\n Y_N = Data.Y\n X_NE = Data.X_NE\n E = X_NE.shape[1]\n\n if 'resp' in LP:\n # Dense responsibility calculations\n resp = LP['resp']\n K = resp.shape[1]\n S_yy_K = dotATB(resp, np.square(Y_N)).flatten()\n S_yx_KE = dotATB(resp, Y_N * X_NE)\n\n # Expected outer product\n S_xxT_KEE = np.zeros((K, E, E))\n sqrtResp_k_N = np.sqrt(resp[:, 0])\n sqrtR_X_k_NE = sqrtResp_k_N[:, np.newaxis] * X_NE\n S_xxT_KEE[0] = dotATA(sqrtR_X_k_NE)\n for k in range(1, K):\n np.sqrt(resp[:, k], out=sqrtResp_k_N)\n np.multiply(sqrtResp_k_N[:, np.newaxis], X_NE, out=sqrtR_X_k_NE)\n S_xxT_KEE[k] = dotATA(sqrtR_X_k_NE)\n else:\n raise ValueError(\"TODO\")\n spR = LP['spR']\n K = spR.shape[1]\n\n if SS is None:\n SS = SuffStatBag(K=K, D=Data.dim, E=E)\n elif not hasattr(SS, 'E'):\n SS._Fields.E = E\n SS.setField('xxT_KEE', S_xxT_KEE, dims=('K', 'E', 'E'))\n SS.setField('yx_KE', S_yx_KE, dims=('K', 'E'))\n SS.setField('yy_K', S_yy_K, dims=('K'))\n # Expected count for each k\n # Usually computed by allocmodel. But just in case...\n if not hasattr(SS, 'N'):\n if 'resp' in LP:\n SS.setField('N', LP['resp'].sum(axis=0), dims='K')\n else:\n SS.setField('N', as1D(toCArray(LP['spR'].sum(axis=0))), dims='K')\n\n #SS.setField(\"N_K\", SS.N, dims=\"K\")\n return SS\n\n\ndef calcPostParamsFromSS(\n SS=None, xxT_KEE=None, yx_KE=None, yy_K=None, N_K=None,\n Prior=None,\n Post=None,\n returnParamBag=True,\n **kwargs):\n ''' Calc updated posterior parameters for all clusters from suff stats\n\n Returns\n --------\n pnu_K : 1D array, size K\n ptau_K : 1D array, size K\n w_KE : 2D array, size K x E\n P_KEE : 3D array, size K x E x E\n '''\n K = SS.K\n E = SS.E\n\n pnu_K = Prior.pnu + SS.N\n P_KEE = Prior.P_EE[np.newaxis,:] + SS.xxT_KEE\n\n w_KE = np.zeros((K, E))\n for k in range(K):\n w_KE[k] = np.linalg.solve(\n P_KEE[k],\n SS.yx_KE[k] + Prior.Pw_E)\n\n ptau_K = np.zeros(K)\n ptau_K[:] = SS.yy_K + Prior.ptau + Prior.wPw_1\n for k in range(K):\n ptau_K[k] -= np.dot(w_KE[k], np.dot(P_KEE[k], w_KE[k]))\n\n if not returnParamBag:\n return pnu_K, ptau_K, w_KE, P_KEE\n return packParamBagForPost(\n pnu_K=pnu_K,\n ptau_K=ptau_K,\n w_KE=w_KE,\n P_KEE=P_KEE,\n Post=Post)\n\ndef calcPostParamsFromSSForComp(\n SS=None, kA=0, kB=None,\n Prior=None,\n **kwargs):\n ''' Calc posterior parameters for specific cluster from SS\n\n Returns\n --------\n pnu_K : float\n ptau_K : float\n w_KE : 1D array, size E\n P_KEE : 2D array, size E x E\n '''\n K = 1\n E = SS.E\n\n if kB is None:\n SS_N_K = SS.N[kA]\n SS_xxT_KEE = SS.xxT_KEE[kA]\n SS_yx_KE = SS.yx_KE[kA]\n SS_yy_K = SS.yy_K[kA]\n else:\n SS_N_K = SS.N[kA] + SS.N[kB]\n SS_xxT_KEE = SS.xxT_KEE[kA] + SS.xxT_KEE[kB]\n SS_yx_KE = SS.yx_KE[kA] + SS.yx_KE[kB]\n SS_yy_K = SS.yy_K[kA] + SS.yy_K[kB]\n\n pnu_K = Prior.pnu + SS_N_K\n P_KEE = Prior.P_EE[np.newaxis,:] + SS_xxT_KEE\n\n w_KE = np.zeros((K, E))\n for k in range(K):\n w_KE[k] = np.linalg.solve(\n P_KEE[k],\n SS_yx_KE + Prior.Pw_E)\n\n ptau_K = np.zeros(K)\n ptau_K[:] = SS_yy_K + Prior.ptau + Prior.wPw_1\n for k in range(K):\n ptau_K[k] -= np.dot(w_KE[k], np.dot(P_KEE[k], w_KE[k]))\n\n return pnu_K, ptau_K, w_KE, P_KEE\n\ndef calcELBOFromSSAndPost(\n SS, Post=None, Prior=None,\n returnVec=0, afterMStep=False, **kwargs):\n \"\"\" Calculate obsModel objective function using suff stats SS and Post.\n\n Args\n -------\n SS : bnpy SuffStatBag\n Post : bnpy ParamBag\n afterMStep : boolean flag\n if 1, elbo calculated assuming M-step just completed\n\n Returns\n -------\n elbo_K : scalar float\n Equal to E[ log p(x) + log p(phi) - log q(phi)]\n \"\"\"\n elbo_K = np.zeros(SS.K)\n for k in range(SS.K):\n elbo_K[k] = - (0.5 * LOGTWOPI) * SS.N[k] \\\n + c_Func(\n pnu=Prior.pnu,\n ptau=Prior.ptau,\n w_E=Prior.w_E,\n P_EE=Prior.P_EE) \\\n - c_Func(\n pnu=Post.pnu_K[k],\n ptau=Post.ptau_K[k],\n w_E=Post.w_KE[k],\n P_EE=Post.P_KEE[k])\n if not afterMStep:\n Post_Pw_E_k = np.dot(Post.P_KEE[k], Post.w_KE[k])\n Post_wPw_1_k = np.dot(Post.w_KE[k], Post_Pw_E_k)\n # A : log delta term\n A_1 = SS.N[k] + Prior.pnu - Post.pnu_K[k]\n Elogd_k_1 = E_log_d(\n pnu=Post.pnu_K[k],\n ptau=Post.ptau_K[k])\n elbo_K[k] -= 0.5 * A_1 * Elogd_k_1\n # B : delta term\n B_1 = SS.yy_K[k] \\\n + Prior.ptau + Prior.wPw_1 \\\n - Post.ptau_K[k] - Post_wPw_1_k\n Ed_k_1 = E_d(\n pnu=Post.pnu_K[k],\n ptau=Post.ptau_K[k])\n elbo_K[k] -= 0.5 * B_1 * Ed_k_1\n # C : delta * w_E term, size E\n C_E = SS.yx_KE[k] + \\\n + Prior.Pw_E \\\n - Post_Pw_E_k\n Edw_k_E = E_d_w(\n pnu=Post.pnu_K[k],\n ptau=Post.ptau_K[k],\n w_E=Post.w_KE[k])\n elbo_K[k] += np.inner(C_E, Edw_k_E)\n # D : delta * w_E w_E term, size E * E\n D_EE = SS.xxT_KEE[k] + Prior.P_EE - Post.P_KEE[k]\n EdwwT_k_EE = E_d_w_wT(\n pnu=Post.pnu_K[k],\n ptau=Post.ptau_K[k],\n w_E=Post.w_KE[k],\n P_EE=Post.P_KEE[k])\n elbo_K[k] -= 0.5 * np.trace(np.dot(D_EE, EdwwT_k_EE))\n if returnVec:\n return elbo_K\n return np.sum(elbo_K)\n\ndef E_log_d(w_E=None, P_EE=None, pnu=None, ptau=None, **kwargs):\n ''' Expected value of log of precision parameter delta\n\n Returns\n -------\n Elogdelta : scalar\n '''\n return digamma(0.5 * pnu) - np.log(0.5 * ptau)\n\ndef E_d(w_E=None, P_EE=None, pnu=None, ptau=None, **kwargs):\n ''' Expected value of precision parameter delta\n\n Returns\n -------\n Edelta : positive scalar\n '''\n return pnu / ptau\n\ndef E_d_w(w_E=None, P_EE=None, pnu=None, ptau=None, **kwargs):\n ''' Expected value of weight vector scaled by delta\n\n $$\n E[ \\delta_k w_k ]\n $$\n\n Returns\n -------\n E_d_w : 1D array, size E\n '''\n return (pnu / ptau) * w_E\n\ndef E_d_w_wT(w_E=None, P_EE=None, pnu=None, ptau=None, **kwargs):\n ''' Expected value of outer product of weight vector, scaled by delta\n\n $$\n E[ \\delta_k w_k w_k^T ]\n $$\n\n Returns\n -------\n E_d_wwT : 2D array, size E x E\n '''\n return np.linalg.inv(P_EE) + (pnu / ptau) * np.outer(w_E, w_E)\n\ndef c_Func(pnu=1e-9, ptau=1e-9, w_E=None, P_EE=None, logdet_P_EE=None):\n ''' Compute cumulant function for Multivariate-Normal-Univariate-Wishart\n\n Returns\n -------\n c : float\n scalar output of cumulant function\n '''\n if logdet_P_EE is None:\n logdet_P_EE = np.log(np.linalg.det(P_EE))\n E = w_E.size\n c_wish_1dim = (0.5 * pnu) * np.log(0.5 * ptau) - gammaln(0.5 * pnu)\n c_normal_Edim = - 0.5 * E * LOGTWOPI + 0.5 * logdet_P_EE\n return c_wish_1dim + c_normal_Edim\n\ndef packParamBagForPost(\n pnu_K=None,\n ptau_K=None,\n w_KE=None,\n P_KEE=None,\n Post=None,\n **kwargs):\n ''' Parse provided array args and pack into parameter bag\n\n Returns\n -------\n Post : ParamBag, with K clusters\n '''\n pnu_K = as1D(pnu_K)\n ptau_K = as1D(ptau_K)\n w_KE = as2D(w_KE)\n P_KEE = as3D(P_KEE)\n\n K = pnu_K.size\n E = w_KE.shape[1]\n if Post is None:\n Post = ParamBag(K=K, D=E-1, E=E)\n elif not hasattr(Post, 'E'):\n Post.E = E\n assert Post.K == K\n assert Post.D == E - 1\n assert Post.E == E\n Post.setField('pnu_K', pnu_K, dims=('K'))\n Post.setField('ptau_K', ptau_K, dims=('K'))\n Post.setField('w_KE', w_KE, dims=('K', 'E'))\n Post.setField('P_KEE', P_KEE, dims=('K', 'E', 'E'))\n return Post\n\ndef getStringSummaryOfPrior(Prior):\n ''' Create string summarizing prior information\n\n Returns\n -------\n s : str\n '''\n msg = 'Gaussian-Wishart joint prior on regression weights/prec\\n'\n msg += \"Wishart on precision scalar\\n\"\n msg += \" pnu = %.3g\\n\" % (Prior.pnu)\n msg += \" ptau = %.3g\\n\" % (Prior.ptau)\n msg += \" mean = %.3g\\n\" % (E_d(pnu=Prior.pnu, ptau=Prior.ptau))\n w_E_str = np2flatstr(Prior.w_E[:2], fmt='% .2g')\n P_EE_str = np2flatstr(np.diag(Prior.P_EE)[:2], fmt='% .2g')\n msg += \"Gaussian on regression weight vector\\n\"\n msg += \" mean = %s\\n\" % w_E_str\n msg += \" diag[prec] = %s\\n\" % P_EE_str\n return msg\n\ndef createParamBagForPrior(\n Data=None, D=0,\n pnu=0, ptau=None, w_E=0,\n P_EE=None, P_diag_E=None, P_diag_val=1.0,\n Prior=None,\n **kwargs):\n ''' Initialize Prior ParamBag attribute.\n\n Returns\n -------\n Prior : ParamBag\n with dimension attributes K, D, E\n with parameter attributes pnu, ptau, w_E, P_EE\n '''\n if Data is None:\n D = int(D)\n else:\n D = int(Data.dim)\n E = D + 1\n\n # Init parameters of 1D Wishart prior on delta\n pnu = np.maximum(pnu, 1e-9)\n ptau = np.maximum(ptau, 1e-9)\n\n # Initialize precision matrix of the weight vector\n if P_EE is not None:\n P_EE = np.asarray(P_EE)\n elif P_diag_E is not None:\n P_EE = np.diag(np.asarray(P_diag_E))\n else:\n P_EE = np.diag(P_diag_val * np.ones(E))\n assert P_EE.ndim == 2\n assert P_EE.shape == (E,E)\n\n # Initialize mean of the weight vector\n w_E = as1D(np.asarray(w_E))\n if w_E.size < E:\n w_E = np.tile(w_E, E)[:E]\n assert w_E.ndim == 1\n assert w_E.size == E\n\n if Prior is None:\n Prior = ParamBag(K=0, D=D, E=E)\n if not hasattr(Prior, 'E'):\n Prior.E = E\n assert Prior.D == D\n assert Prior.E == E\n Prior.setField('pnu', pnu, dims=None)\n Prior.setField('ptau', ptau, dims=None)\n Prior.setField('w_E', w_E, dims=('E'))\n Prior.setField('P_EE', P_EE, dims=('E', 'E'))\n\n Pw_E = np.dot(P_EE, w_E)\n wPw_1 = np.dot(w_E, Pw_E)\n Prior.setField('Pw_E', Pw_E, dims=('E'))\n Prior.setField('wPw_1', wPw_1, dims=None)\n return Prior\n\ndef calcHardMergeGapForPair(\n SS=None, Prior=None, Post=None, kA=0, kB=1,\n cPost_K=None,\n cPrior=None,\n ):\n ''' Compute difference in ELBO objective after merging two clusters\n\n Uses caching if desired\n\n Returns\n -------\n Ldiff : scalar\n difference in ELBO from merging cluster indices kA and kB\n '''\n if cPost_K is None or cPost_K[kA] is None:\n cA = c_Func(\n pnu=Post.pnu_K[kA], ptau=Post.ptau_K[kA],\n w_E=Post.w_KE[kA], P_EE=Post.P_KEE[kA])\n cPost_K[kA] = cA\n else:\n cA = cPost_K[kA]\n\n if cPost_K is None or cPost_K[kB] is None:\n cB = c_Func(\n pnu=Post.pnu_K[kB], ptau=Post.ptau_K[kB],\n w_E=Post.w_KE[kB], P_EE=Post.P_KEE[kB])\n cPost_K[kB] = cB\n else:\n cB = cPost_K[kB]\n\n if cPrior is None:\n cPrior = c_Func(pnu=Prior.pnu, ptau=Prior.ptau,\n w_E=Prior.w_E, P_EE=Prior.P_EE)\n cAB = c_Func(*calcPostParamsFromSSForComp(SS, kA, kB, Prior))\n return cAB + cPrior - cA - cB, cPost_K, cPrior\n",
"from builtins import *\nimport argparse\nimport time\nimport os\nimport numpy as np\nimport scipy.io\nimport sklearn.metrics\nimport bnpy\nimport glob\nimport warnings\nimport logging\n\nfrom scipy.special import digamma\nfrom scipy.misc import logsumexp\nfrom bnpy.allocmodel.topics.LocalStepSingleDoc import calcLocalParams_SingleDoc\nfrom bnpy.ioutil.ModelReader import \\\n getPrefixForLapQuery, loadTopicModel, loadModelForLap\nfrom bnpy.ioutil.DataReader import \\\n loadDataFromSavedTask, loadLPKwargsFromDisk, loadDataKwargsFromDisk\nfrom bnpy.ioutil.DataReader import str2numorstr\n\nVERSION = 0.1\n\ndef evalTopicModelOnTestDataFromTaskpath(\n taskpath='',\n queryLap=0,\n nLap=0,\n elapsedTime=None,\n seed=42,\n dataSplitName='test',\n fracHeldout=0.2,\n printFunc=None,\n **kwargs):\n ''' Evaluate trained topic model saved in specified task on test data\n '''\n stime = time.time()\n\n LPkwargs = dict(\n nnzPerRowLP=0,\n nCoordAscentItersLP=100,\n convThrLP=0.01,\n restartLP=0,\n initDocTopicCountLP='setDocProbsToEGlobalProbs')\n for key in kwargs:\n if key in LPkwargs and kwargs[key] is not None:\n LPkwargs[key] = str2val(kwargs[key])\n # Force to be 0, which gives better performance\n # (due to mismatch in objectives)\n if 'restartLP' in LPkwargs:\n LPkwargs['restartLP'] = 0\n # Force to be 0, so we are fair at test time\n if 'nnzPerRowLP' in LPkwargs:\n LPkwargs['nnzPerRowLP'] = 0\n\n # Load test dataset\n Data = loadDataFromSavedTask(taskpath, dataSplitName=dataSplitName)\n\n # Check if info is stored in topic-model form\n topicFileList = glob.glob(os.path.join(taskpath, 'Lap*Topic*'))\n if len(topicFileList) > 0:\n topics, probs, alpha = loadTopicModel(\n taskpath, queryLap=queryLap,\n returnTPA=1, normalizeTopics=1, normalizeProbs=1)\n K = probs.size\n else:\n hmodel, foundLap = loadModelForLap(taskpath, queryLap)\n if hasattr(Data, 'word_count'):\n # Convert to topics 2D array (K x V)\n topics = hmodel.obsModel.getTopics()\n probs = hmodel.allocModel.get_active_comp_probs()\n else:\n hmodel.obsModel.setEstParamsFromPost(hmodel.obsModel.Post)\n hmodel.obsModel.inferType = \"EM\" # Point estimate!\n\n assert np.allclose(foundLap, queryLap)\n if hasattr(hmodel.allocModel, 'alpha'):\n alpha = hmodel.allocModel.alpha\n else:\n try:\n DataKwargs = loadDataKwargsFromDisk(taskpath)\n alpha = float(DataKwargs['alpha'])\n except Exception:\n alpha = 0.5\n K = hmodel.allocModel.K\n # Prepare debugging statements\n if printFunc:\n startmsg = \"Heldout Metrics at lap %.3f\" % (queryLap)\n filler = '=' * (80 - len(startmsg))\n printFunc(startmsg + ' ' + filler)\n if hasattr(Data, 'word_count'):\n nAtom = Data.word_count.sum()\n else:\n nAtom = Data.nObs\n msg = \"%s heldout data. %d documents. %d total atoms.\" % (\n Data.name, Data.nDoc, nAtom)\n printFunc(msg)\n printFunc(\"Using trained model from lap %7.3f with %d topics\" % (\n queryLap, K))\n printFunc(\"Using alpha=%.3f for heldout inference.\" % (alpha))\n printFunc(\"Local step params:\")\n for key in ['nCoordAscentItersLP', 'convThrLP', 'restartLP']:\n printFunc(\" %s: %s\" % (key, str(LPkwargs[key])))\n msg = \"Splitting each doc\" + \\\n \" into %3.0f%% train and %3.0f%% test, with seed %d\" % (\n 100*(1-fracHeldout), 100*fracHeldout, seed)\n printFunc(msg)\n\n # Preallocate storage for metrics\n KactivePerDoc = np.zeros(Data.nDoc)\n logpTokensPerDoc = np.zeros(Data.nDoc)\n nTokensPerDoc = np.zeros(Data.nDoc, dtype=np.int32)\n if hasattr(Data, 'word_count'):\n aucPerDoc = np.zeros(Data.nDoc)\n RprecisionPerDoc = np.zeros(Data.nDoc)\n for d in range(Data.nDoc):\n Data_d = Data.select_subset_by_mask([d], doTrackFullSize=0)\n if hasattr(Data, 'word_count'):\n Info_d = calcPredLikForDoc(\n Data_d, topics, probs, alpha,\n fracHeldout=fracHeldout,\n seed=seed + d,\n LPkwargs=LPkwargs)\n logpTokensPerDoc[d] = Info_d['sumlogProbTokens']\n nTokensPerDoc[d] = Info_d['nHeldoutToken']\n aucPerDoc[d] = Info_d['auc']\n RprecisionPerDoc[d] = Info_d['R_precision']\n KactivePerDoc[d] = np.sum(Info_d['DocTopicCount'] >= 1.0)\n avgAUCscore = np.mean(aucPerDoc[:d+1])\n avgRscore = np.mean(RprecisionPerDoc[:d+1])\n scoreMsg = \"avgLik %.4f avgAUC %.4f avgRPrec %.4f medianKact %d\" % (\n np.sum(logpTokensPerDoc[:d+1]) / np.sum(nTokensPerDoc[:d+1]),\n avgAUCscore, avgRscore, np.median(KactivePerDoc[:d+1]))\n SVars = dict(\n avgRPrecScore=avgRscore,\n avgAUCScore=avgAUCscore,\n avgAUCScorePerDoc=aucPerDoc,\n avgRPrecScorePerDoc=RprecisionPerDoc)\n else:\n Info_d = calcPredLikForDocFromHModel(\n Data_d, hmodel,\n alpha=alpha,\n fracHeldout=fracHeldout,\n seed=seed + d,\n LPkwargs=LPkwargs)\n logpTokensPerDoc[d] = Info_d['sumlogProbTokens']\n nTokensPerDoc[d] = Info_d['nHeldoutToken']\n scoreMsg = \"avgLik %.4f\" % (\n np.sum(logpTokensPerDoc[:d+1]) / np.sum(nTokensPerDoc[:d+1]),\n )\n SVars = dict()\n\n if d == 0 or (d+1) % 25 == 0 or d == Data.nDoc - 1:\n if printFunc:\n etime = time.time() - stime\n msg = \"%5d/%d after %8.1f sec \" % (d+1, Data.nDoc, etime)\n printFunc(msg + scoreMsg)\n # Aggregate results\n meanlogpTokensPerDoc = np.sum(logpTokensPerDoc) / np.sum(nTokensPerDoc)\n '''\n # Compute heldout Lscore\n if not hasattr(Data, 'word_count'):\n if hasattr(hmodel.allocModel, 'gamma'):\n gamma = hmodel.allocModel.gamma\n else:\n gamma = hmodel.allocModel.gamma0\n aParams = dict(gamma=gamma, alpha=alpha)\n oParams = hmodel.obsModel.get_prior_dict()\n del oParams['inferType']\n\n # Create DP mixture model from current hmodel\n DPmodel = bnpy.HModel.CreateEntireModel('VB', 'DPMixtureModel',\n hmodel.getObsModelName(),\n aParams, oParams,\n Data)\n DPmodel.set_global_params(hmodel=hmodel)\n LP = DPmodel.calc_local_params(Data, **LPkwargs)\n SS = DPmodel.get_global_suff_stats(Data, LP, doPrecompEntropy=1)\n dpLscore = DPmodel.calc_evidence(SS=SS)\n\n # Create HDP topic model from current hmodel\n HDPmodel = bnpy.HModel.CreateEntireModel('VB', 'HDPTopicModel',\n hmodel.getObsModelName(),\n aParams, oParams,\n Data)\n HDPmodel.set_global_params(hmodel=hmodel)\n LP = HDPmodel.calc_local_params(Data, **LPkwargs)\n SS = HDPmodel.get_global_suff_stats(Data, LP, doPrecompEntropy=1)\n hdpLscore = HDPmodel.calc_evidence(SS=SS)\n\n SVars['dpLscore'] = dpLscore\n SVars['hdpLscore'] = hdpLscore\n printFunc(\"~~~ dpL=%.6e\\n~~~hdpL=%.6e\" % (dpLscore, hdpLscore))\n '''\n # Prepare to save results.\n if dataSplitName.count('test'):\n outfileprefix = 'predlik-'\n else:\n outfileprefix = dataSplitName + '-predlik-'\n prefix, lap = getPrefixForLapQuery(taskpath, queryLap)\n outmatfile = os.path.join(taskpath, prefix + \"Heldout_%s.mat\"\n % (dataSplitName))\n # Collect all quantities to save into giant dict.\n SaveVars = dict(\n version=VERSION,\n outmatfile=outmatfile,\n fracHeldout=fracHeldout,\n predLLPerDoc=logpTokensPerDoc,\n avgPredLL=np.sum(logpTokensPerDoc) / np.sum(nTokensPerDoc),\n K=K,\n KactivePerDoc=KactivePerDoc,\n nTokensPerDoc=nTokensPerDoc,\n **LPkwargs)\n SaveVars.update(SVars)\n scipy.io.savemat(outmatfile, SaveVars, oned_as='row')\n SVars['avgLikScore'] = SaveVars['avgPredLL']\n SVars['lapTrain'] = queryLap\n SVars['K'] = K\n for p in [10, 50, 90]:\n SVars['KactivePercentile%02d' % (p)] = np.percentile(KactivePerDoc, p)\n\n\n # Record total time spent doing current work\n timeSpent = time.time() - stime\n if elapsedTime is not None:\n SVars['timeTrainAndEval'] = elapsedTime + timeSpent\n # Load previous time spent non training from disk\n timeSpentFilepaths = glob.glob(os.path.join(taskpath, '*-timeEvalOnly.txt'))\n totalTimeSpent = timeSpent\n splitTimeSpent = timeSpent\n for timeSpentFilepath in timeSpentFilepaths:\n with open(timeSpentFilepath,'r') as f:\n for line in f.readlines():\n pass\n prevTime = float(line.strip())\n cond1 = dataSplitName.count('valid')\n cond2 = timeSpentFilepath.count('valid')\n if cond1 and cond2:\n splitTimeSpent += prevTime\n elif (not cond1) and (not cond2):\n splitTimeSpent += prevTime\n totalTimeSpent += prevTime\n SVars['timeEvalOnly'] = splitTimeSpent\n # Mark total time spent purely on training\n if elapsedTime is not None:\n SVars['timeTrain'] = SVars['timeTrainAndEval'] - totalTimeSpent\n for key in SVars:\n if key.endswith('PerDoc'):\n continue\n outtxtfile = os.path.join(taskpath, outfileprefix + '%s.txt' % (key))\n with open(outtxtfile, 'a') as f:\n f.write(\"%.6e\\n\" % (SVars[key]))\n if printFunc:\n printFunc(\"DONE with heldout inference at lap %.3f\" % queryLap)\n printFunc(\"Wrote per-doc results in MAT file:\" +\n outmatfile.split(os.path.sep)[-1])\n printFunc(\" Aggregate results in txt files: %s__.txt\"\n % (outfileprefix))\n\n # Write the summary message\n if printFunc:\n etime = time.time() - stime\n curLapStr = '%7.3f' % (queryLap)\n nLapStr = '%d' % (nLap)\n logmsg = ' %s/%s %s metrics | K %4d | %s'\n logmsg = logmsg % (curLapStr, nLapStr, '%5s' % (dataSplitName[:5]), K, scoreMsg)\n printFunc(logmsg, 'info')\n\n return SaveVars\n\n\ndef createTrainTestSplitOfVocab(\n seen_wids,\n seen_wcts,\n vocab_size,\n fracHeldout=0.2,\n ratioSeenToUnseenInHoldout=1/9.,\n MINSIZE=10,\n seed=42):\n ''' Create train/test split of the vocab words\n\n Returns\n -------\n Info : dict with fields\n * tr_seen_wids\n * tr_unsn_wids\n * ho_seen_wids\n * ho_unsn_wids\n * ratio\n\n Example\n -------\n >>> seen_wids = np.arange(100)\n >>> swc = np.ones(100)\n >>> Info = createTrainTestSplitOfVocab(seen_wids, swc, 1000, 0.2, 1.0/10.0)\n >>> print Info['ratio']\n 0.1\n >>> I213 = createTrainTestSplitOfVocab(seen_wids, 213, 0.2, 1.0/10.0)\n >>> print I213['ratio']\n 0.1\n >>> print len(I213['tr_seen_wids'])\n 80\n >>> print len(I213['ho_seen_wids'])\n 11\n >>> print len(I213['ho_unsn_wids'])\n 110\n >>> # Here's an example that fails\n >>> I111 = createTrainTestSplitOfVocab(seen_wids, 111, 0.2, 1.0/10.0)\n raises ValueError\n '''\n seen_wids = np.asarray(seen_wids, dtype=np.int32)\n # Split seen words into train and heldout\n # Enforcing the desired fraction as much as possible\n # while guaranteeing minimum size\n n_ho_seen = int(np.ceil(fracHeldout * len(seen_wids)))\n if len(seen_wids) < 2 * MINSIZE:\n raise ValueError(\n \"Cannot create training and test set with \" +\n \"at least MINSIZE=%d seen (present) words\" % (MINSIZE))\n elif n_ho_seen < MINSIZE:\n n_ho_seen = MINSIZE\n n_tr_seen = len(seen_wids) - n_ho_seen\n assert n_tr_seen >= MINSIZE\n assert n_ho_seen >= MINSIZE\n\n # Now, divide the un-seen words similarly\n n_ttl_unsn = vocab_size - len(seen_wids)\n n_ho_unsn = int(np.ceil(n_ho_seen / ratioSeenToUnseenInHoldout))\n while n_ho_unsn > n_ttl_unsn and n_ho_seen > MINSIZE:\n # Try to shrink heldout set\n n_ho_seen -= 1\n n_ho_unsn = int(np.ceil(n_ho_seen / ratioSeenToUnseenInHoldout))\n\n if n_ho_seen < MINSIZE:\n raise ValueError(\n \"Cannot create test set with \" +\n \"at least MINSIZE=%d seen/present words\" % (MINSIZE))\n if n_ho_unsn > n_ttl_unsn:\n raise ValueError(\n \"Cannot create heldout set with desired ratio of unseen words\")\n assert n_ho_unsn >= MINSIZE\n ratio = n_ho_seen / float(n_ho_unsn)\n\n # Now actually do the shuffling of vocab ids\n PRNG = np.random.RandomState(seed)\n shuffled_inds = PRNG.permutation(len(seen_wids))\n tr_seen_wids = seen_wids[shuffled_inds[:n_tr_seen]].copy()\n tr_seen_wcts = seen_wcts[shuffled_inds[:n_tr_seen]].copy()\n ho_seen_wids = seen_wids[\n shuffled_inds[n_tr_seen:n_tr_seen+n_ho_seen]].copy()\n ho_seen_wcts = seen_wcts[\n shuffled_inds[n_tr_seen:n_tr_seen+n_ho_seen]].copy()\n assert len(ho_seen_wids) == n_ho_seen\n assert len(tr_seen_wids) == n_tr_seen\n\n unsn_wids = np.setdiff1d(np.arange(vocab_size), seen_wids)\n PRNG.shuffle(unsn_wids)\n ho_unsn_wids = unsn_wids[:n_ho_unsn].copy()\n tr_unsn_wids = unsn_wids[n_ho_unsn:].copy()\n assert len(ho_unsn_wids) == n_ho_unsn\n\n Info = dict(\n ratio=ratio,\n tr_seen_wcts=tr_seen_wcts,\n ho_seen_wcts=ho_seen_wcts,\n tr_seen_wids=tr_seen_wids,\n ho_seen_wids=ho_seen_wids,\n tr_unsn_wids=tr_unsn_wids,\n ho_unsn_wids=ho_unsn_wids,)\n\n ho_all_wids = np.hstack([ho_seen_wids, ho_unsn_wids])\n tr_all_wids = np.hstack([tr_seen_wids, tr_unsn_wids])\n n_all = len(ho_all_wids) + len(tr_all_wids)\n if n_all < vocab_size:\n xtra_seen_wids = seen_wids[\n shuffled_inds[n_tr_seen+n_ho_seen:]].copy()\n xtra_seen_wcts = seen_wcts[\n shuffled_inds[n_tr_seen+n_ho_seen:]].copy()\n assert vocab_size - n_all == len(xtra_seen_wids)\n Info['xtra_seen_wids'] = xtra_seen_wids\n Info['xtra_seen_wcts'] = xtra_seen_wcts\n return Info\n\ndef calcPredLikForDoc(docData, topics, probs, alpha,\n LPkwargs=dict(),\n **kwargs):\n ''' Calculate predictive likelihood for single doc under given model.\n\n Returns\n -------\n '''\n assert docData.nDoc == 1\n Info = createTrainTestSplitOfVocab(\n docData.word_id, docData.word_count, docData.vocab_size,\n **kwargs)\n # # Run local step to get DocTopicCounts\n DocTopicCount_d, moreInfo_d = inferDocTopicCountForDoc(\n Info['tr_seen_wids'], Info['tr_seen_wcts'],\n topics, probs, alpha, **LPkwargs)\n Info.update(moreInfo_d)\n\n # # Compute point-estimate of topic probs in this doc\n theta_d = DocTopicCount_d + alpha * probs\n Epi_d = theta_d / np.sum(theta_d)\n\n # # Evaluate likelihood\n Info['DocTopicCount'] = DocTopicCount_d\n ho_wcts = Info['ho_seen_wcts'].copy()\n ho_wids = Info['ho_seen_wids'].copy()\n if 'xtra_seen_wids' in Info:\n ho_wids = np.hstack([ho_wids, Info['xtra_seen_wids']])\n ho_wcts = np.hstack([ho_wcts, Info['xtra_seen_wcts']])\n\n probPerToken_d = np.dot(topics[:, ho_wids].T, Epi_d)\n logProbPerToken_d = np.log(probPerToken_d)\n Info['sumlogProbTokens'] = np.sum(logProbPerToken_d * ho_wcts)\n Info['nHeldoutToken'] = np.sum(ho_wcts)\n\n # # Eval retrieval metrics\n ho_all_wids = np.hstack([Info['ho_seen_wids'], Info['ho_unsn_wids']])\n scoresOfHeldoutTypes_d = np.dot(topics[:, ho_all_wids].T, Epi_d)\n trueLabelsOfHeldoutTypes_d = np.zeros(ho_all_wids.size, dtype=np.int32)\n trueLabelsOfHeldoutTypes_d[:len(Info['ho_seen_wids'])] = 1\n assert np.sum(trueLabelsOfHeldoutTypes_d) == len(Info['ho_seen_wids'])\n # AUC metric\n fpr, tpr, thr = sklearn.metrics.roc_curve(\n trueLabelsOfHeldoutTypes_d, scoresOfHeldoutTypes_d)\n auc = sklearn.metrics.auc(fpr, tpr)\n # Top R precision, where R = total num positive instances\n topR = len(Info['ho_seen_wids'])\n topRHeldoutWordTypes = np.argsort(-1 * scoresOfHeldoutTypes_d)[:topR]\n R_precision = sklearn.metrics.precision_score(\n trueLabelsOfHeldoutTypes_d[topRHeldoutWordTypes],\n np.ones(topR))\n Info['auc'] = auc\n Info['R_precision'] = R_precision\n Info['scoresOfHeldoutTypes'] = scoresOfHeldoutTypes_d\n # # That's all folks\n return Info\n\n \"\"\"\n # Split document into training and heldout\n # assigning each unique vocab type to one or the other\n nSeen_d = docData.word_id.size\n nUnseen_d = docData.vocab_size - nSeen_d\n\n # Randomly assign seen words to TRAIN or HELDOUT\n nHeldout = int(np.ceil(fracHeldout * nSeen_d))\n nHeldout = np.maximum(MINSIZE, nHeldout)\n PRNG = np.random.RandomState(int(seed))\n shuffleIDs = PRNG.permutation(nSeen_d)\n heldoutIDs = shuffleIDs[:nHeldout]\n trainIDs = shuffleIDs[nHeldout:]\n if len(heldoutIDs) < MINSIZE:\n raise ValueError('Not enough unique IDs to make good test split')\n if len(trainIDs) < MINSIZE:\n raise ValueError('Not enough unique IDs to make good train split')\n\n # Randomly assign unseen words to TRAIN or HELDOUT\n unseen_mask_d = np.ones(docData.vocab_size, dtype=np.bool8)\n unseen_mask_d[docData.word_id] = 0\n unseenWordTypes = np.flatnonzero(unseen_mask_d)\n PRNG.shuffle(unseenWordTypes)\n # Pick heldout set size,\n # so that among all heldout types (seen & unseen)\n # the ratio of seen / total equals the desired fracHeldoutSeen\n nUHeldout = int(np.floor(nHeldout / fracHeldoutSeen))\n if nUHeldout > unseenWordTypes.size:\n nUHeldout = unseenWordTypes.size - nHeldout\n\n fracHeldoutPresent = nHeldout / float(unseenWordTypes.size)\n if fracHeldoutPresent < 0.5 * fracHeldoutSeen:\n warnings.warn(\n \"Frac of heldout types thare are PRESENT is %.3f\" % (\n fracHeldoutPresent))\n elif fracHeldoutPresent > 1.5 * fracHeldoutSeen:\n warnings.warn(\n \"Frac of heldout types thare are PRESENT is %.3f\" % (\n fracHeldoutPresent))\n heldoutUWords = unseenWordTypes[:nUHeldout]\n trainUWords = unseenWordTypes[nUHeldout:]\n\n ho_word_id = docData.word_id[heldoutIDs]\n ho_word_ct = docData.word_count[heldoutIDs]\n tr_word_id = docData.word_id[trainIDs]\n tr_word_ct = docData.word_count[trainIDs]\n # Run local step to get DocTopicCounts\n DocTopicCount_d, Info = inferDocTopicCountForDoc(\n tr_word_id, tr_word_ct, topics, probs, alpha, **LPkwargs)\n # # Compute expected topic probs in this doc\n theta_d = DocTopicCount_d + alpha * probs\n Epi_d = theta_d / np.sum(theta_d)\n # # Evaluate log prob per token metric\n probPerToken_d = np.dot(topics[:, ho_word_id].T, Epi_d)\n logProbPerToken_d = np.log(probPerToken_d)\n sumlogProbTokens_d = np.sum(logProbPerToken_d * ho_word_ct)\n nHeldoutToken_d = np.sum(ho_word_ct)\n\n # # Evaluate retrieval metrics\n heldoutSWords = ho_word_id\n heldoutWords = np.hstack([heldoutSWords, heldoutUWords])\n scoresOfHeldoutTypes_d = np.dot(topics[:, heldoutWords].T, Epi_d)\n trueLabelsOfHeldoutTypes_d = np.zeros(heldoutWords.size, dtype=np.int32)\n trueLabelsOfHeldoutTypes_d[:heldoutSWords.size] = 1\n assert np.sum(trueLabelsOfHeldoutTypes_d) == ho_word_id.size\n # AUC metric\n fpr, tpr, thr = sklearn.metrics.roc_curve(\n trueLabelsOfHeldoutTypes_d, scoresOfHeldoutTypes_d)\n auc = sklearn.metrics.auc(fpr, tpr)\n # Top R precision, where R = total num positive instances\n topR = ho_word_id.size\n topRHeldoutWordTypes = np.argsort(-1 * scoresOfHeldoutTypes_d)[:topR]\n R_precision = sklearn.metrics.precision_score(\n trueLabelsOfHeldoutTypes_d[topRHeldoutWordTypes],\n np.ones(topR))\n '''\n # unseen_mask_d : 1D array, size vocab_size\n # entry is 0 if word is seen in training half\n # entry is 1 if word is unseen\n unseen_mask_d = np.ones(docData.vocab_size, dtype=np.bool8)\n unseen_mask_d[tr_word_id] = 0\n probOfUnseenTypes_d = np.dot(topics[:, unseen_mask_d].T, Epi_d)\n unseen_mask_d = np.asarray(unseen_mask_d, dtype=np.int32)\n unseen_mask_d[ho_word_id] = 2\n trueLabelsOfUnseenTypes_d = unseen_mask_d[unseen_mask_d > 0]\n trueLabelsOfUnseenTypes_d -= 1\n assert np.sum(trueLabelsOfUnseenTypes_d) == ho_word_id.size\n fpr, tpr, thr = sklearn.metrics.roc_curve(\n trueLabelsOfUnseenTypes_d, probOfUnseenTypes_d)\n auc = sklearn.metrics.auc(fpr, tpr)\n # top R precision, where R = total num positive instances\n topR = ho_word_id.size\n topRUnseenTypeIDs = np.argsort(-1 * probOfUnseenTypes_d)[:topR]\n R_precision = sklearn.metrics.precision_score(\n trueLabelsOfUnseenTypes_d[topRUnseenTypeIDs],\n np.ones(topR))\n # Useful debugging\n # >>> unseenTypeIDs = np.flatnonzero(unseen_mask_d)\n # >>> trainIm = np.zeros(900); trainIm[tr_word_id] = 1.0\n # >>> testIm = np.zeros(900); testIm[ho_word_id] = 1.0\n # >>> predictIm = np.zeros(900);\n # >>> predictIm[unseenTypeIDs[topRUnseenTypeIDs]] = 1;\n # >>> bnpy.viz.BarsViz.showTopicsAsSquareImages( np.vstack([trainIm, testIm, predictIm]) )\n '''\n Info['auc'] = auc\n Info['R_precision'] = R_precision\n Info['ho_word_ct'] = ho_word_ct\n Info['tr_word_ct'] = tr_word_ct\n Info['DocTopicCount'] = DocTopicCount_d\n Info['nHeldoutToken'] = nHeldoutToken_d\n Info['sumlogProbTokens'] = sumlogProbTokens_d\n return Info\n \"\"\"\n\n\ndef calcPredLikForDocFromHModel(\n docData, hmodel,\n fracHeldout=0.2,\n seed=42,\n MINSIZE=10,\n LPkwargs=dict(),\n alpha=None,\n **kwargs):\n ''' Calculate predictive likelihood for single doc under given model.\n\n Returns\n -------\n '''\n Info = dict()\n assert docData.nDoc == 1\n\n # Split document into training and heldout\n # assigning each unique vocab type to one or the other\n if hasattr(docData, 'word_id'):\n N = docData.word_id.size\n else:\n N = docData.nObs\n nHeldout = int(np.ceil(fracHeldout * N))\n nHeldout = np.maximum(MINSIZE, nHeldout)\n PRNG = np.random.RandomState(int(seed))\n shuffleIDs = PRNG.permutation(N)\n heldoutIDs = shuffleIDs[:nHeldout]\n trainIDs = shuffleIDs[nHeldout:]\n if len(heldoutIDs) < MINSIZE:\n raise ValueError('Not enough unique IDs to make good test split')\n if len(trainIDs) < MINSIZE:\n raise ValueError('Not enough unique IDs to make good train split')\n\n hoData = docData.select_subset_by_mask(atomMask=heldoutIDs)\n trData = docData.select_subset_by_mask(atomMask=trainIDs)\n\n Epi_global = hmodel.allocModel.get_active_comp_probs()\n LP = hmodel.obsModel.calc_local_params(hoData)\n hoLik_d = LP['E_log_soft_ev']\n hoLik_d += np.log(Epi_global)[np.newaxis,:]\n logProbPerToken_d = logsumexp(hoLik_d, axis=1)\n Info['sumlogProbTokens'] = np.sum(logProbPerToken_d)\n Info['nHeldoutToken'] = len(heldoutIDs) * hoData.dim\n return Info\n '''\n # Run local step to get DocTopicCounts\n DocTopicCount_d, Info = inferDocTopicCountForDocFromHModel(\n trData, hmodel, **LPkwargs)\n probs = hmodel.allocModel.get_active_comp_probs()\n # Compute expected topic probs in this doc\n theta_d = DocTopicCount_d + alpha * probs\n E_log_pi_d = digamma(theta_d) - digamma(np.sum(theta_d))\n # Evaluate log prob per token metric\n LP = hmodel.obsModel.calc_local_params(hoData)\n logProbArr_d = LP['E_log_soft_ev']\n logProbArr_d += E_log_pi_d[np.newaxis, :]\n logProbPerToken_d = logsumexp(logProbArr_d, axis=1)\n # Pack up and ship\n Info['DocTopicCount'] = DocTopicCount_d\n Info['nHeldoutToken'] = len(heldoutIDs)\n Info['sumlogProbTokens'] = np.sum(logProbPerToken_d)\n return Info\n '''\n\ndef inferDocTopicCountForDoc(\n word_id, word_ct, topics, probs, alpha,\n **LPkwargs):\n K = probs.size\n K2, W = topics.shape\n assert K == K2\n # topics : 2D array, vocab_size x K\n # Each col is non-negative and sums to one.\n topics = topics.T.copy()\n assert np.allclose(np.sum(topics, axis=0), 1.0)\n # Lik_d : 2D array, size N x K\n # Each row is non-negative\n Lik_d = np.asarray(topics[word_id, :].copy(), dtype=np.float64)\n # alphaEbeta : 1D array, size K\n alphaEbeta = np.asarray(alpha * probs, dtype=np.float64)\n DocTopicCount_d, _, _, Info = calcLocalParams_SingleDoc(\n word_ct, Lik_d, alphaEbeta,\n alphaEbetaRem=None,\n **LPkwargs)\n assert np.allclose(DocTopicCount_d.sum(), word_ct.sum())\n return DocTopicCount_d, Info\n\ndef inferDocTopicCountForDocFromHModel(\n docData, hmodel, alpha=0.5, **LPkwargs):\n # Lik_d : 2D array, size N x K\n # Each row is non-negative\n LP = hmodel.obsModel.calc_local_params(docData)\n Lik_d = LP['E_log_soft_ev']\n Lik_d -= Lik_d.max(axis=1)[:,np.newaxis]\n np.exp(Lik_d, out=Lik_d)\n\n # alphaEbeta : 1D array, size K\n alphaEbeta = alpha * hmodel.allocModel.get_active_comp_probs()\n DocTopicCount_d, _, _, Info = calcLocalParams_SingleDoc(\n 1.0, Lik_d, alphaEbeta,\n alphaEbetaRem=None,\n **LPkwargs)\n assert np.allclose(DocTopicCount_d.sum(), Lik_d.shape[0])\n return DocTopicCount_d, Info\n\nif __name__ == '__main__':\n parser = argparse.ArgumentParser()\n parser.add_argument('taskpath', type=str)\n parser.add_argument('--queryLap', type=float, default=None)\n parser.add_argument('--seed', type=int, default=42)\n parser.add_argument('--printStdOut', type=int, default=1)\n parser.add_argument('--printLevel', type=int, default=logging.INFO)\n parser.add_argument('--elapsedTime', type=float, default=None)\n parser.add_argument('--dataSplitName', type=str, default=\"test\")\n #parser.add_argument('--restartLP', type=int, default=None)\n #parser.add_argument('--fracHeldout', type=float, default=0.2)\n args = parser.parse_args()\n\n if args.printStdOut:\n def printFunc(x, level='debug', **kwargs):\n if level == 'debug':\n level = logging.DEBUG\n elif level == 'info':\n level = logging.INFO\n if level >= args.printLevel:\n print(x)\n args.__dict__['printFunc'] = printFunc\n evalTopicModelOnTestDataFromTaskpath(**args.__dict__)\n",
"'''\nToyMMSBK6.py\n'''\n\nimport numpy as np\nfrom bnpy.data import GraphXData\n\nK = 6\n\n\ndef get_data(\n seed=123, nNodes=100, alpha=0.05,\n w_diag=.95,\n w_offdiag_eps=.01,\n **kwargs):\n ''' Create toy dataset as bnpy GraphXData object.\n\n Uses a simple mixed membership generative model.\n Assumes high within-block edge probability, small epsilon otherwise.\n\n Args\n -------\n seed : int\n seed for random number generator\n nNodes : int\n number of nodes in the generated network\n\n Returns\n -------\n Data : bnpy GraphXData object\n '''\n nNodes = int(nNodes)\n prng = np.random.RandomState(seed)\n\n # Create membership probabilities at each node\n if not hasattr(alpha, '__len__'):\n alpha = alpha * np.ones(K)\n pi = prng.dirichlet(alpha, size=nNodes)\n\n # Create block relation matrix W, shape K x K\n w = w_offdiag_eps * np.ones((K, K))\n w[np.diag_indices(6)] = w_diag\n\n # Generate community assignments, s, r, and pack into TrueZ\n s = np.zeros((nNodes, nNodes), dtype=int)\n r = np.zeros((nNodes, nNodes), dtype=int)\n for i in range(nNodes):\n s[i, :] = prng.choice(range(K), p=pi[i, :], size=nNodes)\n r[:, i] = prng.choice(range(K), p=pi[i, :], size=nNodes)\n TrueZ = np.zeros((nNodes, nNodes, 2), dtype=int)\n TrueZ[:, :, 0] = s\n TrueZ[:, :, 1] = r\n\n TrueParams = dict(Z=TrueZ, w=w, pi=pi)\n\n # Generate adjacency matrix\n AdjMat = np.zeros((nNodes, nNodes))\n for i in range(nNodes):\n for j in range(nNodes):\n if i == j:\n continue\n AdjMat[i,j] = prng.binomial(n=1, p=w[s[i, j], r[i, j]])\n\n Data = GraphXData(AdjMat=AdjMat,\n nNodesTotal=nNodes, nNodes=nNodes,\n TrueParams=TrueParams, isSparse=True)\n Data.name = get_short_name()\n return Data\n\n\ndef get_short_name():\n return 'ToyMMSBK6'\n\n\nif __name__ == '__main__':\n import matplotlib.pyplot as plt\n\n Data = get_data(nNodes=100, alpha=0.5)\n w = Data.TrueParams['w']\n\n # # Draw graph with nodes colored by their mixed community membership\n # from bnpy.viz import RelationalViz\n # RelationalViz.plotTrueLabels(\n # 'ToyMMSBK6', Data,\n # gtypes=['Actual'],\n # mixColors=True, thresh=.65, colorEdges=False, title='ToyMMSBK6 Graph')\n\n # Plot adj matrix\n f, ax = plt.subplots(1)\n Xdisp = np.squeeze(Data.toAdjacencyMatrix())\n sortids = np.argsort(Data.TrueParams['pi'].argmax(axis=1))\n Xdisp = Xdisp[sortids, :]\n Xdisp = Xdisp[:, sortids]\n ax.imshow(\n Xdisp, cmap='Greys', interpolation='nearest',\n vmin=0, vmax=1)\n ax.set_title('Adjacency matrix')\n ax.set_yticks(np.arange(0, Data.nNodes+1, 10))\n ax.set_xticks(np.arange(0, Data.nNodes+1, 10))\n\n\n # Plot subset of pi\n Epi = Data.TrueParams['pi']\n fix, ax = plt.subplots(1)\n ax.imshow(\n Epi[0:30, :],\n cmap='Greys', interpolation='nearest',\n vmin=0, vmax=1.0)\n ax.set_ylabel('nodes')\n ax.set_yticks(np.arange(0, 31, 5))\n ax.set_xlabel('states')\n ax.set_xticks(np.arange(K))\n ax.set_title('Membership vectors pi (first 30 rows)')\n\n # Plot w\n fig, ax = plt.subplots(1)\n im = ax.imshow(\n w, cmap='Greys', interpolation='nearest',\n vmin=0, vmax=1.0)\n ax.set_xlabel('states')\n ax.set_xticks(np.arange(K))\n ax.set_ylabel('states')\n ax.set_yticks(np.arange(K))\n ax.set_title('Edge probability matrix w')\n\n plt.show()\n",
"import numpy as np\nimport math\n\ndef Random_Projection(M, new_dim, prng):\n ''' Project *columns* of input matrix M into lower-dimension new_dim\n\n Args\n --------\n M : 2D array, old_dim x nFeatures\n\n Returns\n --------\n M_red : 2D array, new_dim x nFeatures\n\n Internals\n --------\n Creates R : 2D array, new_dim x old_dim\n projection matrix\n each column is a random vector of size new_dim,\n with entries in {-sqrt(3), 0, sqrt(3)}\n with associated probabilities 1/6, 2/3, 1/6\n '''\n old_dim = M[:, 0].size\n p = np.array([1./6, 2./3, 1./6])\n c = np.cumsum(p)\n randdoubles = prng.random_sample(new_dim*old_dim)\n R = np.searchsorted(c, randdoubles)\n R = math.sqrt(3)*(R - 1)\n R = np.reshape(R, (new_dim, old_dim))\n \n M_red = np.dot(R, M)\n return M_red\n"
] | [
[
"numpy.random.RandomState"
],
[
"numpy.asarray",
"numpy.all",
"numpy.zeros",
"numpy.allclose"
],
[
"numpy.all",
"numpy.isnan",
"numpy.allclose",
"numpy.ones"
],
[
"matplotlib.pylab.show",
"numpy.asarray",
"matplotlib.pylab.title",
"matplotlib.pylab.imshow",
"matplotlib.pylab.ylabel",
"matplotlib.pylab.gca",
"numpy.argsort",
"numpy.vstack"
],
[
"numpy.diag",
"numpy.dot",
"numpy.sqrt",
"numpy.asarray",
"numpy.square",
"scipy.special.digamma",
"numpy.linalg.det",
"numpy.outer",
"numpy.zeros",
"numpy.log",
"numpy.multiply",
"numpy.linalg.inv",
"scipy.special.gammaln",
"numpy.sum",
"numpy.linalg.solve",
"numpy.maximum",
"numpy.inner",
"numpy.tile",
"numpy.ones"
],
[
"numpy.hstack",
"numpy.dot",
"numpy.log",
"numpy.maximum",
"numpy.allclose",
"numpy.asarray",
"numpy.arange",
"numpy.median",
"numpy.percentile",
"numpy.ones",
"numpy.ceil",
"numpy.mean",
"numpy.exp",
"numpy.argsort",
"numpy.random.RandomState",
"numpy.zeros",
"numpy.sum",
"scipy.misc.logsumexp"
],
[
"numpy.arange",
"matplotlib.pyplot.subplots",
"numpy.ones",
"numpy.diag_indices",
"numpy.random.RandomState",
"numpy.zeros",
"matplotlib.pyplot.show"
],
[
"numpy.dot",
"numpy.reshape",
"numpy.cumsum",
"numpy.searchsorted",
"numpy.array"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [
"0.18",
"0.19"
],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [
"0.13",
"0.14",
"0.15",
"0.19",
"0.18",
"1.2",
"0.12",
"1.0",
"0.17",
"0.16"
],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
BBN-E/nlplingo | [
"32ff17b1320937faa3d3ebe727032f4b3e7a353d",
"32ff17b1320937faa3d3ebe727032f4b3e7a353d",
"32ff17b1320937faa3d3ebe727032f4b3e7a353d"
] | [
"nlplingo/nn/extractor.py",
"nlplingo/nn/keras_models/model/base_model.py",
"nlplingo/nn/pytorch_models/model/softmax_nn.py"
] | [
"import codecs\nimport json\nimport os\n\nimport numpy as np\nfrom nlplingo.nn.sequence_model import SequenceXLMRBase, SequenceXLMRCustom\nfrom nlplingo.nn.spanpair_model import SpanPairModelEmbedded\nfrom nlplingo.tasks.entitycoref.feature import EntityCorefFeatureGenerator\nfrom nlplingo.tasks.entitycoref.generator import EntityCorefExampleGenerator\nfrom nlplingo.tasks.eventcoref.feature import EventCorefFeatureGenerator\nfrom nlplingo.tasks.eventcoref.generator import EventCorefExampleGenerator\nfrom nlplingo.tasks.eventpair.feature import EventPairFeatureGenerator\nfrom nlplingo.tasks.eventpair.generator import EventPairExampleGenerator\nfrom nlplingo.tasks.eventframe.feature import EventFramePairFeatureGenerator\nfrom nlplingo.tasks.eventframe.generator import EventFramePairExampleGenerator\n\nfrom keras.models import load_model as keras_load_model\nfrom keras.models import Model as KerasModel\n\nfrom nlplingo.tasks.eventargument.feature import EventArgumentFeatureGenerator\nfrom nlplingo.tasks.eventargument.generator import EventArgumentExampleGenerator\nfrom nlplingo.tasks.eventrelation.feature import EventEventRelationFeatureGenerator\nfrom nlplingo.tasks.eventrelation.generator import EventEventRelationExampleGenerator\nfrom nlplingo.tasks.entityrelation.feature import EntityRelationFeatureGenerator\nfrom nlplingo.tasks.entityrelation.generator import EntityRelationExampleGenerator\n\nfrom nlplingo.tasks.event_domain import EventDomain\nfrom nlplingo.tasks.eventtrigger.feature import EventTriggerFeatureGenerator\nfrom nlplingo.tasks.eventtrigger.generator import EventTriggerExampleGenerator\n\nfrom nlplingo.nn.argument_model import CNNArgumentModel\nfrom nlplingo.nn.argument_model import GNNArgumentModel\nfrom nlplingo.nn.argument_model import MultiLayerArgumentModelEmbedded, WithinSentenceArgumentModel\nfrom nlplingo.nn.extraction_model import ExtractionModel\nfrom nlplingo.nn.keras_models.common import keras_custom_objects\nfrom nlplingo.nn.trigger_model import CNNTriggerModel\nfrom nlplingo.nn.trigger_model import MultiLayerTriggerModelEmbedded\nfrom nlplingo.nn.eventpair_model import EventPairModelEmbeddedTrigger\nfrom nlplingo.nn.event_event_relation_model import MultiLayerEventEventRelationModel, WithinSentenceEER, EventEventRelationStackedOpenNREModel, WithinSentenceEERGeneral\nfrom nlplingo.nn.entity_entity_relation_model import MultiLayerEntityRelationModelEmbedded, WithinSentenceEntityRelationModel\nfrom nlplingo.nn.eventframepair_model import EventFramePairModelEmbedded\n\nfrom nlplingo.nn.hyperparameters import HyperParameters\nfrom nlplingo.tasks.common.feature.feature_setting import FeatureSetting\n\nimport logging\n\nfrom nlplingo.tasks.sequence.feature import SequenceFeatureGenerator\nfrom nlplingo.tasks.sequence.generator import SequenceExampleGenerator\n\nlogger = logging.getLogger(__name__)\n\n\nclass Extractor(object):\n trigger_model_table = {\n 'event-trigger_cnn': CNNTriggerModel,\n 'event-trigger_cnn-embedded': CNNTriggerModel,\n 'event-trigger_multilayer-embedded': MultiLayerTriggerModelEmbedded,\n 'event-trigger_sentence-embedded': MultiLayerTriggerModelEmbedded,\n }\n\n argument_model_table = {\n 'event-argument_cnn': CNNArgumentModel,\n 'event-argument_cnn-embedded': CNNArgumentModel,\n 'event-argument_gnn': GNNArgumentModel,\n 'event-argument_multilayer-embedded': MultiLayerArgumentModelEmbedded,\n 'event-argument_bert-mention': WithinSentenceArgumentModel\n }\n\n eer_model_table = {\n 'event-event-relation_multilayer': MultiLayerEventEventRelationModel,\n 'event-event-relation_multilayer-embedded': MultiLayerEventEventRelationModel,\n 'event-event-relation_two_models_with_postprocessing': EventEventRelationStackedOpenNREModel,\n 'event-event-relation_cnn-embedded': WithinSentenceEER, # This exists for legacy reasons\n 'event-event-relation_within-sentence': WithinSentenceEER,\n 'event-event-relation_general_decode-embedded': WithinSentenceEERGeneral\n }\n\n entity_relation_model_table = {\n 'entity-entity-relation_multilayer-embedded': MultiLayerEntityRelationModelEmbedded,\n 'entity-entity-relation_bert-mention': WithinSentenceEntityRelationModel\n }\n\n eventpair_model_table = {\n 'event-pair_embedded': SpanPairModelEmbedded,\n 'event-pair_embedded_trigger': EventPairModelEmbeddedTrigger\n }\n\n eventframepair_model_table = {\n 'event-framepair_embedded': EventFramePairModelEmbedded\n }\n\n entitycoref_model_table = {\n 'entitycoref_embedded': SpanPairModelEmbedded\n }\n\n eventcoref_model_table = {\n 'eventcoref_embedded': SpanPairModelEmbedded\n }\n\n sequence_model_table = {\n 'sequence_xlmr-base': SequenceXLMRBase,\n 'sequence_xlmr-custom': SequenceXLMRCustom\n }\n\n\n def __init__(self, params, extractor_params, embeddings, load_from_file=False):\n \"\"\"\n :type params: dict # general parameters\n :type extractor_params: dict # specific to this extractor\n :type embeddings: dict[str : nlplingo.embeddings.word_embeddings.WordEmbedding]\n \"\"\"\n\n self.extractor_params = extractor_params\n self.extractor_name = extractor_params.get('extractor_name', None)\n\n self.task = extractor_params.get('task', None)\n self.engine = extractor_params.get('engine', None)\n\n self.model_type = extractor_params['model_type']\n \"\"\":type: str\"\"\"\n\n self.domain = EventDomain.read_domain_ontology_file(extractor_params['domain_ontology'],\n domain_name=extractor_params.get('domain_name', 'general'))\n \"\"\":type: nlplingo.tasks.event_domain.EventDomain\"\"\"\n self.domain.build_prior(extractor_params.get('ontology_yaml'))\n\n self.model_file = extractor_params['model_file']\n \"\"\":type: str\"\"\"\n\n self.class_thresholds_path = extractor_params.get('class_thresholds')\n \"\"\":type: str\"\"\"\n\n self.class_thresholds_global = float(\n extractor_params.get('class_thresholds_global', -1.0))\n \"\"\":type: float\"\"\"\n\n self.use_trigger_safelist = extractor_params.get('trigger.use_safelist', False)\n\n if 'engine' not in extractor_params or (('engine' in extractor_params) and (extractor_params['engine'] == 'keras')):\n self.hyper_parameters = HyperParameters(extractor_params['hyper-parameters'], load_from_file)\n elif extractor_params['engine'] == 'pytorch':\n self.hyper_parameters = HyperParameters(extractor_params['hyper-parameters'], load_from_file)\n # elif extractor_params['engine'] == 'transformers':\n # pass\n else:\n raise RuntimeError('Extractor model type: {} not implemented.'.format(self.model_type))\n\n \"\"\":type: nlplingo.nn.extractor.HyperParameters\"\"\"\n\n self.feature_setting = FeatureSetting(self.extractor_params['features'])\n\n self.extraction_model = None\n if self.model_type in self.trigger_model_table:\n self.extraction_model = self.trigger_model_table[self.model_type](params, extractor_params, self.domain, embeddings,\n self.hyper_parameters,\n self.feature_setting)\n elif self.model_type in self.argument_model_table:\n self.extraction_model = self.argument_model_table[self.model_type](params, extractor_params, self.domain,\n embeddings, self.hyper_parameters,\n self.feature_setting)\n elif self.model_type in self.eventpair_model_table:\n self.extraction_model = self.eventpair_model_table[self.model_type](params, extractor_params, self.domain, embeddings,\n self.hyper_parameters,\n self.feature_setting) # TODO: fix this model\n elif self.model_type in self.eer_model_table:\n self.extraction_model = self.eer_model_table[self.model_type](params, extractor_params, self.domain, embeddings,\n self.hyper_parameters,\n self.feature_setting)\n elif self.model_type in self.entity_relation_model_table:\n self.extraction_model = self.entity_relation_model_table[self.model_type](params, extractor_params, self.domain, embeddings,\n self.hyper_parameters,\n self.feature_setting)\n elif self.model_type in self.eventframepair_model_table:\n self.extraction_model = self.eventframepair_model_table[self.model_type](params, extractor_params, self.domain, embeddings,\n self.hyper_parameters,\n self.feature_setting) # TODO: fix this model\n elif self.model_type in self.entitycoref_model_table:\n self.extraction_model = self.entitycoref_model_table[self.model_type](params, extractor_params, self.domain, embeddings,\n self.hyper_parameters,\n self.feature_setting)\n elif self.model_type in self.eventcoref_model_table:\n self.extraction_model = self.eventcoref_model_table[self.model_type](params, extractor_params, self.domain, embeddings,\n self.hyper_parameters,\n self.feature_setting)\n elif self.model_type in self.sequence_model_table:\n if self.task == 'event-trigger':\n self.domain.create_sequence_types(self.domain.event_types)\n elif self.task == 'event-argument':\n self.domain.create_sequence_types(self.domain.event_roles)\n elif self.task == 'ner':\n self.domain.create_sequence_types(self.domain.entity_types)\n\n self.extraction_model = self.sequence_model_table[self.model_type](params, extractor_params, self.domain, embeddings,\n self.hyper_parameters, self.feature_setting)\n elif self.model_type.startswith('oregon'): # TODO hack, until YS has time to properly integrate after BETTER eval\n pass\n else:\n raise RuntimeError('Extractor model type: {} not implemented.'.format(self.model_type))\n\n \"\"\":type: nlplingo.nn.event_model.ExtractionModel\"\"\"\n # TODO: extend this to support EventEventRelation models\n if load_from_file:\n logging.info('Loading previously trained model')\n\n if extractor_params.get('engine', None) == 'keras':\n self.load_keras()\n if extractor_params.get('engine', None) is None: # TODO use framework\n self.load_keras()\n elif extractor_params['engine'] == 'pytorch':\n pass\n # elif extractor_params['engine'] == 'transformers':\n # pass\n else:\n raise Exception(\n 'Only Keras or PyTorch engines are supported.')\n\n #if ('engine' in extractor_params) and (extractor_params['engine'] == 'pytorch'):\n # if load_from_file or self.extraction_model.hyper_params.load:\n # pass\n \"\"\"\n self.extraction_model.hyper_params.num_class = self.extraction_model.num_output\n if self.extraction_model.word_embeddings is not None:\n trainer = self.extraction_model.model(self.extraction_model.extractor_params, self.extraction_model.hyper_params.dict, self.extraction_model.optimizer,\n feature_names=self.extraction_model.features.feature_strings, emb_matrix=self.extraction_model.word_embeddings)\n else: # frozen, external embedding case\n if self.extraction_model.embeddings_vector_size is not None:\n self.extraction_model.hyper_params.dict['emb_dim'] = self.extraction_model.embeddings_vector_size\n trainer = self.extraction_model.model(self.extraction_model.extractor_params, self.extraction_model.hyper_params.dict, self.extraction_model.optimizer,\n feature_names=self.extraction_model.features.feature_strings)\n\n if self.model_file:\n trainer.load(self.model_file)\n self.extraction_model.trained_model = trainer\n \"\"\"\n\n self.feature_generator = None # feature generator\n self.example_generator = None # example generator\n\n # TODO this should really be renamed as task instead of model_type\n if self.model_type.startswith('event-trigger_'):\n self.feature_generator = EventTriggerFeatureGenerator(extractor_params, self.hyper_parameters, self.feature_setting, self.domain)\n self.example_generator = EventTriggerExampleGenerator(self.domain, params, extractor_params,\n self.hyper_parameters)\n elif self.model_type.startswith('event-argument_'):\n self.feature_generator = EventArgumentFeatureGenerator(extractor_params, self.hyper_parameters, self.feature_setting)\n self.example_generator = EventArgumentExampleGenerator(self.domain, params, extractor_params,\n self.hyper_parameters)\n elif self.model_type.startswith('event-pair_'):\n self.feature_generator = EventPairFeatureGenerator(extractor_params)\n self.example_generator = EventPairExampleGenerator(self.domain, params, extractor_params,\n self.hyper_parameters)\n elif self.model_type.startswith('event-event-relation_'):\n self.feature_generator = EventEventRelationFeatureGenerator(extractor_params, self.hyper_parameters, self.feature_setting)\n self.example_generator = EventEventRelationExampleGenerator(self.domain, params, extractor_params,\n self.hyper_parameters)\n elif self.model_type.startswith('entity-entity-relation_'):\n self.feature_generator = EntityRelationFeatureGenerator(extractor_params, self.hyper_parameters, self.feature_setting)\n self.example_generator = EntityRelationExampleGenerator(self.domain, params, extractor_params,\n self.hyper_parameters)\n elif self.model_type.startswith('event-framepair_'):\n self.feature_generator = EventFramePairFeatureGenerator(extractor_params)\n self.example_generator = EventFramePairExampleGenerator(self.domain, params, extractor_params,\n self.hyper_parameters)\n elif self.model_type.startswith('entitycoref_'):\n self.feature_generator = EntityCorefFeatureGenerator(extractor_params, self.hyper_parameters, self.feature_setting)\n self.example_generator = EntityCorefExampleGenerator(self.domain, params, extractor_params,\n self.hyper_parameters)\n elif self.model_type.startswith('eventcoref_'):\n self.feature_generator = EventCorefFeatureGenerator(extractor_params, self.hyper_parameters, self.feature_setting)\n self.example_generator = EventCorefExampleGenerator(self.domain, params, extractor_params,\n self.hyper_parameters)\n elif self.model_type.startswith('oregon'): # TODO hack, until YS has time to properly integrate after BETTER eval\n pass\n elif self.model_type.startswith('sequence_'):\n self.feature_generator = SequenceFeatureGenerator(extractor_params, self.hyper_parameters, self.feature_setting, self.extraction_model.tokenizer, self.domain)\n self.example_generator = SequenceExampleGenerator(self.domain, params, extractor_params,\n self.hyper_parameters)\n else:\n raise RuntimeError('Extractor model type: {} not implemented.'.format(self.model_type))\n\n self.extraction_model_last_layer = None\n \"\"\":type: keras.models.Model\"\"\"\n self.emit_vectors = extractor_params.get('output_vectors', False)\n\n self.class_thresholds = None\n # load saved thresholds from file\n self._build_threshold_vector()\n\n # use a global threshold value if they were not loaded\n if self.class_thresholds is None:\n logging.info('Using global threshold override for {}'.format(\n self.extractor_name))\n\n # use defaults, if no global override given in extractor parameters\n if self.class_thresholds_global < 0.0:\n logging.info('Using default thresholds for {}'.format(\n self.extractor_name))\n self.class_thresholds_global = 0.5\n number_of_classes = len(self.domain.event_types.keys())\n\n logging.info('- global threshold ={}'.format(self.class_thresholds_global))\n self.class_thresholds = np.asarray(\n [self.class_thresholds_global] * number_of_classes)\n\n def _build_threshold_vector(self):\n path = self.class_thresholds_path\n if path is not None and os.path.isfile(str(path)):\n if path.endswith('.npz'):\n self.class_thresholds = np.load(str(path))['thresholds']\n print('Loaded saved thresholds from NPZ for {}'.format(\n self.extractor_name))\n elif path.endswith('.json'):\n number_of_classes = len(self.domain.event_types.keys())\n self.class_thresholds = np.asarray([0.5] * number_of_classes)\n with codecs.open(path, 'r', encoding='utf8') as fh:\n thresholds_json = json.load(fh)\n for label, threshold in thresholds_json.items():\n try:\n index = self.domain.get_event_type_index(label)\n self.class_thresholds[index] = float(threshold)\n except ValueError as e:\n print('The following error occurred while loading '\n 'thresholds from json and will be ignored:\\n'\n '{}'.format(e))\n print('Loaded saved thresholds from JSON for {}'.format(\n self.extractor_name))\n\n def make_last_layer_model(self):\n\n if self.extraction_model_last_layer is not None:\n print(\"Last layer of model has already been built\")\n return\n\n keras_model = self.extraction_model\n if type(keras_model) is not KerasModel:\n keras_model = keras_model.model\n \"\"\":type: keras.models.Model\"\"\"\n print(\"Original model:\")\n try:\n print(keras_model.summary())\n except TypeError:\n print(\"Keras encountered an error when trying to print the model \"\n \"summary. Skipping this printout...\")\n\n self.extraction_model_last_layer = KerasModel(\n inputs=keras_model.input,\n outputs=keras_model.layers[-2].output)\n\n print(\"Copy model:\")\n try:\n print(self.extraction_model_last_layer.summary())\n except TypeError:\n print(\"Keras encountered an error when trying to print the copy's \"\n \"summary. Skipping this printout...\")\n\n def get_embeddings(self, examples, data_list):\n ret = []\n self.make_last_layer_model()\n vectors = self.extraction_model_last_layer.predict(data_list)\n for i, ex in enumerate(examples):\n output_vector = vectors[i, :]\n ret.append(output_vector)\n return ret\n\n def load_keras(self):\n try:\n trained_keras_model = keras_load_model(self.model_file)\n except ValueError:\n custom_objects = keras_custom_objects\n trained_keras_model = keras_load_model(self.model_file, custom_objects)\n\n weights = trained_keras_model.get_weights()\n new_weights = []\n for i, w in enumerate(weights):\n pretrained = self.extraction_model.layers.pretrained_embeddings\n using_pretrained = pretrained is not None\n if using_pretrained and i > 1 and w.shape[0] == pretrained.shape[0]:\n # TODO retrain models to avoid this hack\n pass\n else:\n new_weights.append(w)\n weights = new_weights\n # for i, w in enumerate(weights):\n # print(i, w.shape\n\n\n self.extraction_model.model.set_weights(weights)\n\n",
"\nimport abc\nimport logging\n\nfrom keras.callbacks import EarlyStopping\nfrom keras.models import Model\nimport numpy as np\n\nfrom nlplingo.nn.extraction_model import ExtractionModel\nfrom nlplingo.nn.keras_models.common.layer_creator import LayerCreator\n\n\nlogger = logging.getLogger(__name__)\n\n\nclass KerasExtractionModel(ExtractionModel):\n\n def __init__(self, params, extractor_params, event_domain, embeddings, hyper_params, features):\n \"\"\"\n :type event_domain: nlplingo.event.event_domain.EventDomain\n :type embeddings: nlplingo.embeddings.word_embeddings.WordEmbedding\n :type hyper_params: nlplingo.nn.extractor.HyperParameters\n :type features: nlplingo.event.eventargument.feature.EventArgumentFeature\n \"\"\"\n super(KerasExtractionModel, self).__init__(\n params, extractor_params, event_domain, embeddings, hyper_params,\n features)\n self.is_binary = None\n\n @property\n @abc.abstractmethod\n def none_label_index(self):\n \"\"\"Must be defined as property in child classes; cannot be set\"\"\"\n raise NotImplementedError\n\n def create_model(self):\n\n assert self.num_output is not None\n\n self.layers = LayerCreator(\n self.features.activated_features,\n self.extractor_params,\n self.hyper_params,\n self.event_domain,\n self.num_output,\n self.word_embeddings,\n )\n\n self.is_binary = self.layers.is_binary\n\n def compile(self, model_outputs, model_input_dict, metrics=None):\n\n if metrics is None:\n metrics = []\n\n model_inputs = [model_input_dict[k] for k in self.features.activated_features]\n\n self.model = Model(inputs=model_inputs, outputs=model_outputs)\n # historically self.loss = 'categorical_crossentropy' or masked_bce\n self.model.compile(optimizer=self.optimizer,\n loss=self.layers.loss,\n metrics=metrics)\n\n def fit_model(self, train_data_list, train_label, test_data_list, test_label):\n \"\"\"\n Overrides\n :param train_data_list:\n :param train_label:\n :param test_data_list:\n :param test_label:\n :return:\n \"\"\"\n\n if self.is_binary:\n class_weights = self.prepare_class_weight(train_label)\n sample_weight = None\n else:\n sample_weight = self.prepare_sample_weight(train_label)\n class_weights = None\n\n logger.debug('- train_data_list={}'.format(train_data_list))\n logger.debug('- train_label={}'.format(train_label))\n\n callbacks = None\n if self.hyper_params.early_stopping:\n callbacks = [EarlyStopping(monitor='val_loss', patience=2)]\n\n if len(test_data_list) > 0:\n val_data = (test_data_list, test_label)\n else:\n val_data = None\n\n history = self.model.fit(\n train_data_list,\n train_label,\n sample_weight=sample_weight,\n class_weight=class_weights,\n batch_size=self.hyper_params.batch_size,\n epochs=self.hyper_params.epoch,\n validation_data=val_data,\n callbacks=callbacks\n )\n\n return history\n\n def prepare_sample_weight(self, train_label):\n sample_weight = np.ones(train_label.shape[0])\n if train_label.ndim == 1: # some tasks have 1d (binary) labels\n # [ 1, 1, 0, 1, 0 ]\n train_label_argmax = train_label\n else: # most tasks have 2d (multilabel) labels\n # [ [ 1, 0 ], [ 1, 0 ], [ 0, 1 ], [ 1, 0 ], [ 0, 1 ] ]\n train_label_argmax = np.argmax(train_label, axis=1)\n for i, label_index in enumerate(train_label_argmax):\n if label_index != self.none_label_index:\n sample_weight[i] = self.hyper_params.positive_weight\n return sample_weight\n\n def prepare_class_weight(self, train_label):\n # CLASS WEIGHT CODE\n if len(train_label.shape) > 1:\n count_per_label = np.sum(train_label, axis=0)\n # count_all_labels = float(np.sum(count_per_label))\n # total_over_count = count_all_labels / count_per_label\n else: # binary 1d label\n positives = np.sum(train_label)\n negatives = len(train_label) - positives\n count_per_label = np.asarray([negatives, positives])\n\n # CODE FOR INVERSE LOG FREQUENCY CLASS WEIGHTS\n inverse_log_freqs = 1 / np.log(count_per_label)\n class_weights = {i: weight for i, weight in enumerate(inverse_log_freqs)}\n\n logger.debug(\"CLASS WEIGHTS:\")\n logger.debug(\"{}\".format(sorted(class_weights.items(), key=lambda x: x[0])))\n logger.debug(\"CLASS FREQUENCIES:\")\n logger.debug(\" \".join([\"{}: {}\".format(i, x) for i, x in enumerate(count_per_label)]))\n\n return class_weights\n",
"import torch\nfrom torch import nn, optim\nfrom .base_model import SentenceRE\n\n\nclass SoftmaxNN(SentenceRE):\n \"\"\"\n Softmax classifier for sentence-level relation extraction.\n \"\"\"\n\n def __init__(self, sentence_encoder, num_class, rel2id):\n \"\"\"\n Args:\n sentence_encoder: encoder for sentences\n num_class: number of classes\n id2rel: dictionary of id -> relation name mapping\n \"\"\"\n super().__init__()\n self.sentence_encoder = sentence_encoder\n self.num_class = num_class\n self.fc = nn.Linear(self.sentence_encoder.hidden_size, num_class)\n self.softmax = nn.Softmax(-1)\n self.rel2id = rel2id\n self.id2rel = {}\n self.drop = nn.Dropout()\n for rel, id in rel2id.items():\n self.id2rel[id] = rel\n\n def infer(self, item):\n self.eval()\n item = self.sentence_encoder.tokenize(item)\n logits = self.forward(*item)\n logits = self.softmax(logits)\n score, pred = logits.max(-1)\n score = score.item()\n pred = pred.item()\n return self.id2rel[pred], score\n\n def forward(self, args):\n \"\"\"\n Args:\n args: depends on the encoder\n Return:\n logits, (B, N)\n \"\"\"\n rep = self.sentence_encoder(args) # (B, H)\n rep = self.drop(rep)\n logits = self.fc(rep) # (B, N)\n return logits\n\n# difference from above lies in the forward function\nclass SoftmaxNNLegacy(SentenceRE):\n \"\"\"\n Softmax classifier for sentence-level relation extraction.\n \"\"\"\n\n def __init__(self, sentence_encoder, num_class, rel2id, hidden_factor_size=1):\n \"\"\"\n Args:\n sentence_encoder: encoder for sentences\n num_class: number of classes\n id2rel: dictionary of id -> relation name mapping\n \"\"\"\n super().__init__()\n self.sentence_encoder = sentence_encoder\n self.num_class = num_class\n self.fc = nn.Linear(self.sentence_encoder.hidden_size * hidden_factor_size, num_class)\n self.softmax = nn.Softmax(-1)\n self.rel2id = rel2id\n self.id2rel = {}\n self.drop = nn.Dropout()\n for rel, id in rel2id.items():\n self.id2rel[id] = rel\n if torch.cuda.is_available():\n self.device = torch.device(\"cuda\")\n else:\n self.device = torch.device(\"cpu\")\n # torch.set_num_threads(1)\n\n def infer(self, item):\n self.eval()\n item = self.sentence_encoder.tokenize(item)\n logits = self.forward(*item)\n logits = self.softmax(logits)\n score, pred = logits.max(-1)\n score = score.item()\n pred = pred.item()\n return self.id2rel[pred], score\n\n def forward(self, *args):\n \"\"\"\n Args:\n args: depends on the encoder\n Return:\n logits, (B, N)\n \"\"\"\n rep = self.sentence_encoder(*args) # (B, H)\n rep = self.drop(rep)\n logits = self.fc(rep) # (B, N)\n return logits\n\n# difference from above lies in the forward function\nclass SoftmaxNNLegacyMentionPool(SoftmaxNNLegacy):\n \"\"\"\n Softmax classifier for sentence-level relation extraction.\n \"\"\"\n def forward(self, *args):\n \"\"\"\n Args:\n args: depends on the encoder\n Return:\n logits, (B, N)\n \"\"\"\n x, head_arrays, tail_arrays = self.sentence_encoder(*args) # (B, H)\n #print('x', x.shape)\n # head_arrays = args[1]\n #print('len(head_arrays)', len(head_arrays))\n #print('len(head_arrays[0])', len(head_arrays[0]))\n #print('len(head_arrays[0])', len(head_arrays[1]))\n # tail_arrays = args[2]\n pooled_vector_dict = {}\n total = sum([len(head_array) for head_array in head_arrays])\n #print('total', total)\n result_tensor = torch.zeros((total, 2*768)) # TODO: hidden size is currently hard-coded; this should be fixed\n ct = 0\n for i in range(x.size(0)):\n curr_head_array = head_arrays[i]\n curr_tail_array = tail_arrays[i]\n for curr_head, curr_tail in zip(curr_head_array, curr_tail_array):\n head_start = curr_head[0]\n tail_start = curr_tail[0]\n head_end = curr_head[1]\n tail_end = curr_tail[1]\n head_key = str(i) + '#' + str(head_start) + '#' + str(head_end)\n tail_key = str(i) + '#' + str(tail_start) + '#' + str(tail_end)\n if head_key not in pooled_vector_dict:\n head_vectors = torch.narrow(x[i], 0, int(head_start), int(head_end - head_start)) # HEAD_LENGTH X EMBED\n head_max = torch.max(head_vectors, 0)[0]\n pooled_vector_dict[head_key] = head_max\n\n if tail_key not in pooled_vector_dict:\n tail_vectors = torch.narrow(x[i], 0, int(tail_start), int(tail_end - tail_start)) # TAIL_LENGTH X EMBED\n tail_max = torch.max(tail_vectors, 0)[0]\n pooled_vector_dict[tail_key] = tail_max\n\n #print('head shape', head_max.shape)\n result = (torch.cat((pooled_vector_dict[head_key], pooled_vector_dict[tail_key]))).unsqueeze(0) #.to(self.device)\n #print('result shape', result.shape)\n result_tensor[ct, :] = result\n ct += 1\n result_tensor = result_tensor.to(self.device)\n\n rep = self.drop(result_tensor)\n logits = self.fc(rep) # (B, N)\n return logits"
] | [
[
"numpy.asarray"
],
[
"numpy.log",
"numpy.asarray",
"numpy.ones",
"numpy.argmax",
"numpy.sum"
],
[
"torch.nn.Softmax",
"torch.nn.Dropout",
"torch.max",
"torch.zeros",
"torch.cat",
"torch.nn.Linear",
"torch.cuda.is_available",
"torch.device"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
jacobbieker/NUR_Handin2 | [
"6e620b23191edaec4452d29eac90ec37ced0c038"
] | [
"one.py"
] | [
"import numpy as np\nimport matplotlib.pyplot as plt\nfrom one_a import one_a\nfrom one_b import one_b\nfrom one_c import one_c\nfrom one_d import one_d\nfrom one_e import one_e\n\n\ndef random_generator(seed, m=2 ** 64 - 1, a=2349543, c=913842, a1=21, a2=35, a3=4, a4=4294957665):\n \"\"\"\n Generates psuedorandom numbers with a combination of (M)LCC, 64 bit shift, and MWC\n :param seed: Seed to use\n :param m: Determines period of the MLCC\n :param a: For the MLCC\n :param c: For the MLCC\n :param a1: For the first bit shift\n :param a2: For the second bit shift\n :param a3: For the third bit shift\n :param a4: For the MWC\n :return:\n \"\"\"\n\n # First linear congruential generator\n # While true, so the generator never stops making new numbers\n # This is used to make sure teh XOR shift is 64 bit\n bit_64 = 0xffffffffffffffff\n while True:\n # This is MLCC part\n generated_number = (a * seed + c) % m\n # Now bit shift\n generated_number = generated_number ^ (generated_number >> a1) & bit_64\n generated_number = generated_number ^ (generated_number << a2) & bit_64\n generated_number = generated_number ^ (generated_number >> a3) & bit_64\n\n # Now MWC part\n mwc_out = a4 * (generated_number & (2 ** 32 - 1)) + (generated_number >> 32)\n\n seed = mwc_out # set the seed to a new number, so a different number generated next time\n mwc_out = mwc_out / m\n\n if mwc_out > 1.:\n # Have to make it between 1 and 0, so mod 1. makes sure its between 0 and 1 now\n close_to_final = mwc_out % 1.\n else:\n close_to_final = mwc_out\n\n yield close_to_final\n\n\ndef all_one(rand_gen):\n one_a(rand_gen)\n plt.cla()\n one_b(rand_gen)\n plt.cla()\n one_c(rand_gen)\n plt.cla()\n one_d(rand_gen)\n plt.cla()\n one_e(rand_gen)\n plt.cla()\n"
] | [
[
"matplotlib.pyplot.cla"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
manish-pra/trcopo | [
"df8730f07ef554970c7a0aa653cc42d4886948ec",
"df8730f07ef554970c7a0aa653cc42d4886948ec"
] | [
"others/maddpg/utils/noise.py",
"trcopo_optim/trcopo.py"
] | [
"import numpy as np\n\n\n# from https://github.com/songrotek/DDPG/blob/master/ou_noise.py\nclass OUNoise:\n def __init__(self, action_dimension, scale=0.1, mu=0, theta=0.15, sigma=1):#sigma=0.2\n self.action_dimension = action_dimension\n self.scale = scale\n self.mu = mu\n self.theta = theta\n self.sigma = sigma\n self.state = np.ones(self.action_dimension) * self.mu\n self.reset()\n\n def reset(self):\n self.state = np.ones(self.action_dimension) * self.mu\n\n def noise(self):\n x = self.state\n dx = self.theta * (self.mu - x) + self.sigma * np.random.randn(len(x))\n self.state = x + dx\n return self.state * self.scale\n",
"import math\nimport time\n\nimport torch\nimport torch.autograd as autograd\nfrom torch.distributions import Categorical\n\nfrom trcopo_optim.utils import zero_grad, conjugate_gradient, general_conjugate_gradient, conjugate_gradient_2trpo, conjugate_gradient_trpo\nimport scipy.sparse.linalg as lin\nfrom scipy.sparse.linalg import LinearOperator\n\n\nclass TRCoPO(object):\n def __init__(self, max_params, min_params, lam=1, threshold=0.01, device=torch.device('cpu'),\n solve_x=False, collect_info=True):\n self.max_params = list(max_params)\n self.min_params = list(min_params)\n self.lam = lam\n self.threshold = threshold\n self.device = device\n self.solve_x = solve_x\n self.collect_info = collect_info\n\n self.old_x = None\n self.old_y = None\n self.old_AinvC = None\n\n def zero_grad(self):\n zero_grad(self.max_params)\n zero_grad(self.min_params)\n\n def getinfo(self):\n if self.collect_info:\n return self.norm_gx, self.norm_gy, self.norm_cgx, self.norm_cgy, self.iter_num\n else:\n raise ValueError(\n 'No update information stored. Set collect_info=True before call this method')\n def getlamda(self, grad_vec, kl_vec, params, esp):\n Ainvg, self.iter_num = conjugate_gradient_2trpo(grad_vec = grad_vec, kl_vec=kl_vec,\n params=params, g=-grad_vec,\n x=None, nsteps=10,residual_tol=1e-6,#*grad_x_vec.shape[0],\n device=self.device)\n\n g = autograd.grad(kl_vec, params, grad_outputs=Ainvg,retain_graph=True)\n g_vec = torch.cat([g.contiguous().view(-1, 1) for g in g])\n\n sAs = torch.matmul(Ainvg.transpose(0,1),g_vec)\n\n step_size = torch.sqrt(torch.abs(2*esp/sAs))\n lamda = 1/step_size\n if sAs<0:\n a=1\n else:\n a=0\n return lamda, a\n\n\n def step(self, get_log_prob):\n\n log_probs1, log_probs2, val1_p = get_log_prob()\n objective = torch.exp(log_probs1 + log_probs2 - log_probs1.detach() - log_probs2.detach()) * (val1_p)\n ob = objective.mean()\n\n kl = torch.mean(-log_probs1 - log_probs2)\n\n grad_x = autograd.grad(ob, self.max_params, create_graph=True, retain_graph=True)\n grad_x_vec = torch.cat([g.contiguous().view(-1,1) for g in grad_x])\n grad_y = autograd.grad(ob, self.min_params, create_graph=True, retain_graph=True)\n grad_y_vec = torch.cat([g.contiguous().view(-1,1) for g in grad_y])\n\n kl_x = autograd.grad(kl, self.max_params, create_graph=True, retain_graph=True)\n kl_x_vec = torch.cat([g.contiguous().view(-1,1) for g in kl_x])\n kl_y = autograd.grad(kl, self.min_params, create_graph=True, retain_graph=True)\n kl_y_vec = torch.cat([g.contiguous().view(-1,1) for g in kl_y])\n\n lam1,_ = self.getlamda(grad_x_vec, kl_x_vec, self.max_params, self.threshold)\n lam2,_ = self.getlamda(grad_y_vec, kl_y_vec, self.min_params, self.threshold)\n\n lamda = torch.min(lam1,lam2)\n lamda = lamda/2\n esp = 100\n self.its = 0\n while esp>self.threshold:\n lamda = lamda*2\n\n def mv(v):\n p = torch.FloatTensor(v).reshape(2*kl_x_vec.size(0), 1)\n c1 = p[0:int(p.size(0) / 2)]\n c2 = p[int(p.size(0) / 2):p.size(0)]\n self.its = self.its + 1\n # print(self.its)\n tot_grad_xy = autograd.grad(grad_y_vec, self.max_params, grad_outputs=c2, retain_graph=True)\n hvp_x_vec = torch.cat([g.contiguous().view(-1, 1) for g in tot_grad_xy]) # B1\n\n tot_grad_yx = autograd.grad(grad_x_vec, self.min_params, grad_outputs=c1, retain_graph=True)\n hvp_y_vec = torch.cat([g.contiguous().view(-1, 1) for g in tot_grad_yx]) # B2\n\n B = torch.cat([-hvp_x_vec, hvp_y_vec], dim=0)\n\n a11 = autograd.grad(kl_x_vec, self.max_params, grad_outputs=c1, retain_graph=True)\n a11_vec = torch.cat([g.contiguous().view(-1, 1) for g in a11]) # A11\n a22 = autograd.grad(kl_y_vec, self.min_params, grad_outputs=c2, retain_graph=True)\n a22_vec = torch.cat([g.contiguous().view(-1, 1) for g in a22]) # A22\n\n a1 = a11_vec # + a12_vec\n a2 = a22_vec # + a21_vec\n A = torch.cat([a1, a2], dim=0)\n Avp_ = lamda * A + B\n return Avp_\n\n D = LinearOperator((2*kl_x_vec.size(0), 2*kl_x_vec.size(0)), matvec=mv)\n\n # if self.old_AinvC is not None:\n # AinvC = lin.lgmres(D, torch.cat([-grad_x_vec,grad_y_vec],dim=0).clone().detach(), maxiter=2, x0=self.old_AinvC, tol=1e-2)\n # else:\n # AinvC = lin.lgmres(D, torch.cat([-grad_x_vec, grad_y_vec], dim=0).clone().detach(), maxiter=2, tol=1e-2)\n # self.iter_num = 0\n\n if self.old_AinvC is not None:\n AinvC = lin.gmres(D, torch.cat([-grad_x_vec,grad_y_vec],dim=0).clone().detach(), maxiter=3,restrt=10, x0=self.old_AinvC, tol=1e-2)\n else:\n AinvC = lin.gmres(D, torch.cat([-grad_x_vec, grad_y_vec], dim=0).clone().detach(), maxiter=3,restrt=10, tol=1e-2)\n self.iter_num = 0\n # print('conv',AinvC[1])\n\n # AinvC_temp, self.iter_num = conjugate_gradient_trpo(grad_x_vec = grad_x_vec, grad_y_vec=grad_y_vec,\n # kl_x_vec=kl_x_vec, kl_y_vec=kl_y_vec, lam=lamda,\n # max_params=self.max_params, min_params=self.min_params, c=torch.cat([-grad_x_vec,grad_y_vec],dim=0),\n # x=None, nsteps=10,#2*grad_x_vec.shape[0],\n # device=self.device, residual_tol=1)\n\n AinvC = torch.FloatTensor(AinvC[0]).reshape(2*kl_x_vec.size(0), 1)\n\n\n c1 = AinvC[0:int(AinvC.size(0)/2)]\n c2 = AinvC[int(AinvC.size(0)/2):AinvC.size(0)]\n a11 = autograd.grad(kl_x_vec, self.max_params, grad_outputs=c1, retain_graph=True)\n a11_vec = torch.cat([g.contiguous().view(-1, 1) for g in a11])\n a22 = autograd.grad(kl_y_vec, self.min_params, grad_outputs=c2, retain_graph=True)\n a22_vec = torch.cat([g.contiguous().view(-1, 1) for g in a22])\n\n a1 = a11_vec #+ a12_vec\n a2 = a22_vec #+ a21_vec\n A = torch.cat([a1,a2],dim=0)\n\n esp = torch.abs(torch.matmul(AinvC.transpose(0,1),A))\n self.old_AinvC = AinvC\n # break\n # print(AinvC, AinvC_temp)\n\n\n cg_x = -c1\n cg_y = -c2\n\n index = 0\n for p in self.max_params:\n p.data.add_(cg_x[index: index + p.numel()].reshape(p.shape))\n index += p.numel()\n if index != cg_x.numel():\n raise ValueError('CG size mismatch')\n\n new_log_probs1, _, _ = get_log_prob()\n\n objective = torch.exp(new_log_probs1 - log_probs1.detach()) * (val1_p)\n ob_ed = objective.mean()\n improve1 = ob_ed - ob\n\n index = 0\n for p in self.min_params:\n p.data.add_(cg_y[index: index + p.numel()].reshape(p.shape))\n index += p.numel()\n if index != cg_y.numel():\n raise ValueError('CG size mismatch')\n\n _, new_log_probs2, _ = get_log_prob()\n\n objective = torch.exp(new_log_probs2 - log_probs2.detach()) * (val1_p)\n ob_ed = objective.mean()\n improve2 = ob_ed - ob\n stat = 5\n if improve1<0 or improve2>0:\n stat = 0\n cg_x = -cg_x\n index=0\n for p in self.max_params:\n p.data.add_(cg_x[index: index + p.numel()].reshape(p.shape))\n index += p.numel()\n cg_y = -cg_y\n index=0\n for p in self.min_params:\n p.data.add_(cg_y[index: index + p.numel()].reshape(p.shape))\n index += p.numel()\n if improve1<0 and improve2<0:\n stat=1\n if improve1>0 and improve2<0:\n stat=2\n if improve1<0 and improve2>0:\n stat=3\n if improve1>0 and improve2>0:\n stat=4\n\n if self.collect_info:\n self.norm_gx = torch.norm(grad_x_vec, p=2)\n self.norm_gy = torch.norm(grad_y_vec, p=2)\n self.norm_cgx = torch.norm(cg_x, p=2)\n self.norm_cgy = torch.norm(cg_y, p=2)\n self.solve_x = False if self.solve_x else True\n\n return improve1, improve2, lamda, lam1, lam2, esp, stat, self.its\n\n####################################\nclass TRPO(object):\n def __init__(self, params, lam=1, esp=0.01, bound=0.01, device=torch.device('cpu'),\n solve_x=False, collect_info=True):\n self.model=params\n self.params = list(params.parameters())\n self.lam = lam\n self.esp = esp\n self.bound = bound\n self.device = device\n self.solve_x = solve_x\n self.collect_info = collect_info\n\n self.old_x = None\n self.old_y = None\n\n def zero_grad(self):\n zero_grad(self.params)\n\n def getinfo(self):\n if self.collect_info:\n return self.norm_gx, self.norm_cgx, self.iter_num, self.norm_kl\n else:\n raise ValueError(\n 'No update information stored. Set collect_info=True before call this method')\n\n def step(self,get_logprob):\n\n log_probs, val1_p = get_logprob()\n\n objective = torch.exp(log_probs-log_probs.detach()) * (-val1_p)\n loss = objective.mean()\n\n kl = torch.mean(-log_probs)\n\n grad = autograd.grad(loss, self.params, retain_graph=True)\n grad_vec = torch.cat([g.contiguous().view(-1,1) for g in grad])\n\n kl_p = autograd.grad(kl, self.params, create_graph=True, retain_graph=True)\n kl_vec = torch.cat([g.contiguous().view(-1,1) for g in kl_p])\n\n esp = self.esp\n\n Ainvg, self.iter_num = conjugate_gradient_2trpo(grad_vec = grad_vec, kl_vec=kl_vec,\n params=self.params, g=-grad_vec,\n x=None, nsteps=10,#grad_vec.shape[0],\n device=self.device,residual_tol = 1e-4)\n\n g = autograd.grad(kl_vec, self.params, grad_outputs=Ainvg,retain_graph=True)\n g_vec = torch.cat([g.contiguous().view(-1, 1) for g in g])\n\n # a11 = autograd.grad(kl_vec, self.params, grad_outputs=Ainvg, retain_graph=True)\n # a11_vec = torch.cat([g.contiguous().view(-1, 1) for g in a11]) # A11\n\n sAs = torch.matmul(Ainvg.transpose(0,1),g_vec)\n\n # def get_kl():\n # pi_a2_s = self.model(torch.stack(state))\n # dist_batch2 = Categorical(pi_a2_s)\n # log_probs2 = dist_batch2.log_prob(action)\n #\n # kl = torch.mean(-log_probs2)\n # return kl\n\n # trpo_step(self.model, loss, get_kl, 0.01, 0)\n\n step_size = torch.sqrt(torch.abs(2*esp/sAs))\n improvement = 0\n\n # AinvC are final parameters\n expected_improvement = torch.matmul(Ainvg.transpose(0,1),-grad_vec)*step_size\n cg_x = step_size*Ainvg\n ratio=0\n if sAs>0:\n index = 0\n for p in self.params:\n p.data.add_(cg_x[index: index + p.numel()].reshape(p.shape))\n index += p.numel()\n if index != cg_x.numel():\n raise ValueError('CG size mismatch')\n\n log_probs_new, val1_p = get_logprob()\n\n objective = torch.exp(log_probs_new-log_probs.detach()) * (-val1_p)\n loss_ed = objective.mean()\n improvement= loss_ed-loss\n # a=1\n # if sAs<0:\n # a = -1\n # if improvement>0:\n # a=-2\n\n ratio = -improvement/expected_improvement\n if improvement>0 or ratio<0.1: # change update\n improvement=0\n index = 0\n for p in self.params:\n cg_x =-cg_x\n p.data.add_(cg_x[index: index + p.numel()].reshape(p.shape))\n index += p.numel()\n\n if self.collect_info:\n self.norm_gx = torch.norm(grad_vec, p=2)\n self.norm_cgx = torch.norm(cg_x, p=2)\n self.norm_kl = torch.norm(kl_vec, p=2)\n self.solve_x = False if self.solve_x else True\n\n return step_size, improvement, ratio, sAs\n\n########################################################\n\nclass TRCoPO_ORCA(object):\n def __init__(self, max_model, min_model, lam=1, esp=6, bound=0.01, device=torch.device('cpu'),\n solve_x=False, collect_info=True):\n self.max_model = max_model\n self.min_model = min_model\n self.max_params = list(max_model.parameters())\n self.min_params = list(min_model.parameters())\n self.lam = lam\n self.esp = esp\n self.bound = bound\n self.device = device\n self.solve_x = solve_x\n self.collect_info = collect_info\n\n self.old_x = None\n self.old_y = None\n\n def zero_grad(self):\n zero_grad(self.max_params)\n zero_grad(self.min_params)\n\n def getinfo(self):\n if self.collect_info:\n return self.norm_gx, self.norm_gy, self.norm_px, self.norm_py, self.norm_cgx, self.norm_cgy, \\\n self.timer, self.iter_num\n else:\n raise ValueError(\n 'No update information stored. Set collect_info=True before call this method')\n def getlamda(self, grad_vec, kl_vec, params, esp):\n Ainvg, self.iter_num = conjugate_gradient_2trpo(grad_vec = grad_vec, kl_vec=kl_vec,\n params=params, g=-grad_vec,\n x=None, nsteps=10,#*grad_x_vec.shape[0],\n device=self.device)\n\n g = autograd.grad(kl_vec, params, grad_outputs=Ainvg,retain_graph=True)\n g_vec = torch.cat([g.contiguous().view(-1, 1) for g in g])\n\n sAs = torch.matmul(Ainvg.transpose(0,1),g_vec)\n\n step_size = torch.sqrt(torch.abs(2*esp/sAs))\n if sAs<0:\n a=1\n else:\n a=0\n return step_size, a\n\n def step(self, advantage, state1, state2, action1,action2):\n\n val1_p = advantage\n dist_batch1 = self.max_model(state1)\n log_probs1_inid = dist_batch1.log_prob(action1)\n log_probs1 = log_probs1_inid.sum(1)\n\n dist_batch2 = self.min_model(state2)\n log_probs2_inid = dist_batch2.log_prob(action2)\n log_probs2 = log_probs2_inid.sum(1)\n\n objective = torch.exp(log_probs1 + log_probs2 - log_probs1.detach() - log_probs2.detach()) * (val1_p)\n ob = objective.mean()\n\n kl = torch.mean(-log_probs1 - log_probs2)\n\n grad_x = autograd.grad(ob, self.max_params, create_graph=True, retain_graph=True)\n grad_x_vec = torch.cat([g.contiguous().view(-1,1) for g in grad_x])\n grad_y = autograd.grad(ob, self.min_params, create_graph=True, retain_graph=True)\n grad_y_vec = torch.cat([g.contiguous().view(-1,1) for g in grad_y])\n\n kl_x = autograd.grad(kl, self.max_params, create_graph=True, retain_graph=True)\n kl_x_vec = torch.cat([g.contiguous().view(-1,1) for g in kl_x])\n kl_y = autograd.grad(kl, self.min_params, create_graph=True, retain_graph=True)\n kl_y_vec = torch.cat([g.contiguous().view(-1,1) for g in kl_y])\n\n lam1,_ = self.getlamda(grad_x_vec, kl_x_vec, self.max_params, 0.01)\n lam2,_ = self.getlamda(grad_y_vec, kl_y_vec, self.min_params, 0.01)\n\n lamda = torch.min(lam1,lam2)\n lamda = lamda/2\n esp = 10\n while esp>self.esp: #0.0001\n lamda = lamda*2\n AinvC, self.iter_num = conjugate_gradient_trpo(grad_x_vec = grad_x_vec, grad_y_vec=grad_y_vec,\n kl_x_vec=kl_x_vec, kl_y_vec=kl_y_vec, lam=lamda,\n max_params=self.max_params, min_params=self.min_params, c=torch.cat([-grad_x_vec,grad_y_vec],dim=0),\n x=None, nsteps=10,residual_tol=1e-2,#*grad_x_vec.shape[0],\n device=self.device)\n # print(self.iter_num)\n\n c1 = AinvC[0:int(AinvC.size(0)/2)]\n c2 = AinvC[int(AinvC.size(0)/2):AinvC.size(0)]\n a11 = autograd.grad(kl_x_vec, self.max_params, grad_outputs=c1, retain_graph=True)\n a11_vec = torch.cat([g.contiguous().view(-1, 1) for g in a11])\n a22 = autograd.grad(kl_y_vec, self.min_params, grad_outputs=c2, retain_graph=True)\n a22_vec = torch.cat([g.contiguous().view(-1, 1) for g in a22])\n\n a1 = a11_vec #+ a12_vec\n a2 = a22_vec #+ a21_vec\n A = torch.cat([a1,a2],dim=0)\n\n esp = torch.abs(torch.matmul(AinvC.transpose(0,1),A))\n\n\n cg_x = -c1\n cg_y = -c2\n\n index = 0\n for p in self.max_params:\n p.data.add_(cg_x[index: index + p.numel()].reshape(p.shape))\n index += p.numel()\n if index != cg_x.numel():\n raise ValueError('CG size mismatch')\n\n dist_batch1 = self.max_model(state1)\n new_log_probs1_inid = dist_batch1.log_prob(action1)\n new_log_probs1 = new_log_probs1_inid.sum(1)\n\n objective = torch.exp(new_log_probs1 - log_probs1.detach()) * (val1_p)\n ob_ed = objective.mean()\n improve1 = ob_ed - ob\n\n index = 0\n for p in self.min_params:\n p.data.add_(cg_y[index: index + p.numel()].reshape(p.shape))\n index += p.numel()\n if index != cg_y.numel():\n raise ValueError('CG size mismatch')\n\n dist_batch2 = self.min_model(state2)\n new_log_probs2_inid = dist_batch2.log_prob(action2)\n new_log_probs2 = new_log_probs2_inid.sum(1)\n # new_log_probs1 = log_probs1_inid.sum(1)\n\n objective = torch.exp(new_log_probs2 - log_probs2.detach()) * (val1_p)\n ob_ed = objective.mean()\n improve2 = ob_ed - ob\n stat = 5\n if improve1<0 or improve2>0:\n stat = 0\n cg_x = -cg_x\n index=0\n for p in self.max_params:\n p.data.add_(cg_x[index: index + p.numel()].reshape(p.shape))\n index += p.numel()\n cg_y = -cg_y\n index=0\n for p in self.min_params:\n p.data.add_(cg_y[index: index + p.numel()].reshape(p.shape))\n index += p.numel()\n if improve1<0 and improve2<0:\n stat=1\n if improve1>0 and improve2<0:\n stat=2\n if improve1<0 and improve2>0:\n stat=3\n if improve1>0 and improve2>0:\n stat=4\n\n if self.collect_info:\n self.norm_gx = torch.norm(grad_x_vec, p=2)\n self.norm_gy = torch.norm(grad_y_vec, p=2)\n self.norm_cgx = torch.norm(cg_x, p=2)\n self.norm_cgy = torch.norm(cg_y, p=2)\n self.solve_x = False if self.solve_x else True\n\n return improve1, improve2, lamda, lam1, lam2, esp, stat\n\n################################################################################\nclass TRPO_ORCA(object):\n def __init__(self, params, lam=1, esp=0.01, bound=0.01, device=torch.device('cpu'),\n solve_x=False, collect_info=True):\n self.model=params\n self.params = list(params.parameters())\n self.lam = lam\n self.esp = esp\n self.bound = bound\n self.device = device\n self.solve_x = solve_x\n self.collect_info = collect_info\n\n self.old_x = None\n self.old_y = None\n\n def zero_grad(self):\n zero_grad(self.params)\n\n def getinfo(self):\n if self.collect_info:\n return self.norm_gx, self.norm_gy, self.norm_px, self.norm_py, self.norm_cgx, self.norm_cgy, \\\n self.timer, self.iter_num\n else:\n raise ValueError(\n 'No update information stored. Set collect_info=True before call this method')\n\n def step(self, advantage, state, action):\n val1_p = advantage\n dist_batch = self.model(state)\n log_probs_inid = dist_batch.log_prob(action)\n log_probs = log_probs_inid.sum(1)\n\n objective = torch.exp(log_probs-log_probs.detach()) * (-val1_p)\n loss = objective.mean()\n\n kl = torch.mean(-log_probs)\n\n grad = autograd.grad(loss, self.params, retain_graph=True)\n grad_vec = torch.cat([g.contiguous().view(-1,1) for g in grad])\n\n kl_p = autograd.grad(kl, self.params, create_graph=True, retain_graph=True)\n kl_vec = torch.cat([g.contiguous().view(-1,1) for g in kl_p])\n\n esp = self.esp\n\n Ainvg, self.iter_num = conjugate_gradient_2trpo(grad_vec = grad_vec, kl_vec=kl_vec,\n params=self.params, g=-grad_vec,\n x=None, nsteps=10,#*grad_x_vec.shape[0],\n device=self.device)\n\n g = autograd.grad(kl_vec, self.params, grad_outputs=Ainvg,retain_graph=True)\n g_vec = torch.cat([g.contiguous().view(-1, 1) for g in g])\n\n # a11 = autograd.grad(kl_vec, self.params, grad_outputs=Ainvg, retain_graph=True)\n # a11_vec = torch.cat([g.contiguous().view(-1, 1) for g in a11]) # A11\n\n sAs = torch.matmul(Ainvg.transpose(0,1),g_vec)\n\n # def get_kl():\n # pi_a2_s = self.model(torch.stack(state))\n # dist_batch2 = Categorical(pi_a2_s)\n # log_probs2 = dist_batch2.log_prob(action)\n #\n # kl = torch.mean(-log_probs2)\n # return kl\n\n # trpo_step(self.model, loss, get_kl, 0.01, 0)\n\n step_size = torch.sqrt(torch.abs(2*esp/sAs))\n improvement = 0\n\n # AinvC are final parameters\n expected_improvement = torch.matmul(Ainvg.transpose(0,1),-grad_vec)*step_size\n cg_x = step_size*Ainvg\n ratio=0\n if sAs>0:\n index = 0\n for p in self.params:\n p.data.add_(cg_x[index: index + p.numel()].reshape(p.shape))\n index += p.numel()\n if index != cg_x.numel():\n raise ValueError('CG size mismatch')\n\n dist_batch = self.model(state)\n log_probs_new_inid = dist_batch.log_prob(action)\n log_probs_new = log_probs_new_inid.sum(1)\n\n objective = torch.exp(log_probs_new-log_probs.detach()) * (-val1_p)\n loss_ed = objective.mean()\n improvement= loss_ed-loss\n # a=1\n # if sAs<0:\n # a = -1\n # if improvement>0:\n # a=-2\n\n ratio = -improvement/expected_improvement\n if improvement>0 or ratio<0.1: # change update\n improvement=0\n index = 0\n for p in self.params:\n cg_x =-cg_x\n p.data.add_(cg_x[index: index + p.numel()].reshape(p.shape))\n index += p.numel()\n\n if self.collect_info:\n self.norm_gx = torch.norm(grad_vec, p=2)\n # self.norm_cgx = torch.norm(cg_x, p=2)\n self.solve_x = False if self.solve_x else True\n\n return step_size, improvement, ratio\n\n"
] | [
[
"numpy.ones"
],
[
"torch.mean",
"torch.abs",
"torch.norm",
"torch.cat",
"torch.min",
"torch.FloatTensor",
"torch.device",
"torch.autograd.grad"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
cyc/estimator | [
"742a07296c8f584150bb02f97be7207130ded5fd",
"742a07296c8f584150bb02f97be7207130ded5fd",
"742a07296c8f584150bb02f97be7207130ded5fd",
"742a07296c8f584150bb02f97be7207130ded5fd",
"742a07296c8f584150bb02f97be7207130ded5fd"
] | [
"tensorflow_estimator/python/estimator/tpu/tpu_estimator_signals_test.py",
"tensorflow_estimator/contrib/estimator/python/estimator/rnn_v2_test.py",
"tensorflow_estimator/python/estimator/early_stopping.py",
"tensorflow_estimator/python/estimator/gc_test.py",
"tensorflow_estimator/python/estimator/canned/dnn_linear_combined.py"
] | [
"# 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\"\"\"TPU Estimator Signalling Tests.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport numpy as np\n\nfrom tensorflow.python.client import session\nfrom tensorflow.python.data.ops import dataset_ops\nfrom tensorflow.python.framework import errors\nfrom tensorflow.python.framework import ops\nfrom tensorflow.python.platform import test\nfrom tensorflow_estimator.python.estimator.tpu import tpu_estimator\n\n\ndef make_input_fn(num_samples):\n a = np.linspace(0, 100.0, num=num_samples)\n b = np.reshape(np.array(a, dtype=np.float32), (len(a), 1))\n\n def input_fn(params):\n batch_size = params['batch_size']\n da1 = dataset_ops.Dataset.from_tensor_slices(a)\n da2 = dataset_ops.Dataset.from_tensor_slices(b)\n\n dataset = dataset_ops.Dataset.zip((da1, da2))\n dataset = dataset.map(lambda fa, fb: {'a': fa, 'b': fb})\n dataset = dataset.batch(batch_size)\n return dataset\n return input_fn, (a, b)\n\n\ndef make_input_fn_with_labels(num_samples):\n a = np.linspace(0, 100.0, num=num_samples)\n b = np.reshape(np.array(a, dtype=np.float32), (len(a), 1))\n\n def input_fn(params):\n batch_size = params['batch_size']\n da1 = dataset_ops.Dataset.from_tensor_slices(a)\n da2 = dataset_ops.Dataset.from_tensor_slices(b)\n\n dataset = dataset_ops.Dataset.zip((da1, da2))\n dataset = dataset.map(lambda fa, fb: ({'a': fa}, fb))\n dataset = dataset.batch(batch_size)\n return dataset\n return input_fn, (a, b)\n\n\nclass TPUEstimatorStoppingSignalsTest(test.TestCase):\n\n def test_normal_output_without_signals(self):\n num_samples = 4\n batch_size = 2\n\n params = {'batch_size': batch_size}\n input_fn, (a, b) = make_input_fn(num_samples=num_samples)\n\n with ops.Graph().as_default():\n dataset = input_fn(params)\n features = dataset_ops.make_one_shot_iterator(dataset).get_next()\n\n # With tf.data.Dataset.batch, the batch is None, i.e., dynamic shape.\n self.assertIsNone(features['a'].shape.as_list()[0])\n\n with session.Session() as sess:\n result = sess.run(features)\n self.assertAllEqual(a[:batch_size], result['a'])\n self.assertAllEqual(b[:batch_size], result['b'])\n\n # This run should work as num_samples / batch_size = 2.\n result = sess.run(features)\n self.assertAllEqual(a[batch_size:num_samples], result['a'])\n self.assertAllEqual(b[batch_size:num_samples], result['b'])\n\n with self.assertRaises(errors.OutOfRangeError):\n # Given num_samples and batch_size, this run should fail.\n sess.run(features)\n\n def test_output_with_stopping_signals(self):\n num_samples = 4\n batch_size = 2\n\n params = {'batch_size': batch_size}\n input_fn, (a, b) = make_input_fn(num_samples=num_samples)\n\n with ops.Graph().as_default():\n dataset = input_fn(params)\n inputs = tpu_estimator._InputsWithStoppingSignals(dataset, batch_size)\n dataset_initializer = inputs.dataset_initializer()\n features, _ = inputs.features_and_labels()\n signals = inputs.signals()\n\n # With tf.data.Dataset.batch, the batch is None, i.e., dynamic shape.\n self.assertIsNone(features['a'].shape.as_list()[0])\n\n with session.Session() as sess:\n sess.run(dataset_initializer)\n\n result, evaluated_signals = sess.run([features, signals])\n self.assertAllEqual(a[:batch_size], result['a'])\n self.assertAllEqual(b[:batch_size], result['b'])\n self.assertAllEqual([[0.]] * batch_size, evaluated_signals['stopping'])\n\n # This run should work as num_samples / batch_size = 2.\n result, evaluated_signals = sess.run([features, signals])\n self.assertAllEqual(a[batch_size:num_samples], result['a'])\n self.assertAllEqual(b[batch_size:num_samples], result['b'])\n self.assertAllEqual([[0.]] * batch_size, evaluated_signals['stopping'])\n\n # This run should work, *but* see STOP ('1') as signals\n _, evaluated_signals = sess.run([features, signals])\n self.assertAllEqual([[1.]] * batch_size, evaluated_signals['stopping'])\n\n with self.assertRaises(errors.OutOfRangeError):\n sess.run(features)\n\n\nclass TPUEstimatorStoppingSignalsWithPaddingTest(test.TestCase):\n\n def test_num_samples_divisible_by_batch_size(self):\n num_samples = 4\n batch_size = 2\n\n params = {'batch_size': batch_size}\n input_fn, (a, b) = make_input_fn(num_samples=num_samples)\n\n with ops.Graph().as_default():\n dataset = input_fn(params)\n inputs = tpu_estimator._InputsWithStoppingSignals(dataset, batch_size,\n add_padding=True)\n dataset_initializer = inputs.dataset_initializer()\n features, _ = inputs.features_and_labels()\n signals = inputs.signals()\n\n # With padding, all shapes are static now.\n self.assertEqual(batch_size, features['a'].shape.as_list()[0])\n\n with session.Session() as sess:\n sess.run(dataset_initializer)\n\n result, evaluated_signals = sess.run([features, signals])\n self.assertAllEqual(a[:batch_size], result['a'])\n self.assertAllEqual(b[:batch_size], result['b'])\n self.assertAllEqual([[0.]] * batch_size, evaluated_signals['stopping'])\n self.assertAllEqual([0.] * batch_size,\n evaluated_signals['padding_mask'])\n\n # This run should work as num_samples / batch_size = 2.\n result, evaluated_signals = sess.run([features, signals])\n self.assertAllEqual(a[batch_size:num_samples], result['a'])\n self.assertAllEqual(b[batch_size:num_samples], result['b'])\n self.assertAllEqual([[0.]] * batch_size, evaluated_signals['stopping'])\n self.assertAllEqual([0.] * batch_size,\n evaluated_signals['padding_mask'])\n\n # This run should work, *but* see STOP ('1') as signals\n _, evaluated_signals = sess.run([features, signals])\n self.assertAllEqual([[1.]] * batch_size, evaluated_signals['stopping'])\n\n with self.assertRaises(errors.OutOfRangeError):\n sess.run(features)\n\n def test_num_samples_not_divisible_by_batch_size(self):\n num_samples = 5\n batch_size = 2\n\n params = {'batch_size': batch_size}\n input_fn, (a, b) = make_input_fn_with_labels(num_samples=num_samples)\n\n with ops.Graph().as_default():\n dataset = input_fn(params)\n inputs = tpu_estimator._InputsWithStoppingSignals(dataset, batch_size,\n add_padding=True)\n dataset_initializer = inputs.dataset_initializer()\n features, labels = inputs.features_and_labels()\n signals = inputs.signals()\n\n # With padding, all shapes are static.\n self.assertEqual(batch_size, features['a'].shape.as_list()[0])\n\n with session.Session() as sess:\n sess.run(dataset_initializer)\n\n evaluated_features, evaluated_labels, evaluated_signals = (\n sess.run([features, labels, signals]))\n self.assertAllEqual(a[:batch_size], evaluated_features['a'])\n self.assertAllEqual(b[:batch_size], evaluated_labels)\n self.assertAllEqual([[0.]] * batch_size, evaluated_signals['stopping'])\n self.assertAllEqual([0.] * batch_size,\n evaluated_signals['padding_mask'])\n\n # This run should work as num_samples / batch_size >= 2.\n evaluated_features, evaluated_labels, evaluated_signals = (\n sess.run([features, labels, signals]))\n self.assertAllEqual(a[batch_size:2*batch_size], evaluated_features['a'])\n self.assertAllEqual(b[batch_size:2*batch_size], evaluated_labels)\n self.assertAllEqual([[0.]] * batch_size, evaluated_signals['stopping'])\n self.assertAllEqual([0.] * batch_size,\n evaluated_signals['padding_mask'])\n\n # This is the final partial batch.\n evaluated_features, evaluated_labels, evaluated_signals = (\n sess.run([features, labels, signals]))\n real_batch_size = num_samples % batch_size\n\n # Assert the real part.\n self.assertAllEqual(a[2*batch_size:num_samples],\n evaluated_features['a'][:real_batch_size])\n self.assertAllEqual(b[2*batch_size:num_samples],\n evaluated_labels[:real_batch_size])\n # Assert the padded part.\n self.assertAllEqual([0.0] * (batch_size - real_batch_size),\n evaluated_features['a'][real_batch_size:])\n self.assertAllEqual([[0.0]] * (batch_size - real_batch_size),\n evaluated_labels[real_batch_size:])\n\n self.assertAllEqual([[0.]] * batch_size, evaluated_signals['stopping'])\n\n padding = ([.0] * real_batch_size\n + [1.] * (batch_size - real_batch_size))\n self.assertAllEqual(padding, evaluated_signals['padding_mask'])\n\n # This run should work, *but* see STOP ('1') as signals\n _, evaluated_signals = sess.run([features, signals])\n self.assertAllEqual([[1.]] * batch_size, evaluated_signals['stopping'])\n\n with self.assertRaises(errors.OutOfRangeError):\n sess.run(features)\n\n def test_slice(self):\n num_samples = 3\n batch_size = 2\n\n params = {'batch_size': batch_size}\n input_fn, (a, b) = make_input_fn(num_samples=num_samples)\n\n with ops.Graph().as_default():\n dataset = input_fn(params)\n inputs = tpu_estimator._InputsWithStoppingSignals(dataset, batch_size,\n add_padding=True)\n dataset_initializer = inputs.dataset_initializer()\n features, _ = inputs.features_and_labels()\n signals = inputs.signals()\n\n sliced_features = (\n tpu_estimator._PaddingSignals.slice_tensor_or_dict(\n features, signals))\n\n with session.Session() as sess:\n sess.run(dataset_initializer)\n\n result, evaluated_signals = sess.run([sliced_features, signals])\n self.assertAllEqual(a[:batch_size], result['a'])\n self.assertAllEqual(b[:batch_size], result['b'])\n self.assertAllEqual([[0.]] * batch_size, evaluated_signals['stopping'])\n\n # This is the final partial batch.\n result, evaluated_signals = sess.run([sliced_features, signals])\n self.assertEqual(1, len(result['a']))\n self.assertAllEqual(a[batch_size:num_samples], result['a'])\n self.assertAllEqual(b[batch_size:num_samples], result['b'])\n self.assertAllEqual([[0.]] * batch_size, evaluated_signals['stopping'])\n\n # This run should work, *but* see STOP ('1') as signals\n _, evaluated_signals = sess.run([sliced_features, signals])\n self.assertAllEqual([[1.]] * batch_size, evaluated_signals['stopping'])\n\n with self.assertRaises(errors.OutOfRangeError):\n sess.run(sliced_features)\n\n def test_slice_with_multi_invocations_per_step(self):\n num_samples = 3\n batch_size = 2\n\n params = {'batch_size': batch_size}\n input_fn, (a, b) = make_input_fn(num_samples=num_samples)\n\n with ops.Graph().as_default():\n dataset = input_fn(params)\n inputs = tpu_estimator._InputsWithStoppingSignals(\n dataset, batch_size, add_padding=True, num_invocations_per_step=2)\n dataset_initializer = inputs.dataset_initializer()\n features, _ = inputs.features_and_labels()\n signals = inputs.signals()\n\n sliced_features = (\n tpu_estimator._PaddingSignals.slice_tensor_or_dict(features, signals))\n\n with session.Session() as sess:\n sess.run(dataset_initializer)\n\n result, evaluated_signals = sess.run([sliced_features, signals])\n self.assertAllEqual(a[:batch_size], result['a'])\n self.assertAllEqual(b[:batch_size], result['b'])\n self.assertAllEqual([[0.]] * batch_size, evaluated_signals['stopping'])\n\n # This is the final partial batch.\n result, evaluated_signals = sess.run([sliced_features, signals])\n self.assertEqual(1, len(result['a']))\n self.assertAllEqual(a[batch_size:num_samples], result['a'])\n self.assertAllEqual(b[batch_size:num_samples], result['b'])\n self.assertAllEqual([[0.]] * batch_size, evaluated_signals['stopping'])\n\n # We should see 3 continuous batches with STOP ('1') as signals and all\n # of them have mask 1.\n _, evaluated_signals = sess.run([sliced_features, signals])\n self.assertAllEqual([[1.]] * batch_size, evaluated_signals['stopping'])\n self.assertAllEqual([1.] * batch_size,\n evaluated_signals['padding_mask'])\n\n _, evaluated_signals = sess.run([sliced_features, signals])\n self.assertAllEqual([[1.]] * batch_size, evaluated_signals['stopping'])\n self.assertAllEqual([1.] * batch_size,\n evaluated_signals['padding_mask'])\n\n _, evaluated_signals = sess.run([sliced_features, signals])\n self.assertAllEqual([[1.]] * batch_size, evaluated_signals['stopping'])\n self.assertAllEqual([1.] * batch_size,\n evaluated_signals['padding_mask'])\n with self.assertRaises(errors.OutOfRangeError):\n sess.run(sliced_features)\n\n\nif __name__ == '__main__':\n test.main()\n",
"# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"Tests for rnn.py.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport random\nimport tempfile\n\nfrom absl.testing import parameterized\nimport numpy as np\nimport six\n\nfrom tensorflow.core.example import example_pb2\nfrom tensorflow.core.example import feature_pb2\nfrom tensorflow.python.data.experimental.ops import readers\nfrom tensorflow.python.feature_column import feature_column_lib as fc\nfrom tensorflow.python.framework import dtypes\nfrom tensorflow.python.framework import ops\nfrom tensorflow.python.framework import sparse_tensor\nfrom tensorflow.python.framework import test_util\nfrom tensorflow.python.keras import activations\nfrom tensorflow.python.keras import initializers\nfrom tensorflow.python.keras import layers as keras_layers\nfrom tensorflow.python.keras import losses\nfrom tensorflow.python.keras.layers import recurrent_v2\nfrom tensorflow.python.keras.optimizer_v2 import adam\nfrom tensorflow.python.keras.optimizer_v2 import optimizer_v2\nfrom tensorflow.python.keras.utils import losses_utils\nfrom tensorflow.python.lib.io import python_io\nfrom tensorflow.python.ops import check_ops\nfrom tensorflow.python.ops import math_ops\nfrom tensorflow.python.ops import variables as variables_lib\nfrom tensorflow.python.platform import gfile\nfrom tensorflow.python.platform import test\nfrom tensorflow.python.training import checkpoint_utils\nfrom tensorflow.python.training import monitored_session\nfrom tensorflow.python.training import training_util\nfrom tensorflow_estimator.contrib.estimator.python.estimator import rnn_v2 as rnn\nfrom tensorflow_estimator.python.estimator import model_fn\nfrom tensorflow_estimator.python.estimator.canned import metric_keys\nfrom tensorflow_estimator.python.estimator.canned import parsing_utils\nfrom tensorflow_estimator.python.estimator.canned import prediction_keys\nfrom tensorflow_estimator.python.estimator.export import export\nfrom tensorflow_estimator.python.estimator.head import multi_class_head as multi_head_lib\nfrom tensorflow_estimator.python.estimator.head import sequential_head as seq_head_lib\nfrom tensorflow_estimator.python.estimator.inputs import numpy_io\n\n# Names of variables created by BasicRNNCell model.\nCELL_KERNEL_NAME = 'rnn_model/rnn/kernel'\nCELL_RECURRENT_KERNEL_NAME = 'rnn_model/rnn/recurrent_kernel'\nCELL_BIAS_NAME = 'rnn_model/rnn/bias'\nLOGITS_WEIGHTS_NAME = 'rnn_model/logits/kernel'\nLOGITS_BIAS_NAME = 'rnn_model/logits/bias'\n\n\ndef _assert_close(expected, actual, rtol=1e-04, name='assert_close'):\n with ops.name_scope(name, 'assert_close', (expected, actual, rtol)) as scope:\n expected = ops.convert_to_tensor(expected, name='expected')\n actual = ops.convert_to_tensor(actual, name='actual')\n rdiff = math_ops.abs(expected - actual, 'diff') / math_ops.abs(expected)\n rtol = ops.convert_to_tensor(rtol, name='rtol')\n return check_ops.assert_less(\n rdiff,\n rtol,\n data=('Condition expected =~ actual did not hold element-wise:'\n 'expected = ', expected, 'actual = ', actual, 'rdiff = ', rdiff,\n 'rtol = ', rtol,),\n name=scope)\n\n\ndef create_checkpoint(kernel, recurrent, bias, dense_kernel, dense_bias,\n global_step, model_dir):\n \"\"\"Create checkpoint file with provided model weights.\n\n Args:\n kernel: Iterable of values of input weights for the RNN cell.\n recurrent: Iterable of values of recurrent weights for the RNN cell.\n bias: Iterable of values of biases for the RNN cell.\n dense_kernel: Iterable of values for matrix connecting RNN output to logits.\n dense_bias: Iterable of values for logits bias term.\n global_step: Initial global step to save in checkpoint.\n model_dir: Directory into which checkpoint is saved.\n \"\"\"\n model_weights = {}\n model_weights[CELL_KERNEL_NAME] = kernel\n model_weights[CELL_RECURRENT_KERNEL_NAME] = recurrent\n model_weights[CELL_BIAS_NAME] = bias\n model_weights[LOGITS_WEIGHTS_NAME] = dense_kernel\n model_weights[LOGITS_BIAS_NAME] = dense_bias\n\n with ops.Graph().as_default():\n # Create model variables.\n for k, v in six.iteritems(model_weights):\n variables_lib.Variable(v, name=k, dtype=dtypes.float32)\n\n # Create non-model variables.\n global_step_var = training_util.create_global_step()\n assign_op = global_step_var.assign(global_step)\n\n # Initialize vars and save checkpoint.\n with monitored_session.MonitoredTrainingSession(\n checkpoint_dir=model_dir) as sess:\n sess.run(assign_op)\n\n\ndef _make_rnn_layer(rnn_cell_fn=None, units=None, cell_type=rnn.USE_DEFAULT,\n return_sequences=False):\n return rnn._make_rnn_layer(\n rnn_cell_fn=rnn_cell_fn, units=units, cell_type=cell_type,\n return_sequences=return_sequences)\n\n\n@test_util.run_all_in_graph_and_eager_modes\nclass RNNLayerFnTest(test.TestCase, parameterized.TestCase):\n \"\"\"Tests for rnn layer function.\"\"\"\n\n def testWrongClassProvided(self):\n \"\"\"Tests that an error is raised if the class doesn't have a call method.\"\"\"\n with self.assertRaisesRegexp(\n ValueError,\n 'RNN cell should have a `call` and `state_size` method.'):\n _make_rnn_layer(units=[10], cell_type=lambda units: object())\n\n def testWrongStringProvided(self):\n \"\"\"Tests that an error is raised if cell type is unknown.\"\"\"\n with self.assertRaisesRegexp(\n ValueError,\n 'cell_type` should be a class producing a RNN cell, or a string .*.'):\n _make_rnn_layer(units=[10], cell_type='unknown-cell-name')\n\n @parameterized.parameters(['simple_rnn', rnn.USE_DEFAULT])\n def testDefaultCellProvided(self, cell_type):\n \"\"\"Tests behavior when the default cell type is provided.\"\"\"\n layer = _make_rnn_layer(cell_type=cell_type, units=[1])\n self.assertIsInstance(layer, keras_layers.RNN)\n self.assertIsInstance(layer.cell, keras_layers.SimpleRNNCell)\n\n @parameterized.parameters([('gru', recurrent_v2.GRU),\n ('lstm', recurrent_v2.LSTM),\n ('simple_rnn', keras_layers.SimpleRNN)])\n def testSpecificLayerTypeProvided(self, cell_type, layer_type):\n \"\"\"Tests specific layer type for GRU and LSTM.\"\"\"\n layer = _make_rnn_layer(cell_type=cell_type, units=1)\n self.assertIsInstance(layer, layer_type)\n\n def testSpecificLayerTypeArguments(self):\n \"\"\"Tests arguments for specific layer types (GRU and LSTM).\"\"\"\n mock_layer_type = test.mock.Mock()\n with test.mock.patch.object(\n rnn, '_CELL_TYPE_TO_LAYER_MAPPING', {'custom-type': mock_layer_type}):\n _make_rnn_layer(\n cell_type='custom-type', units=11,\n return_sequences='return-seq-value')\n mock_layer_type.assert_called_once_with(\n units=11, return_sequences='return-seq-value')\n\n @test.mock.patch.object(keras_layers, 'RNN')\n def testCustomCellProvided(self, mock_rnn_layer_type):\n \"\"\"Tests behavior when a custom cell type is provided.\"\"\"\n mock_custom_cell = test.mock.Mock()\n _make_rnn_layer(\n units=[10], cell_type=lambda units: mock_custom_cell,\n return_sequences='return-seq-value')\n mock_rnn_layer_type.assert_called_once_with(\n cell=mock_custom_cell, return_sequences='return-seq-value')\n\n def testMultipleCellsProvided(self):\n \"\"\"Tests behavior when multiple cells are provided.\"\"\"\n layer = _make_rnn_layer(cell_type='simple_rnn', units=[1, 2])\n self.assertIsInstance(layer, keras_layers.RNN)\n self.assertIsInstance(layer.cell, keras_layers.StackedRNNCells)\n self.assertLen(layer.cell.cells, 2)\n self.assertIsInstance(layer.cell.cells[0], keras_layers.SimpleRNNCell)\n\n @test.mock.patch.object(keras_layers, 'RNN')\n def testCustomCellFnProvided(self, mock_rnn_layer_type):\n \"\"\"Tests behavior when a custom cell function is provided.\"\"\"\n mock_cell_fn = test.mock.Mock(return_value='custom-cell')\n _make_rnn_layer(\n rnn_cell_fn=mock_cell_fn, return_sequences='return-seq-value')\n mock_rnn_layer_type.assert_called_once_with(\n cell='custom-cell', return_sequences='return-seq-value')\n\n\ndef _mock_logits_layer(kernel, bias):\n \"\"\"Sets initialization values to dense `logits` layers used in context.\"\"\"\n\n class _MockDenseLayer(keras_layers.Dense):\n\n def __init__(self, units, activation, name):\n kwargs = {}\n if name == 'logits':\n kwargs = {\n 'kernel_initializer': initializers.Constant(kernel),\n 'bias_initializer': initializers.Constant(bias)}\n\n super(_MockDenseLayer, self).__init__(\n units=units, name=name, activation=activation, **kwargs)\n\n return test.mock.patch.object(keras_layers, 'Dense', _MockDenseLayer)\n\n\ndef _default_features_fn():\n return {\n 'price':\n sparse_tensor.SparseTensor(\n values=[10., 5.],\n indices=[[0, 0], [0, 1]],\n dense_shape=[1, 2]),\n }\n\n\ndef _get_mock_head():\n mock_head = multi_head_lib.MultiClassHead(3)\n mock_head.create_estimator_spec = test.mock.Mock(\n return_value=model_fn.EstimatorSpec(None))\n return mock_head\n\n\n@test_util.run_all_in_graph_and_eager_modes\nclass RNNLogitFnTest(test.TestCase, parameterized.TestCase):\n \"\"\"Tests correctness of logits calculated from RNNModel.\"\"\"\n\n def setUp(self):\n # Sets layers default weights for testing purpose.\n self.kernel = [[.1, -.2]]\n self.recurrent = [[.2, -.3], [.3, -.4]]\n self.bias = [.2, .5]\n self.dense_kernel = [[-1.], [1.]]\n self.dense_bias = [0.3]\n self.sequence_feature_columns = [\n fc.sequence_numeric_column('price', shape=(1,))]\n self.context_feature_columns = []\n super(RNNLogitFnTest, self).setUp()\n\n def _mock_logits_layer(self):\n return _mock_logits_layer(self.dense_kernel, bias=self.dense_bias)\n\n def _test_logits(self, logits_dimension, features_fn, expected_logits,\n expected_mask, return_sequences=False):\n \"\"\"Tests that the expected logits are calculated.\"\"\"\n rnn_layer = keras_layers.SimpleRNN(\n 2, return_sequences=return_sequences,\n kernel_initializer=initializers.Constant(self.kernel),\n recurrent_initializer=initializers.Constant(self.recurrent),\n bias_initializer=initializers.Constant(self.bias))\n with self._mock_logits_layer():\n logit_layer = rnn.RNNModel(\n rnn_layer=rnn_layer,\n units=logits_dimension,\n sequence_feature_columns=self.sequence_feature_columns,\n context_feature_columns=self.context_feature_columns,\n return_sequences=return_sequences)\n logits = logit_layer(features_fn())\n if return_sequences:\n logits = (logits, logits._keras_mask)\n expected_logits = (expected_logits, expected_mask)\n self.evaluate(variables_lib.global_variables_initializer())\n self.assertAllClose(expected_logits, self.evaluate(logits), atol=1e-4)\n\n @parameterized.named_parameters(\n {'testcase_name': 'Static',\n 'return_sequences': False,\n 'expected_logits': [[-0.6033]]},\n {'testcase_name': 'Sequential',\n 'return_sequences': True,\n 'expected_logits': [[[-1.4388], [-0.6033]]]})\n def testOneDimLogits(self, return_sequences, expected_logits):\n \"\"\"Tests one-dimensional logits.\n\n Intermediate values are rounded for ease in reading.\n input_layer = [[[10]], [[5]]]\n sequence_mask = [[1, 1]]\n initial_state = [0, 0]\n rnn_output_timestep_1 = [[tanh(.1*10 + .2*0 + .3*0 +.2),\n tanh(-.2*10 - .3*0 - .4*0 +.5)]]\n = [[0.83, -0.91]]\n rnn_output_timestep_2 = [[tanh(.1*5 + .2*.83 - .3*.91 +.2),\n tanh(-.2*5 - .3*.83 + .4*.91 +.5)]]\n = [[0.53, -0.37]]\n logits_timestep_1 = [[-1*0.83 - 1*0.91 + 0.3]] = [[-1.4388]]\n logits_timestep_2 = [[-1*0.53 - 1*0.37 + 0.3]] = [[-0.6033]]\n\n Args:\n return_sequences: A boolean indicating whether to return the last output\n in the output sequence, or the full sequence.\n expected_logits: An array with expected logits result.\n \"\"\"\n expected_mask = [[1, 1]]\n\n self._test_logits(\n logits_dimension=1,\n features_fn=_default_features_fn,\n expected_mask=expected_mask,\n expected_logits=expected_logits,\n return_sequences=return_sequences)\n\n @parameterized.named_parameters(\n {'testcase_name': 'Static',\n 'return_sequences': False,\n 'expected_logits': [[-0.6033, 0.7777, 0.5698]]},\n {'testcase_name': 'Sequential',\n 'return_sequences': True,\n 'expected_logits': [[\n [-1.4388, 1.0884, 0.5762],\n [-0.6033, 0.7777, 0.5698]]]})\n def testMultiDimLogits(self, return_sequences, expected_logits):\n \"\"\"Tests multi-dimensional logits.\n\n Intermediate values are rounded for ease in reading.\n input_layer = [[[10]], [[5]]]\n sequence_mask = [[1, 1]]\n initial_state = [0, 0]\n rnn_output_timestep_1 = [[tanh(.1*10 + .2*0 + .3*0 +.2),\n tanh(-.2*10 - .3*0 - .4*0 +.5)]]\n = [[0.83, -0.91]]\n rnn_output_timestep_2 = [[tanh(.1*5 + .2*.83 - .3*.91 +.2),\n tanh(-.2*5 - .3*.83 + .4*.91 +.5)]]\n = [[0.53, -0.37]]\n logits_timestep_1 = [[-1*0.83 - 1*0.91 + 0.3],\n [0.5*0.83 + 0.3*0.91 + 0.4],\n [0.2*0.83 - 0.1*0.91 + 0.5]]\n = [[-1.4388, 1.0884, 0.5762]]\n logits_timestep_2 = [[-1*0.53 - 1*0.37 + 0.3],\n [0.5*0.53 + 0.3*0.37 + 0.4],\n [0.2*0.53 - 0.1*0.37 + 0.5]]\n = [[-0.6033, 0.7777, 0.5698]]\n\n Args:\n return_sequences: A boolean indicating whether to return the last output\n in the output sequence, or the full sequence.\n expected_logits: An array with expected logits result.\n \"\"\"\n expected_mask = [[1, 1]]\n\n self.dense_kernel = [[-1., 0.5, 0.2], [1., -0.3, 0.1]]\n self.dense_bias = [0.3, 0.4, 0.5]\n self._test_logits(\n logits_dimension=3,\n features_fn=_default_features_fn,\n expected_mask=expected_mask,\n expected_logits=expected_logits,\n return_sequences=return_sequences)\n\n @parameterized.named_parameters(\n {'testcase_name': 'Static',\n 'return_sequences': False,\n 'expected_logits': [[-0.6033, 0.7777, 0.5698],\n [-1.2473, 1.0170, 0.5745]]},\n {'testcase_name': 'Sequential',\n 'return_sequences': True,\n 'expected_logits': [[[-1.4388, 1.0884, 0.5762],\n [-0.6033, 0.7777, 0.5698]],\n [[0.0197, 0.5601, 0.5860],\n [-1.2473, 1.0170, 0.5745]]]})\n def testMultiExampleMultiDim(self, return_sequences, expected_logits):\n \"\"\"Tests multiple examples and multi-dimensional logits.\n\n Intermediate values are rounded for ease in reading.\n input_layer = [[[10], [5]], [[2], [7]]]\n sequence_mask = [[1, 1], [1, 1]]\n initial_state = [[0, 0], [0, 0]]\n rnn_output_timestep_1 = [[tanh(.1*10 + .2*0 + .3*0 +.2),\n tanh(-.2*10 - .3*0 - .4*0 +.5)],\n [tanh(.1*2 + .2*0 + .3*0 +.2),\n tanh(-.2*2 - .3*0 - .4*0 +.5)]]\n = [[0.83, -0.91], [0.38, 0.10]]\n rnn_output_timestep_2 = [[tanh(.1*5 + .2*.83 - .3*.91 +.2),\n tanh(-.2*5 - .3*.83 + .4*.91 +.5)],\n [tanh(.1*7 + .2*.38 + .3*.10 +.2),\n tanh(-.2*7 - .3*.38 - .4*.10 +.5)]]\n = [[0.53, -0.37], [0.76, -0.78]\n logits_timestep_1 = [[-1*0.83 - 1*0.91 + 0.3,\n 0.5*0.83 + 0.3*0.91 + 0.4,\n 0.2*0.83 - 0.1*0.91 + 0.5],\n [-1*0.38 + 1*0.10 + 0.3,\n 0.5*0.38 - 0.3*0.10 + 0.4,\n 0.2*0.38 + 0.1*0.10 + 0.5]]\n = [[-1.4388, 1.0884, 0.5762], [0.0197, 0.5601, 0.5860]]\n logits_timestep_2 = [[-1*0.53 - 1*0.37 + 0.3,\n 0.5*0.53 + 0.3*0.37 + 0.4,\n 0.2*0.53 - 0.1*0.37 + 0.5],\n [-1*0.76 - 1*0.78 + 0.3,\n 0.5*0.76 +0.3*0.78 + 0.4,\n 0.2*0.76 -0.1*0.78 + 0.5]]\n = [[-0.6033, 0.7777, 0.5698], [-1.2473, 1.0170, 0.5745]]\n\n Args:\n return_sequences: A boolean indicating whether to return the last output\n in the output sequence, or the full sequence.\n expected_logits: An array with expected logits result.\n \"\"\"\n expected_mask = [[1, 1], [1, 1]]\n\n def features_fn():\n return {\n 'price':\n sparse_tensor.SparseTensor(\n values=[10., 5., 2., 7.],\n indices=[[0, 0], [0, 1], [1, 0], [1, 1]],\n dense_shape=[2, 2]),\n }\n\n self.dense_kernel = [[-1., 0.5, 0.2], [1., -0.3, 0.1]]\n self.dense_bias = [0.3, 0.4, 0.5]\n self._test_logits(\n logits_dimension=3,\n features_fn=features_fn,\n expected_mask=expected_mask,\n expected_logits=expected_logits,\n return_sequences=return_sequences)\n\n @parameterized.named_parameters(\n {'testcase_name': 'Static',\n 'return_sequences': False,\n 'expected_logits': [[-0.6033], [0.0197]]},\n {'testcase_name': 'Sequential',\n 'return_sequences': True,\n 'expected_logits': [[[-1.4388], [-0.6033]],\n [[0.0197], [0.0197]]]})\n def testMultiExamplesDifferentLength(self, return_sequences, expected_logits):\n \"\"\"Tests multiple examples with different lengths.\n\n Intermediate values are rounded for ease in reading.\n input_layer = [[[10], [5]], [[2], [0]]]\n sequence_mask = [[1, 1], [1, 0]]\n initial_state = [[0, 0], [0, 0]]\n rnn_output_timestep_1 = [[tanh(.1*10 + .2*0 + .3*0 +.2),\n tanh(-.2*10 - .3*0 - .4*0 +.5)],\n [tanh(.1*2 + .2*0 + .3*0 +.2),\n tanh(-.2*2 - .3*0 - .4*0 +.5)]]\n = [[0.83, -0.91], [0.38, 0.10]]\n rnn_output_timestep_2 = [[tanh(.1*5 + .2*.83 - .3*.91 +.2),\n tanh(-.2*5 - .3*.83 + .4*.91 +.5)],\n [_]]\n = [[0.53, -0.37], [_, _]]\n logits_timestep_1 = [[-1*0.83 - 1*0.91 + 0.3],\n [-1*0.38 + 1*0.10 + 0.3]]\n = [[-0.4388], [0.0197]]\n logits_timestep_2 = [[-1*0.53 - 1*0.37 + 0.3],\n [_]]\n = [[-0.6033], [_]]\n\n Args:\n return_sequences: A boolean indicating whether to return the last output\n in the output sequence, or the full sequence.\n expected_logits: An array with expected logits result.\n \"\"\"\n expected_mask = [[1, 1], [1, 0]]\n\n def features_fn():\n return {\n 'price':\n sparse_tensor.SparseTensor(\n values=[10., 5., 2.],\n indices=[[0, 0], [0, 1], [1, 0]],\n dense_shape=[2, 2]),\n }\n\n self._test_logits(\n logits_dimension=1,\n features_fn=features_fn,\n expected_mask=expected_mask,\n expected_logits=expected_logits,\n return_sequences=return_sequences)\n\n def testMultiExamplesWithContext(self):\n \"\"\"Tests multiple examples with context features.\n\n Intermediate values are rounded for ease in reading.\n input_layer = [[[10, -0.5], [5, -0.5]], [[2, 0.8], [0, 0]]]\n sequence_mask = [[1, 1], [1, 0]]\n initial_state = [[0, 0], [0, 0]]\n rnn_output_timestep_1 = [[tanh(.1*10 - 1*.5 + .2*0 + .3*0 +.2),\n tanh(-.2*10 - 0.9*.5 - .3*0 - .4*0 +.5)],\n [tanh(.1*2 + 1*.8 + .2*0 + .3*0 +.2),\n tanh(-.2*2 + .9*.8 - .3*0 - .4*0 +.5)]]\n = [[0.60, -0.96], [0.83, 0.68]]\n rnn_output_timestep_2 = [[tanh(.1*5 - 1*.5 + .2*.60 - .3*.96 +.2),\n tanh(-.2*5 - .9*.5 - .3*.60 + .4*.96 +.5)],\n [<ignored-padding>]]\n = [[0.03, -0.63], [<ignored-padding>]]\n logits = [[-1*0.03 - 1*0.63 + 0.3],\n [-1*0.83 + 1*0.68 + 0.3]]\n = [[-0.3662], [0.1414]]\n \"\"\"\n expected_mask = [[1, 1], [1, 0]]\n\n def features_fn():\n return {\n 'price':\n sparse_tensor.SparseTensor(\n values=[10., 5., 2.],\n indices=[[0, 0], [0, 1], [1, 0]],\n dense_shape=[2, 2]),\n 'context': [[-0.5], [0.8]],\n }\n\n self.context_feature_columns = [fc.numeric_column('context', shape=(1,))]\n\n self.kernel = [[.1, -.2], [1., 0.9]]\n self._test_logits(\n logits_dimension=1,\n features_fn=features_fn,\n expected_mask=expected_mask,\n expected_logits=[[-0.3662], [0.1414]])\n\n def testMultiExamplesMultiFeatures(self):\n \"\"\"Tests examples with multiple sequential feature columns.\n\n Intermediate values are rounded for ease in reading.\n input_layer = [[[1, 0, 10], [0, 1, 5]], [[1, 0, 2], [0, 0, 0]]]\n sequence_mask = [[1, 1], [1, 0]]\n initial_state = [[0, 0], [0, 0]]\n rnn_output_timestep_1 = [[tanh(.5*1 + 1*0 + .1*10 + .2*0 + .3*0 +.2),\n tanh(-.5*1 - 1*0 - .2*10 - .3*0 - .4*0 +.5)],\n [tanh(.5*1 + 1*0 + .1*2 + .2*0 + .3*0 +.2),\n tanh(-.5*1 - 1*0 - .2*2 - .3*0 - .4*0 +.5)]]\n = [[0.94, -0.96], [0.72, -0.38]]\n rnn_output_timestep_2 = [[tanh(.5*0 + 1*1 + .1*5 + .2*.94 - .3*.96 +.2),\n tanh(-.5*0 - 1*1 - .2*5 - .3*.94 + .4*.96 +.5)],\n [<ignored-padding>]]\n = [[0.92, -0.88], [<ignored-padding>]]\n logits = [[-1*0.92 - 1*0.88 + 0.3],\n [-1*0.72 - 1*0.38 + 0.3]]\n = [[-1.5056], [-0.7962]]\n \"\"\"\n expected_mask = [[1, 1], [1, 0]]\n\n def features_fn():\n return {\n 'price':\n sparse_tensor.SparseTensor(\n values=[10., 5., 2.],\n indices=[[0, 0], [0, 1], [1, 0]],\n dense_shape=[2, 2]),\n 'on_sale':\n sparse_tensor.SparseTensor(\n values=[0, 1, 0],\n indices=[[0, 0], [0, 1], [1, 0]],\n dense_shape=[2, 2]),\n }\n\n price_column = fc.sequence_numeric_column('price', shape=(1,))\n on_sale_column = fc.indicator_column(\n fc.sequence_categorical_column_with_identity('on_sale', num_buckets=2))\n self.sequence_feature_columns = [price_column, on_sale_column]\n\n self.kernel = [[.5, -.5], [1., -1.], [.1, -.2]]\n self._test_logits(\n logits_dimension=1,\n features_fn=features_fn,\n expected_mask=expected_mask,\n expected_logits=[[-1.5056], [-0.7962]])\n\n @parameterized.parameters([\n (model_fn.ModeKeys.TRAIN, True),\n (model_fn.ModeKeys.EVAL, False),\n (model_fn.ModeKeys.PREDICT, False)])\n def testTrainingMode(self, mode, expected_training_mode):\n \"\"\"Tests that `training` argument is properly used.\"\"\"\n\n class _MockRNNCell(keras_layers.SimpleRNNCell):\n \"\"\"Used to test that `training` argument is properly used.\"\"\"\n\n def __init__(self, test_case):\n self._test_case = test_case\n super(_MockRNNCell, self).__init__(units=10)\n\n def call(self, inputs, states, training=None):\n self._test_case.assertEqual(training, expected_training_mode)\n return super(_MockRNNCell, self).call(\n inputs=inputs, states=states, training=training)\n\n estimator = rnn.RNNEstimator(\n head=_get_mock_head(),\n rnn_cell_fn=lambda: _MockRNNCell(self),\n sequence_feature_columns=self.sequence_feature_columns)\n features = {\n 'price':\n sparse_tensor.SparseTensor(\n values=[10.,],\n indices=[[0, 0]],\n dense_shape=[1, 1]),\n }\n estimator.model_fn(features=features, labels=None, mode=mode, config=None)\n\n\nclass RNNModelTest(test.TestCase, parameterized.TestCase):\n \"\"\"Tests for RNNModel.\"\"\"\n\n def setUp(self):\n super(RNNModelTest, self).setUp()\n self.kernel = [[.1, -.2]]\n self.recurrent = [[.2, -.3], [.3, -.4]]\n self.bias = [.2, .5]\n self.dense_kernel = [[-1.], [1.]]\n self.dense_bias = [0.3]\n self.sequence_feature_columns = [\n fc.sequence_numeric_column('price', shape=(1,))]\n self.x = {\n 'price':\n sparse_tensor.SparseTensor(\n values=[10., 5., 2.],\n indices=[[0, 0], [0, 1], [1, 0]],\n dense_shape=[2, 2]),\n }\n self.y = ops.convert_to_tensor([[[0], [1]], [[0], [1]]])\n\n def _get_compiled_model(\n self, return_sequences=False, optimizer='Adam', **kwargs):\n \"\"\"Initializes and compiles a RNN model with specific weights.\"\"\"\n rnn_layer = keras_layers.SimpleRNN(\n 2, return_sequences=return_sequences,\n kernel_initializer=initializers.Constant(self.kernel),\n recurrent_initializer=initializers.Constant(self.recurrent),\n bias_initializer=initializers.Constant(self.bias))\n with _mock_logits_layer(self.dense_kernel, bias=self.dense_bias):\n model = rnn.RNNModel(\n units=1,\n rnn_layer=rnn_layer,\n sequence_feature_columns=self.sequence_feature_columns,\n activation=activations.sigmoid,\n return_sequences=return_sequences,\n **kwargs)\n model.compile(\n optimizer=optimizer,\n loss=losses.BinaryCrossentropy(reduction='sum'),\n metrics=['accuracy'])\n return model\n\n def testModelWeights(self):\n \"\"\"Tests that the layers weights are properly added to the model weights.\"\"\"\n col = fc.categorical_column_with_hash_bucket('tokens', hash_bucket_size=1)\n context_feature_columns = [fc.embedding_column(col, dimension=1)]\n seq_col = fc.sequence_categorical_column_with_hash_bucket(\n 'seq-tokens', hash_bucket_size=1)\n self.sequence_feature_columns = [fc.embedding_column(seq_col, dimension=1)]\n model = self._get_compiled_model(\n context_feature_columns=context_feature_columns)\n model.predict(x={\n 'tokens': ops.convert_to_tensor([['a']]),\n 'seq-tokens': ops.convert_to_tensor([[['a']]])}, steps=1)\n # Weights included are:\n # - recurrent, kernel and bias from RNN layer\n # - kernel and bias from logits layer\n # - sequential feature column embedding\n # - context feature column embedding.\n self.assertLen(model.get_weights(), 7)\n\n def _testModelConfig(self, **kwargs):\n \"\"\"Tests the parameters of a RNNModel stored to and restored from config.\n\n Args:\n **kwargs: Additional keyword arguments to initialize the RNNModel before\n calling `get_config`.\n\n Returns:\n A dictionary with RNNModel initialization arguments from the `from_config`\n call.\n \"\"\"\n seq_col = fc.sequence_categorical_column_with_hash_bucket(\n 'seq-tokens', hash_bucket_size=1)\n sequence_feature_columns = [fc.embedding_column(\n seq_col, dimension=1, initializer=initializers.Zeros())]\n model = rnn.RNNModel(\n units=11,\n rnn_layer=keras_layers.SimpleRNN(3),\n sequence_feature_columns=sequence_feature_columns,\n return_sequences=True,\n name='rnn-model',\n **kwargs)\n\n with test.mock.patch.object(\n rnn.RNNModel, '__init__', return_value=None) as init:\n rnn.RNNModel.from_config(\n model.get_config(), custom_objects={'Zeros': initializers.Zeros})\n return list(init.call_args_list[0])[1]\n\n def testModelConfig(self):\n \"\"\"Tests that a RNNModel can be stored to and restored from config.\"\"\"\n init_kwargs = self._testModelConfig()\n self.assertEqual(init_kwargs['name'], 'rnn-model')\n self.assertEqual(init_kwargs['units'], 11)\n self.assertEqual(init_kwargs['return_sequences'], True)\n self.assertEqual(\n init_kwargs['sequence_feature_columns'][0].categorical_column.name,\n 'seq-tokens')\n self.assertEqual(init_kwargs['context_feature_columns'], None)\n self.assertEqual(init_kwargs['activation'].__name__, 'linear')\n self.assertEqual(init_kwargs['rnn_layer'].cell.units, 3)\n\n def testModelConfigWithActivation(self):\n \"\"\"Tests store / restore from config with logits activation.\"\"\"\n init_kwargs = self._testModelConfig(activation=activations.sigmoid)\n self.assertEqual(init_kwargs['activation'].__name__, 'sigmoid')\n\n def testModelConfigWithContextFeatures(self):\n \"\"\"Tests store / restore from config with context features.\"\"\"\n init_kwargs = self._testModelConfig(\n context_feature_columns=[fc.numeric_column('context', shape=(1,))])\n self.assertEqual(init_kwargs['context_feature_columns'][0].name, 'context')\n\n def DISABLED_testSaveModelWeights(self): # See b/129842600.\n \"\"\"Tests that model weights can be saved and restored.\"\"\"\n model = self._get_compiled_model(return_sequences=True)\n model.fit(x=self.x, y=self.y, batch_size=1, steps_per_epoch=1, epochs=1)\n y1 = model.predict(x=self.x, steps=1)\n model.save_weights(self.get_temp_dir() + 'model')\n\n model = self._get_compiled_model(return_sequences=True, name='model-2')\n model.load_weights(self.get_temp_dir() + 'model')\n y2 = model.predict(x=self.x, steps=1)\n self.assertAllClose(y1, y2)\n\n def DISABLED_testEvaluationMetrics(self): # See b/129842600.\n \"\"\"Tests evaluation metrics computation in non-sequential case.\"\"\"\n model = self._get_compiled_model()\n metrics = model.evaluate(\n x=self.x, y=ops.convert_to_tensor([[0], [1]]), steps=1)\n # See `RNNClassifierEvaluationTest` for details on computation.\n self.assertAllClose(metrics, (1.1196611, 1.), atol=1e-4)\n\n def DISABLED_testEvaluationSequential(self): # See b/129842600.\n \"\"\"Tests that the sequence mask is properly used to aggregate loss.\"\"\"\n model = self._get_compiled_model(return_sequences=True)\n metrics = model.evaluate(x=self.x, y=self.y, steps=1)\n # See `RNNClassifierEvaluationTest` for details on computation.\n self.assertAllClose(metrics, (1.9556, 1./3.), atol=1e-4)\n\n def DISABLED_testPredictions(self): # See b/129842600.\n \"\"\"Tests predictions with RNN model.\"\"\"\n model = self._get_compiled_model()\n # See `RNNClassifierPredictionTest` for details on computation.\n self.assertAllClose(\n model.predict(x=self.x, steps=1), [[0.353593], [0.5049296]], atol=1e-4)\n\n def DISABLED_testPredictionsSequential(self): # See b/129842600.\n \"\"\"Tests sequential predictions with RNN model.\"\"\"\n model = self._get_compiled_model(return_sequences=True)\n # See `RNNClassifierPredictionTest` for details on computation.\n self.assertAllClose(\n model.predict(x=self.x, steps=1),\n [[[0.191731], [0.353593]],\n [[0.5049296], [0.5049296]]], atol=1e-4)\n\n @parameterized.named_parameters(\n ('StringOptimizer', 'Adam'), ('OptimizerInstance', adam.Adam()))\n def DISABLED_testTraining(self, optimizer): # See b/129842600.\n \"\"\"Tests the loss computed in training step.\"\"\"\n model = self._get_compiled_model(optimizer=optimizer)\n history = model.fit(\n x=self.x, y=ops.convert_to_tensor([[0], [1]]), batch_size=1,\n steps_per_epoch=1)\n # See `RNNClassifierTrainingTest` for details on computation.\n self.assertAllClose(history.history['loss'], [1.1196611], atol=1e-4)\n\n def DISABLED_testTrainingSequential(self): # See b/129842600.\n \"\"\"Tests the loss computed in training step in sequential case.\"\"\"\n model = self._get_compiled_model(return_sequences=True)\n history = model.fit(x=self.x, y=self.y, batch_size=1, steps_per_epoch=1)\n # See `RNNClassifierTrainingTest` for details on computation.\n self.assertAllClose(history.history['loss'], [1.9556], atol=1e-4)\n\n\n@test_util.run_all_in_graph_and_eager_modes\nclass RNNEstimatorInitTest(test.TestCase):\n\n def setUp(self):\n col = fc.sequence_categorical_column_with_hash_bucket(\n 'tokens', hash_bucket_size=10)\n self.feature_columns = [fc.embedding_column(col, dimension=2)]\n self.cell_units = [4, 2]\n super(RNNEstimatorInitTest, self).setUp()\n\n def testConflictingRNNCellFn(self):\n with self.assertRaisesRegexp(\n ValueError,\n 'units and cell_type must not be specified when using rnn_cell_fn'):\n rnn.RNNClassifier(\n sequence_feature_columns=self.feature_columns,\n rnn_cell_fn=lambda: 'mock-cell',\n units=self.cell_units)\n\n with self.assertRaisesRegexp(\n ValueError,\n 'units and cell_type must not be specified when using rnn_cell_fn'):\n rnn.RNNClassifier(\n sequence_feature_columns=self.feature_columns,\n rnn_cell_fn=lambda: 'mock-cell',\n cell_type='lstm')\n\n def testNonSequentialHeadProvided(self):\n with self.assertRaisesRegexp(\n ValueError,\n 'Provided head must be a `_SequentialHead` object when '\n '`return_sequences` is set to True.'):\n rnn.RNNEstimator(\n head=multi_head_lib.MultiClassHead(n_classes=3),\n sequence_feature_columns=self.feature_columns,\n return_sequences=True)\n\n def testWrongOptimizerTypeProvided(self):\n classifier = rnn.RNNClassifier(\n self.feature_columns, units=[1], optimizer=object())\n with self.assertRaisesRegexp(\n ValueError,\n 'The given object is not a tf.keras.optimizers.Optimizer instance.'):\n classifier.model_fn(\n features=None, labels=None, mode=model_fn.ModeKeys.TRAIN, config=None)\n\n\n@test_util.run_all_in_graph_and_eager_modes\nclass RNNClassifierTrainingTest(test.TestCase):\n\n def setUp(self):\n self.kernel = [[.1, -.2]]\n self.recurrent = [[.2, -.3], [.3, -.4]]\n self.bias = [.2, .5]\n self.dense_kernel = [[-1.], [1.]]\n self.dense_bias = [0.3]\n self.sequence_feature_columns = [\n fc.sequence_numeric_column('price', shape=(1,))]\n super(RNNClassifierTrainingTest, self).setUp()\n\n def _assert_checkpoint(\n self, n_classes, input_units, cell_units, expected_global_step):\n\n shapes = {\n name: shape for (name, shape) in\n checkpoint_utils.list_variables(self.get_temp_dir())\n }\n\n self.assertEqual([], shapes[ops.GraphKeys.GLOBAL_STEP])\n self.assertEqual(\n expected_global_step,\n checkpoint_utils.load_variable(\n self.get_temp_dir(), ops.GraphKeys.GLOBAL_STEP))\n\n # RNN Cell variables.\n for i, cell_unit in enumerate(cell_units):\n name_suffix = '_%d' % i if i else ''\n self.assertEqual([input_units, cell_unit],\n shapes[CELL_KERNEL_NAME + name_suffix])\n self.assertEqual([cell_unit, cell_unit],\n shapes[CELL_RECURRENT_KERNEL_NAME + name_suffix])\n self.assertEqual([cell_unit],\n shapes[CELL_BIAS_NAME + name_suffix])\n input_units = cell_unit\n\n # Logits variables.\n logits_dimension = n_classes if n_classes > 2 else 1\n self.assertEqual([cell_units[-1], logits_dimension],\n shapes[LOGITS_WEIGHTS_NAME])\n self.assertEqual([logits_dimension], shapes[LOGITS_BIAS_NAME])\n\n def _mock_optimizer(self, expected_loss=None):\n var_names = (CELL_BIAS_NAME, CELL_KERNEL_NAME, CELL_RECURRENT_KERNEL_NAME,\n LOGITS_BIAS_NAME, LOGITS_WEIGHTS_NAME)\n expected_var_names = ['%s:0' % name for name in var_names]\n\n class _Optimizer(optimizer_v2.OptimizerV2):\n \"\"\"Mock optimizer checking that loss has the proper value.\"\"\"\n\n def __init__(self, test_case):\n super(_Optimizer, self).__init__(name='my-optimizer')\n self.call_count = 0\n self._test_case = test_case\n\n def get_updates(self, loss, params):\n self.call_count += 1\n trainable_vars = ops.get_collection(ops.GraphKeys.TRAINABLE_VARIABLES)\n self._test_case.assertItemsEqual(\n expected_var_names,\n [var.name for var in trainable_vars])\n\n # Verify loss. We can't check the value directly so we add an assert op.\n self._test_case.assertEquals(0, loss.shape.ndims)\n if expected_loss is None:\n return [self.iterations.assign_add(1).op]\n assert_loss = _assert_close(\n math_ops.to_float(expected_loss, name='expected'),\n loss,\n name='assert_loss')\n with ops.control_dependencies((assert_loss,)):\n return [self.iterations.assign_add(1).op]\n\n def get_config(self):\n pass\n\n return _Optimizer(test_case=self)\n\n def _testFromScratchWithDefaultOptimizer(self, n_classes):\n def train_input_fn():\n return {\n 'tokens':\n sparse_tensor.SparseTensor(\n values=['the', 'cat', 'sat'],\n indices=[[0, 0], [0, 1], [0, 2]],\n dense_shape=[1, 3]),\n }, [[1]]\n\n col = fc.sequence_categorical_column_with_hash_bucket(\n 'tokens', hash_bucket_size=10)\n embed = fc.embedding_column(col, dimension=2)\n input_units = 2\n\n cell_units = [4, 2]\n est = rnn.RNNClassifier(\n sequence_feature_columns=[embed],\n units=cell_units,\n n_classes=n_classes,\n model_dir=self.get_temp_dir())\n\n # Train for a few steps, and validate final checkpoint.\n num_steps = 10\n est.train(input_fn=train_input_fn, steps=num_steps)\n self._assert_checkpoint(n_classes, input_units, cell_units, num_steps)\n\n def testBinaryClassFromScratchWithDefaultOptimizer(self):\n self._testFromScratchWithDefaultOptimizer(n_classes=2)\n\n def testMultiClassFromScratchWithDefaultOptimizer(self):\n self._testFromScratchWithDefaultOptimizer(n_classes=4)\n\n def testFromScratchWithCustomRNNCellFn(self):\n def train_input_fn():\n return {\n 'tokens':\n sparse_tensor.SparseTensor(\n values=['the', 'cat', 'sat'],\n indices=[[0, 0], [0, 1], [0, 2]],\n dense_shape=[1, 3]),\n }, [[1]]\n\n col = fc.sequence_categorical_column_with_hash_bucket(\n 'tokens', hash_bucket_size=10)\n embed = fc.embedding_column(col, dimension=2)\n input_units = 2\n cell_units = [4, 2]\n n_classes = 2\n\n def rnn_cell_fn():\n cells = [keras_layers.SimpleRNNCell(units=n) for n in cell_units]\n return keras_layers.StackedRNNCells(cells)\n\n est = rnn.RNNClassifier(\n sequence_feature_columns=[embed],\n rnn_cell_fn=rnn_cell_fn,\n n_classes=n_classes,\n model_dir=self.get_temp_dir())\n\n # Train for a few steps, and validate final checkpoint.\n num_steps = 10\n est.train(input_fn=train_input_fn, steps=num_steps)\n self._assert_checkpoint(n_classes, input_units, cell_units, num_steps)\n\n def _testExampleWeight(self, n_classes):\n def train_input_fn():\n return {\n 'tokens':\n sparse_tensor.SparseTensor(\n values=['the', 'cat', 'sat', 'dog', 'barked'],\n indices=[[0, 0], [0, 1], [0, 2], [1, 0], [1, 1]],\n dense_shape=[2, 3]),\n 'w': [[1], [2]],\n }, [[1], [0]]\n\n col = fc.sequence_categorical_column_with_hash_bucket(\n 'tokens', hash_bucket_size=10)\n embed = fc.embedding_column(col, dimension=2)\n input_units = 2\n\n cell_units = [4, 2]\n est = rnn.RNNClassifier(\n units=cell_units,\n sequence_feature_columns=[embed],\n n_classes=n_classes,\n weight_column='w',\n model_dir=self.get_temp_dir())\n\n # Train for a few steps, and validate final checkpoint.\n num_steps = 10\n est.train(input_fn=train_input_fn, steps=num_steps)\n self._assert_checkpoint(n_classes, input_units, cell_units, num_steps)\n\n def testBinaryClassWithExampleWeight(self):\n self._testExampleWeight(n_classes=2)\n\n def testMultiClassWithExampleWeight(self):\n self._testExampleWeight(n_classes=4)\n\n def _testFromCheckpoint(self, input_fn, expected_loss, **kwargs):\n \"\"\"Loads classifier from checkpoint, runs training and checks loss.\"\"\"\n create_checkpoint(\n kernel=self.kernel,\n recurrent=self.recurrent,\n bias=self.bias,\n dense_kernel=self.dense_kernel,\n dense_bias=self.dense_bias,\n global_step=100,\n model_dir=self.get_temp_dir())\n\n mock_optimizer = self._mock_optimizer(expected_loss=expected_loss)\n\n est = rnn.RNNClassifier(\n units=[2],\n sequence_feature_columns=self.sequence_feature_columns,\n optimizer=mock_optimizer,\n model_dir=self.get_temp_dir(),\n **kwargs)\n self.assertEqual(0, mock_optimizer.call_count)\n est.train(input_fn=input_fn, steps=10)\n self.assertEqual(1, mock_optimizer.call_count)\n\n def testBinaryClassFromCheckpoint(self):\n def train_input_fn():\n return {\n 'price':\n sparse_tensor.SparseTensor(\n values=[10., 5., 2.],\n indices=[[0, 0], [0, 1], [1, 0]],\n dense_shape=[2, 2]),\n }, [[0], [1]]\n\n # Uses same checkpoint and examples as testBinaryClassEvaluationMetrics.\n # See that test for loss calculation.\n self._testFromCheckpoint(train_input_fn, expected_loss=0.559831)\n\n def testMultiClassFromCheckpoint(self):\n def train_input_fn():\n return {\n 'price':\n sparse_tensor.SparseTensor(\n values=[10., 5., 2., 7.],\n indices=[[0, 0], [0, 1], [1, 0], [1, 1]],\n dense_shape=[2, 2]),\n }, [[0], [1]]\n\n # Uses same checkpoint and examples as testMultiClassEvaluationMetrics.\n # See that test for loss calculation.\n self.dense_kernel = [[-1., 0.5, 0.2], [1., -0.3, 0.1]]\n self.dense_bias = [0.3, 0.4, 0.5]\n self._testFromCheckpoint(\n train_input_fn, expected_loss=1.331465, n_classes=3)\n\n def testBinaryClassFromCheckpointSequential(self):\n def train_input_fn():\n return {\n 'price':\n sparse_tensor.SparseTensor(\n values=[10., 5., 2.],\n indices=[[0, 0], [0, 1], [1, 0]],\n dense_shape=[2, 2]),\n }, sparse_tensor.SparseTensor(\n values=[0, 1, 0],\n indices=[[0, 0], [0, 1], [1, 0]],\n dense_shape=[2, 2])\n\n # Same example as testBinaryClassEvaluationMetricsSequential.\n # logits = [[[-1.4388], [-0.6033]],\n # [[0.0197], [_]]]\n # probability = np.exp(logits) / (1 + np.exp(logits))\n # = [[0.1917, 0.3536],\n # [0.5049, _]]\n # loss = -label * ln(p) - (1 - label) * ln(1 - p)\n # loss = [[0.2129, 1.0396],\n # [0.7031, _]]\n # aggregated_loss = sum(loss) / 3\n # aggregated_loss = 0.6518\n self._testFromCheckpoint(\n train_input_fn, expected_loss=0.651841, return_sequences=True)\n\n def testBinaryClassFromCheckpointSequentialWithWeights(self):\n def train_input_fn():\n return {\n 'price':\n sparse_tensor.SparseTensor(\n values=[10., 5., 2.],\n indices=[[0, 0], [0, 1], [1, 0]],\n dense_shape=[2, 2]),\n 'weights':\n sparse_tensor.SparseTensor(\n values=[0., 0.5, 0.5],\n indices=[[0, 0], [0, 1], [1, 0]],\n dense_shape=[2, 2])\n }, sparse_tensor.SparseTensor(\n values=[0, 0, 1],\n indices=[[0, 0], [0, 1], [1, 0]],\n dense_shape=[2, 2])\n\n # Checkpoint and input are the same as testBinaryClassEvaluationMetrics, and\n # expected loss is the same as we use non-zero weights only for the last\n # step of each sequence.\n # loss = [[_, 0.436326],\n # [0.6833351, _]]\n # weights = [[0, 0.5], [0.5, 0]]\n # aggregated_loss = (0.436326 + 0.6833351) / 2.\n # = 0.559831\n self._testFromCheckpoint(\n train_input_fn, expected_loss=0.559831, return_sequences=True,\n weight_column='weights', loss_reduction=losses_utils.ReductionV2.SUM)\n\n def testDefaultGradientClipping(self):\n \"\"\"Tests that optimizer applies default gradient clipping value.\"\"\"\n def train_input_fn():\n return {\n 'price':\n sparse_tensor.SparseTensor(\n values=[1.,],\n indices=[[0, 0]],\n dense_shape=[1, 1]),\n }, [[1]]\n\n def _wrap_create_estimator_spec(create_estimator_spec):\n \"\"\"Wraps function and asserts that the optimizer applies clipping.\"\"\"\n def _wrapped_create_estimator_spec(\n obj, features, mode, logits, labels=None, optimizer=None,\n trainable_variables=None, train_op_fn=None, update_ops=None,\n regularization_losses=None):\n var = variables_lib.Variable([1.0])\n mock_loss = 10 * var\n gradients = optimizer.get_gradients(mock_loss, [var])\n self.assertLen(gradients, 1)\n # Initial gradient value is 10 and expected to be clipped to 5 (default\n # clipping value).\n with ops.control_dependencies((check_ops.assert_equal(\n gradients[0], 5.0),)):\n return create_estimator_spec(\n obj, features, mode, logits, labels, optimizer,\n trainable_variables, train_op_fn, update_ops,\n regularization_losses)\n\n return _wrapped_create_estimator_spec\n\n with test.mock.patch.object(\n multi_head_lib.MultiClassHead, 'create_estimator_spec',\n _wrap_create_estimator_spec(\n multi_head_lib.MultiClassHead.create_estimator_spec)):\n est = rnn.RNNClassifier(\n n_classes=3,\n sequence_feature_columns=[fc.sequence_numeric_column('price')],\n units=[2],\n model_dir=self.get_temp_dir())\n est.train(input_fn=train_input_fn, steps=1)\n\n\ndef sorted_key_dict(unsorted_dict):\n return {k: unsorted_dict[k] for k in sorted(unsorted_dict)}\n\n\n@test_util.run_all_in_graph_and_eager_modes\nclass RNNClassifierEvaluationTest(test.TestCase):\n\n def setUp(self):\n self.kernel = [[.1, -.2]]\n self.recurrent = [[.2, -.3], [.3, -.4]]\n self.bias = [.2, .5]\n self.dense_kernel = [[-1.], [1.]]\n self.dense_bias = [0.3]\n self.global_step = 100\n self.sequence_feature_columns = [\n fc.sequence_numeric_column('price', shape=(1,))]\n super(RNNClassifierEvaluationTest, self).setUp()\n\n def _testFromCheckpoint(self, input_fn, **kwargs):\n create_checkpoint(\n kernel=self.kernel,\n recurrent=self.recurrent,\n bias=self.bias,\n dense_kernel=self.dense_kernel,\n dense_bias=self.dense_bias,\n global_step=self.global_step,\n model_dir=self.get_temp_dir())\n\n est = rnn.RNNClassifier(\n units=[2],\n sequence_feature_columns=self.sequence_feature_columns,\n model_dir=self.get_temp_dir(),\n **kwargs)\n return est.evaluate(input_fn, steps=1)\n\n def testBinaryClassEvaluationMetrics(self):\n def eval_input_fn():\n return {\n 'price':\n sparse_tensor.SparseTensor(\n values=[10., 5., 2.],\n indices=[[0, 0], [0, 1], [1, 0]],\n dense_shape=[2, 2]),\n }, [[0], [1]]\n\n eval_metrics = self._testFromCheckpoint(eval_input_fn)\n\n # Uses identical numbers to testMultiExamplesWithDifferentLength.\n # See that test for logits calculation.\n # logits = [[-0.603282], [0.019719]]\n # probability = exp(logits) / (1 + exp(logits)) = [[0.353593], [0.504930]]\n # loss = -label * ln(p) - (1 - label) * ln(1 - p)\n # = [[0.436326], [0.683335]]\n # sum_over_batch_size = (0.436326 + 0.683335)/2\n expected_metrics = {\n ops.GraphKeys.GLOBAL_STEP: self.global_step,\n metric_keys.MetricKeys.LOSS: 0.559831,\n metric_keys.MetricKeys.LOSS_MEAN: 0.559831,\n metric_keys.MetricKeys.ACCURACY: 1.0,\n metric_keys.MetricKeys.PREDICTION_MEAN: 0.429262,\n metric_keys.MetricKeys.LABEL_MEAN: 0.5,\n metric_keys.MetricKeys.ACCURACY_BASELINE: 0.5,\n # With default threshold of 0.5, the model is a perfect classifier.\n metric_keys.MetricKeys.RECALL: 1.0,\n metric_keys.MetricKeys.PRECISION: 1.0,\n # Positive example is scored above negative, so AUC = 1.0.\n metric_keys.MetricKeys.AUC: 1.0,\n metric_keys.MetricKeys.AUC_PR: 1.0,\n }\n self.assertAllClose(\n sorted_key_dict(expected_metrics), sorted_key_dict(eval_metrics))\n\n def testBinaryClassEvaluationMetricsSequential(self):\n def eval_input_fn():\n return {\n 'price':\n sparse_tensor.SparseTensor(\n values=[10., 5., 2.],\n indices=[[0, 0], [0, 1], [1, 0]],\n dense_shape=[2, 2]),\n }, sparse_tensor.SparseTensor(\n values=[0, 1, 0],\n indices=[[0, 0], [0, 1], [1, 0]],\n dense_shape=[2, 2])\n\n eval_metrics = self._testFromCheckpoint(\n eval_input_fn, return_sequences=True)\n\n # logits = [[[-1.4388], [-0.6033]],\n # [[0.0197], [_]]]\n # probability = np.exp(logits) / (1 + np.exp(logits))\n # = [[0.1917, 0.3536],\n # [0.5049, _]]\n # labels = [[0, 1],\n # [0, _]]\n # loss = -label * ln(p) - (1 - label) * ln(1 - p)\n # loss = [[0.2129, 1.0396],\n # [0.7031, _]]\n # aggregated_loss = sum(loss) / 3\n # aggregated_loss = 0.6518\n # accuracy = 1/3\n # prediction_mean = mean(probability) = 0.3501\n expected_metrics = {\n ops.GraphKeys.GLOBAL_STEP: self.global_step,\n metric_keys.MetricKeys.LOSS: 0.651841,\n metric_keys.MetricKeys.LOSS_MEAN: 0.651841,\n metric_keys.MetricKeys.ACCURACY: 1.0 / 3,\n metric_keys.MetricKeys.PREDICTION_MEAN: 0.350085,\n metric_keys.MetricKeys.LABEL_MEAN: 1.0 / 3,\n metric_keys.MetricKeys.ACCURACY_BASELINE: 2.0 / 3,\n metric_keys.MetricKeys.RECALL: 0.0,\n metric_keys.MetricKeys.PRECISION: 0.0,\n metric_keys.MetricKeys.AUC: 0.5,\n metric_keys.MetricKeys.AUC_PR: 0.30685282,\n }\n self.assertAllClose(\n sorted_key_dict(expected_metrics), sorted_key_dict(eval_metrics))\n\n def testMultiClassEvaluationMetrics(self):\n def eval_input_fn():\n return {\n 'price':\n sparse_tensor.SparseTensor(\n values=[10., 5., 2., 7.],\n indices=[[0, 0], [0, 1], [1, 0], [1, 1]],\n dense_shape=[2, 2]),\n }, [[0], [1]]\n\n self.dense_kernel = [[-1., 0.5, 0.2], [1., -0.3, 0.1]]\n self.dense_bias = [0.3, 0.4, 0.5]\n # Uses identical numbers to testMultiExampleMultiDim.\n # See that test for logits calculation.\n # logits = [[-0.603282, 0.777708, 0.569756],\n # [-1.247356, 1.017018, 0.574481]]\n # logits_exp = exp(logits) / (1 + exp(logits))\n # = [[0.547013, 2.176468, 1.767836],\n # [0.287263, 2.764937, 1.776208]]\n # softmax_probabilities = logits_exp / logits_exp.sum()\n # = [[0.121793, 0.484596, 0.393611],\n # [0.059494, 0.572639, 0.367866]]\n # loss = -1. * log(softmax[label])\n # = [[2.105432], [0.557500]]\n # sum_over_batch_size = (2.105432 + 0.557500)/2\n eval_metrics = self._testFromCheckpoint(eval_input_fn, n_classes=3)\n\n expected_metrics = {\n ops.GraphKeys.GLOBAL_STEP: self.global_step,\n metric_keys.MetricKeys.LOSS: 1.331465,\n metric_keys.MetricKeys.LOSS_MEAN: 1.331466,\n metric_keys.MetricKeys.ACCURACY: 0.5,\n }\n\n self.assertAllClose(\n sorted_key_dict(expected_metrics), sorted_key_dict(eval_metrics))\n\n\n@test_util.run_all_in_graph_and_eager_modes\nclass RNNClassifierPredictionTest(test.TestCase):\n\n def setUp(self):\n self.kernel = [[.1, -.2]]\n self.recurrent = [[.2, -.3], [.3, -.4]]\n self.bias = [.2, .5]\n self.dense_kernel = [[-1.], [1.]]\n self.dense_bias = [0.3]\n self.sequence_feature_columns = [\n fc.sequence_numeric_column('price', shape=(1,))]\n super(RNNClassifierPredictionTest, self).setUp()\n\n def _testFromCheckpoint(self, input_fn, **kwargs):\n create_checkpoint(\n kernel=self.kernel,\n recurrent=self.recurrent,\n bias=self.bias,\n dense_kernel=self.dense_kernel,\n dense_bias=self.dense_bias,\n global_step=100,\n model_dir=self.get_temp_dir())\n\n label_vocabulary = ['class_0', 'class_1']\n\n est = rnn.RNNClassifier(\n units=[2],\n sequence_feature_columns=self.sequence_feature_columns,\n label_vocabulary=label_vocabulary,\n model_dir=self.get_temp_dir(),\n **kwargs)\n return next(est.predict(input_fn))\n\n def testBinaryClassPredictions(self):\n # Uses identical numbers to testOneDimLogits.\n # See that test for logits calculation.\n # logits = [-0.603282]\n # logistic = exp(-0.6033) / (1 + exp(-0.6033)) = [0.353593]\n # probabilities = [0.646407, 0.353593]\n # class_ids = argmax(probabilities) = [0]\n predictions = self._testFromCheckpoint(_default_features_fn)\n self.assertAllClose([-0.603282],\n predictions[prediction_keys.PredictionKeys.LOGITS])\n self.assertAllClose([0.353593],\n predictions[prediction_keys.PredictionKeys.LOGISTIC])\n self.assertAllClose(\n [0.646407, 0.353593],\n predictions[prediction_keys.PredictionKeys.PROBABILITIES])\n self.assertAllClose([0],\n predictions[prediction_keys.PredictionKeys.CLASS_IDS])\n self.assertEqual([b'class_0'],\n predictions[prediction_keys.PredictionKeys.CLASSES])\n\n def testMultiClassPredictions(self):\n self.dense_kernel = [[-1., 0.5, 0.2], [1., -0.3, 0.1]]\n self.dense_bias = [0.3, 0.4, 0.5]\n # Uses identical numbers to testMultiDimLogits.\n # See that test for logits calculation.\n # logits = [-0.603282, 0.777708, 0.569756]\n # logits_exp = exp(logits) = [0.547013, 2.176468, 1.767836]\n # softmax_probabilities = logits_exp / logits_exp.sum()\n # = [0.121793, 0.484596, 0.393611]\n # class_ids = argmax(probabilities) = [1]\n predictions = self._testFromCheckpoint(_default_features_fn, n_classes=3)\n self.assertAllClose([-0.603282, 0.777708, 0.569756],\n predictions[prediction_keys.PredictionKeys.LOGITS])\n self.assertAllClose(\n [0.121793, 0.484596, 0.393611],\n predictions[prediction_keys.PredictionKeys.PROBABILITIES])\n self.assertAllClose([1],\n predictions[prediction_keys.PredictionKeys.CLASS_IDS])\n self.assertEqual([b'class_1'],\n predictions[prediction_keys.PredictionKeys.CLASSES])\n\n def testBinaryClassPredictionsSequential(self):\n def predict_input_fn():\n return {\n 'price':\n sparse_tensor.SparseTensor(\n values=[10., 5.],\n indices=[[0, 0], [0, 1]],\n dense_shape=[1, 3]),\n }\n # Same as first record of testBinaryClassEvaluationMetricsSequential.\n # Last step values are carried over.\n # logits = [[-1.4388], [-0.6033], [_]]\n # probabilities = np.exp(logits) / (1 + np.exp(logits))\n # = [[0.8083, 0.1917], [0.6464, 0.3536], [_, _]]\n # class_ids = [[0], [0], [_]]\n # classes = [['class_0'], ['class_0'], [_]]\n predictions = self._testFromCheckpoint(\n predict_input_fn, return_sequences=True, sequence_mask='my-mask')\n self.assertAllEqual([1, 1], predictions['my-mask'])\n self.assertAllClose(\n [[-1.438803], [-0.603282], [-0.603282]],\n predictions[prediction_keys.PredictionKeys.LOGITS])\n self.assertAllClose(\n [[0.191731], [0.353593], [0.353593]],\n predictions[prediction_keys.PredictionKeys.LOGISTIC])\n self.assertAllClose(\n [[0.808269, 0.191731], [0.646407, 0.353593], [0.646407, 0.353593]],\n predictions[prediction_keys.PredictionKeys.PROBABILITIES])\n self.assertAllClose(\n [[0], [0], [0]],\n predictions[prediction_keys.PredictionKeys.CLASS_IDS])\n self.assertAllEqual(\n [[b'class_0'], [b'class_0'], [b'class_0']],\n predictions[prediction_keys.PredictionKeys.CLASSES])\n\n\nclass BaseRNNClassificationIntegrationTest(object):\n\n def setUp(self):\n col = fc.sequence_categorical_column_with_hash_bucket(\n 'tokens', hash_bucket_size=10)\n embed = fc.embedding_column(col, dimension=2)\n self.feature_columns = [embed]\n super(BaseRNNClassificationIntegrationTest, self).setUp()\n\n def __init__(self, _create_estimator_fn):\n self._create_estimator_fn = _create_estimator_fn\n\n def _test_complete_flow(self, train_input_fn, eval_input_fn,\n predict_input_fn, n_classes, batch_size,\n optimizer='Adam'):\n cell_units = [4, 2]\n est = self._create_estimator_fn(self.feature_columns, n_classes, cell_units,\n self.get_temp_dir(), optimizer=optimizer)\n\n # TRAIN\n num_steps = 10\n est.train(train_input_fn, steps=num_steps)\n\n # EVALUATE\n scores = est.evaluate(eval_input_fn)\n self.assertEqual(num_steps, scores[ops.GraphKeys.GLOBAL_STEP])\n self.assertIn('loss', six.iterkeys(scores))\n\n # PREDICT\n predicted_proba = np.array([\n x[prediction_keys.PredictionKeys.PROBABILITIES]\n for x in est.predict(predict_input_fn)\n ])\n self.assertAllEqual((batch_size, n_classes), predicted_proba.shape)\n\n # EXPORT\n feature_spec = parsing_utils.classifier_parse_example_spec(\n self.feature_columns,\n label_key='label',\n label_dtype=dtypes.int64)\n serving_input_receiver_fn = export.build_parsing_serving_input_receiver_fn(\n feature_spec)\n export_dir = est.export_savedmodel(tempfile.mkdtemp(),\n serving_input_receiver_fn)\n self.assertTrue(gfile.Exists(export_dir))\n\n def _testNumpyInputFn(self, optimizer):\n \"\"\"Tests complete flow with numpy_input_fn.\"\"\"\n n_classes = 3\n batch_size = 10\n words = ['dog', 'cat', 'bird', 'the', 'a', 'sat', 'flew', 'slept']\n # Numpy only supports dense input, so all examples will have same length.\n # TODO(b/73160931): Update test when support for prepadded data exists.\n sequence_length = 3\n\n features = []\n for _ in range(batch_size):\n sentence = random.sample(words, sequence_length)\n features.append(sentence)\n\n x_data = np.array(features)\n y_data = np.random.randint(n_classes, size=batch_size)\n\n train_input_fn = numpy_io.numpy_input_fn(\n x={'tokens': x_data},\n y=y_data,\n batch_size=batch_size,\n num_epochs=None,\n shuffle=True)\n eval_input_fn = numpy_io.numpy_input_fn(\n x={'tokens': x_data},\n y=y_data,\n batch_size=batch_size,\n shuffle=False)\n predict_input_fn = numpy_io.numpy_input_fn(\n x={'tokens': x_data},\n batch_size=batch_size,\n shuffle=False)\n\n self._test_complete_flow(\n train_input_fn=train_input_fn,\n eval_input_fn=eval_input_fn,\n predict_input_fn=predict_input_fn,\n n_classes=n_classes,\n batch_size=batch_size,\n optimizer=optimizer)\n\n def testNumpyInputFnStringOptimizer(self):\n self._testNumpyInputFn(optimizer='Adam')\n\n def testNumpyInputFnOptimizerInstance(self):\n self._testNumpyInputFn(optimizer=adam.Adam())\n\n def testParseExampleInputFn(self):\n \"\"\"Tests complete flow with input_fn constructed from parse_example.\"\"\"\n n_classes = 3\n batch_size = 10\n words = [b'dog', b'cat', b'bird', b'the', b'a', b'sat', b'flew', b'slept']\n\n _, examples_file = tempfile.mkstemp()\n writer = python_io.TFRecordWriter(examples_file)\n for _ in range(batch_size):\n sequence_length = random.randint(1, len(words))\n sentence = random.sample(words, sequence_length)\n label = random.randint(0, n_classes - 1)\n example = example_pb2.Example(features=feature_pb2.Features(\n feature={\n 'tokens':\n feature_pb2.Feature(bytes_list=feature_pb2.BytesList(\n value=sentence)),\n 'label':\n feature_pb2.Feature(int64_list=feature_pb2.Int64List(\n value=[label])),\n }))\n writer.write(example.SerializeToString())\n writer.close()\n\n feature_spec = parsing_utils.classifier_parse_example_spec(\n self.feature_columns,\n label_key='label',\n label_dtype=dtypes.int64)\n\n def _train_input_fn():\n dataset = readers.make_batched_features_dataset(\n examples_file, batch_size, feature_spec)\n return dataset.map(lambda features: (features, features.pop('label')))\n def _eval_input_fn():\n dataset = readers.make_batched_features_dataset(\n examples_file, batch_size, feature_spec, num_epochs=1)\n return dataset.map(lambda features: (features, features.pop('label')))\n def _predict_input_fn():\n dataset = readers.make_batched_features_dataset(\n examples_file, batch_size, feature_spec, num_epochs=1)\n def features_fn(features):\n features.pop('label')\n return features\n return dataset.map(features_fn)\n\n self._test_complete_flow(\n train_input_fn=_train_input_fn,\n eval_input_fn=_eval_input_fn,\n predict_input_fn=_predict_input_fn,\n n_classes=n_classes,\n batch_size=batch_size)\n\n\ndef _rnn_classifier_fn(feature_columns, n_classes, cell_units, model_dir,\n optimizer):\n return rnn.RNNClassifier(\n units=cell_units,\n sequence_feature_columns=feature_columns,\n n_classes=n_classes,\n optimizer=optimizer,\n model_dir=model_dir)\n\n\n@test_util.run_all_in_graph_and_eager_modes\nclass RNNClassifierIntegrationTest(BaseRNNClassificationIntegrationTest,\n test.TestCase):\n\n def __init__(self, methodName='runTest'): # pylint: disable=invalid-name\n test.TestCase.__init__(self, methodName)\n BaseRNNClassificationIntegrationTest.__init__(self, _rnn_classifier_fn)\n\n\ndef _rnn_classifier_dropout_fn(\n feature_columns, n_classes, cell_units, model_dir, optimizer):\n def _rnn_cell_fn():\n cells = []\n for units in cell_units:\n cells.append(keras_layers.SimpleRNNCell(units, dropout=0.5))\n return keras_layers.StackedRNNCells(cells)\n\n return rnn.RNNClassifier(\n rnn_cell_fn=_rnn_cell_fn,\n sequence_feature_columns=feature_columns,\n n_classes=n_classes,\n optimizer=optimizer,\n model_dir=model_dir)\n\n\n@test_util.run_all_in_graph_and_eager_modes\nclass RNNClassifierDropoutIntegrationTest(BaseRNNClassificationIntegrationTest,\n test.TestCase):\n\n def __init__(self, methodName='runTest'): # pylint: disable=invalid-name\n test.TestCase.__init__(self, methodName)\n BaseRNNClassificationIntegrationTest.__init__(\n self, _rnn_classifier_dropout_fn)\n\n\ndef _rnn_estimator_fn(feature_columns, n_classes, cell_units, model_dir,\n optimizer):\n return rnn.RNNEstimator(\n head=multi_head_lib.MultiClassHead(n_classes=n_classes),\n units=cell_units,\n sequence_feature_columns=feature_columns,\n optimizer=optimizer,\n model_dir=model_dir)\n\n\n@test_util.run_all_in_graph_and_eager_modes\nclass RNNEstimatorIntegrationTest(BaseRNNClassificationIntegrationTest,\n test.TestCase):\n\n def __init__(self, methodName='runTest'): # pylint: disable=invalid-name\n test.TestCase.__init__(self, methodName)\n BaseRNNClassificationIntegrationTest.__init__(self, _rnn_estimator_fn)\n\n\n@test_util.run_all_in_graph_and_eager_modes\nclass ModelFnTest(test.TestCase):\n \"\"\"Tests correctness of RNNEstimator's model function.\"\"\"\n\n def _test_sequential_mask_in_head(self, mask=None):\n features = {\n 'price': sparse_tensor.SparseTensor(\n values=[10., 5., 4.],\n indices=[[0, 0], [0, 1], [1, 0]],\n dense_shape=[2, 2])}\n if mask:\n features['sequence_mask'] = ops.convert_to_tensor(mask)\n expected_mask = mask or [[1, 1], [1, 0]]\n\n sequence_feature_columns = [fc.sequence_numeric_column('price', shape=(1,))]\n\n mock_head = _get_mock_head()\n seq_head = seq_head_lib.SequentialHeadWrapper(\n mock_head, sequence_length_mask='sequence_mask')\n estimator = rnn.RNNEstimator(\n head=seq_head, units=[10],\n sequence_feature_columns=sequence_feature_columns,\n return_sequences=True)\n estimator.model_fn(\n features=features, labels=None, mode=model_fn.ModeKeys.PREDICT,\n config=None)\n passed_features = list(\n mock_head.create_estimator_spec.call_args)[1]['features']\n self.assertIn('sequence_mask', passed_features)\n sequence_mask = self.evaluate(passed_features['sequence_mask'])\n self.assertAllEqual(sequence_mask, expected_mask)\n\n def testSequentialMaskInHead(self):\n self._test_sequential_mask_in_head()\n\n def testSequentialMaskInHeadWithMasks(self):\n self._test_sequential_mask_in_head([[1, 1], [1, 1]])\n\nif __name__ == '__main__':\n test.main()\n",
"# Copyright 2018 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"Utilities for early stopping.\"\"\"\n\nimport collections\nimport operator\nimport os\n\nfrom tensorflow.python.framework import dtypes\nfrom tensorflow.python.framework import ops\nfrom tensorflow.python.ops import init_ops\nfrom tensorflow.python.ops import state_ops\nfrom tensorflow.python.ops import variable_scope\nfrom tensorflow.python.platform import gfile\nfrom tensorflow.python.platform import tf_logging\nfrom tensorflow.python.summary import summary_iterator\nfrom tensorflow.python.training import basic_session_run_hooks\nfrom tensorflow.python.training import session_run_hook\nfrom tensorflow.python.training import training_util\nfrom tensorflow.python.util.tf_export import estimator_export\nfrom tensorflow_estimator.python.estimator import estimator as estimator_lib\n\n_EVENT_FILE_GLOB_PATTERN = 'events.out.tfevents.*'\n\n\n@estimator_export('estimator.experimental.make_early_stopping_hook')\ndef make_early_stopping_hook(estimator,\n should_stop_fn,\n run_every_secs=60,\n run_every_steps=None):\n \"\"\"Creates early-stopping hook.\n\n Returns a `SessionRunHook` that stops training when `should_stop_fn` returns\n `True`.\n\n Usage example:\n\n ```python\n estimator = ...\n hook = early_stopping.make_early_stopping_hook(\n estimator, should_stop_fn=make_stop_fn(...))\n train_spec = tf.estimator.TrainSpec(..., hooks=[hook])\n tf.estimator.train_and_evaluate(estimator, train_spec, ...)\n ```\n\n Caveat: Current implementation supports early-stopping both training and\n evaluation in local mode. In distributed mode, training can be stopped but\n evaluation (where it's a separate job) will indefinitely wait for new model\n checkpoints to evaluate, so you will need other means to detect and stop it.\n Early-stopping evaluation in distributed mode requires changes in\n `train_and_evaluate` API and will be addressed in a future revision.\n\n Args:\n estimator: A `tf.estimator.Estimator` instance.\n should_stop_fn: `callable`, function that takes no arguments and returns a\n `bool`. If the function returns `True`, stopping will be initiated by the\n chief.\n run_every_secs: If specified, calls `should_stop_fn` at an interval of\n `run_every_secs` seconds. Defaults to 60 seconds. Either this or\n `run_every_steps` must be set.\n run_every_steps: If specified, calls `should_stop_fn` every\n `run_every_steps` steps. Either this or `run_every_secs` must be set.\n\n Returns:\n A `SessionRunHook` that periodically executes `should_stop_fn` and initiates\n early stopping if the function returns `True`.\n\n Raises:\n TypeError: If `estimator` is not of type `tf.estimator.Estimator`.\n ValueError: If both `run_every_secs` and `run_every_steps` are set.\n \"\"\"\n if not isinstance(estimator, estimator_lib.Estimator):\n raise TypeError('`estimator` must have type `tf.estimator.Estimator`. '\n 'Got: {}'.format(type(estimator)))\n\n if run_every_secs is not None and run_every_steps is not None:\n raise ValueError('Only one of `run_every_secs` and `run_every_steps` must '\n 'be set.')\n\n if estimator.config.is_chief:\n return _StopOnPredicateHook(should_stop_fn, run_every_secs, run_every_steps)\n else:\n return _CheckForStoppingHook()\n\n\n@estimator_export('estimator.experimental.stop_if_higher_hook')\ndef stop_if_higher_hook(estimator,\n metric_name,\n threshold,\n eval_dir=None,\n min_steps=0,\n run_every_secs=60,\n run_every_steps=None):\n \"\"\"Creates hook to stop if the given metric is higher than the threshold.\n\n Usage example:\n\n ```python\n estimator = ...\n # Hook to stop training if accuracy becomes higher than 0.9.\n hook = early_stopping.stop_if_higher_hook(estimator, \"accuracy\", 0.9)\n train_spec = tf.estimator.TrainSpec(..., hooks=[hook])\n tf.estimator.train_and_evaluate(estimator, train_spec, ...)\n ```\n\n Caveat: Current implementation supports early-stopping both training and\n evaluation in local mode. In distributed mode, training can be stopped but\n evaluation (where it's a separate job) will indefinitely wait for new model\n checkpoints to evaluate, so you will need other means to detect and stop it.\n Early-stopping evaluation in distributed mode requires changes in\n `train_and_evaluate` API and will be addressed in a future revision.\n\n Args:\n estimator: A `tf.estimator.Estimator` instance.\n metric_name: `str`, metric to track. \"loss\", \"accuracy\", etc.\n threshold: Numeric threshold for the given metric.\n eval_dir: If set, directory containing summary files with eval metrics. By\n default, `estimator.eval_dir()` will be used.\n min_steps: `int`, stop is never requested if global step is less than this\n value. Defaults to 0.\n run_every_secs: If specified, calls `should_stop_fn` at an interval of\n `run_every_secs` seconds. Defaults to 60 seconds. Either this or\n `run_every_steps` must be set.\n run_every_steps: If specified, calls `should_stop_fn` every\n `run_every_steps` steps. Either this or `run_every_secs` must be set.\n\n Returns:\n An early-stopping hook of type `SessionRunHook` that periodically checks\n if the given metric is higher than specified threshold and initiates\n early stopping if true.\n \"\"\"\n return _stop_if_threshold_crossed_hook(\n estimator=estimator,\n metric_name=metric_name,\n threshold=threshold,\n higher_is_better=True,\n eval_dir=eval_dir,\n min_steps=min_steps,\n run_every_secs=run_every_secs,\n run_every_steps=run_every_steps)\n\n@estimator_export('estimator.experimental.stop_if_lower_hook')\ndef stop_if_lower_hook(estimator,\n metric_name,\n threshold,\n eval_dir=None,\n min_steps=0,\n run_every_secs=60,\n run_every_steps=None):\n \"\"\"Creates hook to stop if the given metric is lower than the threshold.\n\n Usage example:\n\n ```python\n estimator = ...\n # Hook to stop training if loss becomes lower than 100.\n hook = early_stopping.stop_if_lower_hook(estimator, \"loss\", 100)\n train_spec = tf.estimator.TrainSpec(..., hooks=[hook])\n tf.estimator.train_and_evaluate(estimator, train_spec, ...)\n ```\n\n Caveat: Current implementation supports early-stopping both training and\n evaluation in local mode. In distributed mode, training can be stopped but\n evaluation (where it's a separate job) will indefinitely wait for new model\n checkpoints to evaluate, so you will need other means to detect and stop it.\n Early-stopping evaluation in distributed mode requires changes in\n `train_and_evaluate` API and will be addressed in a future revision.\n\n Args:\n estimator: A `tf.estimator.Estimator` instance.\n metric_name: `str`, metric to track. \"loss\", \"accuracy\", etc.\n threshold: Numeric threshold for the given metric.\n eval_dir: If set, directory containing summary files with eval metrics. By\n default, `estimator.eval_dir()` will be used.\n min_steps: `int`, stop is never requested if global step is less than this\n value. Defaults to 0.\n run_every_secs: If specified, calls `should_stop_fn` at an interval of\n `run_every_secs` seconds. Defaults to 60 seconds. Either this or\n `run_every_steps` must be set.\n run_every_steps: If specified, calls `should_stop_fn` every\n `run_every_steps` steps. Either this or `run_every_secs` must be set.\n\n Returns:\n An early-stopping hook of type `SessionRunHook` that periodically checks\n if the given metric is lower than specified threshold and initiates\n early stopping if true.\n \"\"\"\n return _stop_if_threshold_crossed_hook(\n estimator=estimator,\n metric_name=metric_name,\n threshold=threshold,\n higher_is_better=False,\n eval_dir=eval_dir,\n min_steps=min_steps,\n run_every_secs=run_every_secs,\n run_every_steps=run_every_steps)\n\n\n@estimator_export('estimator.experimental.stop_if_no_increase_hook')\ndef stop_if_no_increase_hook(estimator,\n metric_name,\n max_steps_without_increase,\n eval_dir=None,\n min_steps=0,\n run_every_secs=60,\n run_every_steps=None):\n \"\"\"Creates hook to stop if metric does not increase within given max steps.\n\n Usage example:\n\n ```python\n estimator = ...\n # Hook to stop training if accuracy does not increase in over 100000 steps.\n hook = early_stopping.stop_if_no_increase_hook(estimator, \"accuracy\", 100000)\n train_spec = tf.estimator.TrainSpec(..., hooks=[hook])\n tf.estimator.train_and_evaluate(estimator, train_spec, ...)\n ```\n\n Caveat: Current implementation supports early-stopping both training and\n evaluation in local mode. In distributed mode, training can be stopped but\n evaluation (where it's a separate job) will indefinitely wait for new model\n checkpoints to evaluate, so you will need other means to detect and stop it.\n Early-stopping evaluation in distributed mode requires changes in\n `train_and_evaluate` API and will be addressed in a future revision.\n\n Args:\n estimator: A `tf.estimator.Estimator` instance.\n metric_name: `str`, metric to track. \"loss\", \"accuracy\", etc.\n max_steps_without_increase: `int`, maximum number of training steps with no\n increase in the given metric.\n eval_dir: If set, directory containing summary files with eval metrics. By\n default, `estimator.eval_dir()` will be used.\n min_steps: `int`, stop is never requested if global step is less than this\n value. Defaults to 0.\n run_every_secs: If specified, calls `should_stop_fn` at an interval of\n `run_every_secs` seconds. Defaults to 60 seconds. Either this or\n `run_every_steps` must be set.\n run_every_steps: If specified, calls `should_stop_fn` every\n `run_every_steps` steps. Either this or `run_every_secs` must be set.\n\n Returns:\n An early-stopping hook of type `SessionRunHook` that periodically checks\n if the given metric shows no increase over given maximum number of\n training steps, and initiates early stopping if true.\n \"\"\"\n return _stop_if_no_metric_improvement_hook(\n estimator=estimator,\n metric_name=metric_name,\n max_steps_without_improvement=max_steps_without_increase,\n higher_is_better=True,\n eval_dir=eval_dir,\n min_steps=min_steps,\n run_every_secs=run_every_secs,\n run_every_steps=run_every_steps)\n\n\n@estimator_export('estimator.experimental.stop_if_no_decrease_hook')\ndef stop_if_no_decrease_hook(estimator,\n metric_name,\n max_steps_without_decrease,\n eval_dir=None,\n min_steps=0,\n run_every_secs=60,\n run_every_steps=None):\n \"\"\"Creates hook to stop if metric does not decrease within given max steps.\n\n Usage example:\n\n ```python\n estimator = ...\n # Hook to stop training if loss does not decrease in over 100000 steps.\n hook = early_stopping.stop_if_no_decrease_hook(estimator, \"loss\", 100000)\n train_spec = tf.estimator.TrainSpec(..., hooks=[hook])\n tf.estimator.train_and_evaluate(estimator, train_spec, ...)\n ```\n\n Caveat: Current implementation supports early-stopping both training and\n evaluation in local mode. In distributed mode, training can be stopped but\n evaluation (where it's a separate job) will indefinitely wait for new model\n checkpoints to evaluate, so you will need other means to detect and stop it.\n Early-stopping evaluation in distributed mode requires changes in\n `train_and_evaluate` API and will be addressed in a future revision.\n\n Args:\n estimator: A `tf.estimator.Estimator` instance.\n metric_name: `str`, metric to track. \"loss\", \"accuracy\", etc.\n max_steps_without_decrease: `int`, maximum number of training steps with no\n decrease in the given metric.\n eval_dir: If set, directory containing summary files with eval metrics. By\n default, `estimator.eval_dir()` will be used.\n min_steps: `int`, stop is never requested if global step is less than this\n value. Defaults to 0.\n run_every_secs: If specified, calls `should_stop_fn` at an interval of\n `run_every_secs` seconds. Defaults to 60 seconds. Either this or\n `run_every_steps` must be set.\n run_every_steps: If specified, calls `should_stop_fn` every\n `run_every_steps` steps. Either this or `run_every_secs` must be set.\n\n Returns:\n An early-stopping hook of type `SessionRunHook` that periodically checks\n if the given metric shows no decrease over given maximum number of\n training steps, and initiates early stopping if true.\n \"\"\"\n return _stop_if_no_metric_improvement_hook(\n estimator=estimator,\n metric_name=metric_name,\n max_steps_without_improvement=max_steps_without_decrease,\n higher_is_better=False,\n eval_dir=eval_dir,\n min_steps=min_steps,\n run_every_secs=run_every_secs,\n run_every_steps=run_every_steps)\n\n\ndef read_eval_metrics(eval_dir):\n \"\"\"Helper to read eval metrics from eval summary files.\n\n Args:\n eval_dir: Directory containing summary files with eval metrics.\n\n Returns:\n A `dict` with global steps mapping to `dict` of metric names and values.\n \"\"\"\n eval_metrics_dict = collections.defaultdict(dict)\n for event in _summaries(eval_dir):\n if not event.HasField('summary'):\n continue\n metrics = {}\n for value in event.summary.value:\n if value.HasField('simple_value'):\n metrics[value.tag] = value.simple_value\n if metrics:\n eval_metrics_dict[event.step].update(metrics)\n return collections.OrderedDict(\n sorted(eval_metrics_dict.items(), key=lambda t: t[0]))\n\n\ndef _stop_if_threshold_crossed_hook(estimator, metric_name, threshold,\n higher_is_better, eval_dir, min_steps,\n run_every_secs, run_every_steps):\n \"\"\"Creates early-stopping hook to stop training if threshold is crossed.\"\"\"\n\n if eval_dir is None:\n eval_dir = estimator.eval_dir()\n\n is_lhs_better = operator.gt if higher_is_better else operator.lt\n greater_or_lesser = 'greater than' if higher_is_better else 'less than'\n\n def stop_if_threshold_crossed_fn():\n \"\"\"Returns `True` if the given metric crosses specified threshold.\"\"\"\n\n eval_results = read_eval_metrics(eval_dir)\n\n for step, metrics in eval_results.items():\n if step < min_steps:\n continue\n val = metrics[metric_name]\n if is_lhs_better(val, threshold):\n tf_logging.info(\n 'At step %s, metric \"%s\" has value %s which is %s the configured '\n 'threshold (%s) for early stopping.', step, metric_name, val,\n greater_or_lesser, threshold)\n return True\n return False\n\n return make_early_stopping_hook(\n estimator=estimator,\n should_stop_fn=stop_if_threshold_crossed_fn,\n run_every_secs=run_every_secs,\n run_every_steps=run_every_steps)\n\n\ndef _stop_if_no_metric_improvement_hook(\n estimator, metric_name, max_steps_without_improvement, higher_is_better,\n eval_dir, min_steps, run_every_secs, run_every_steps):\n \"\"\"Returns hook to stop training if given metric shows no improvement.\"\"\"\n\n if eval_dir is None:\n eval_dir = estimator.eval_dir()\n\n is_lhs_better = operator.gt if higher_is_better else operator.lt\n increase_or_decrease = 'increase' if higher_is_better else 'decrease'\n\n def stop_if_no_metric_improvement_fn():\n \"\"\"Returns `True` if metric does not improve within max steps.\"\"\"\n\n eval_results = read_eval_metrics(eval_dir)\n\n best_val = None\n best_val_step = None\n for step, metrics in eval_results.items():\n if step < min_steps:\n continue\n val = metrics[metric_name]\n if best_val is None or is_lhs_better(val, best_val):\n best_val = val\n best_val_step = step\n if step - best_val_step >= max_steps_without_improvement:\n tf_logging.info(\n 'No %s in metric \"%s\" for %s steps, which is greater than or equal '\n 'to max steps (%s) configured for early stopping.',\n increase_or_decrease, metric_name, step - best_val_step,\n max_steps_without_improvement)\n return True\n return False\n\n return make_early_stopping_hook(\n estimator=estimator,\n should_stop_fn=stop_if_no_metric_improvement_fn,\n run_every_secs=run_every_secs,\n run_every_steps=run_every_steps)\n\n\ndef _summaries(eval_dir):\n \"\"\"Yields `tensorflow.Event` protos from event files in the eval dir.\n\n Args:\n eval_dir: Directory containing summary files with eval metrics.\n\n Yields:\n `tensorflow.Event` object read from the event files.\n \"\"\"\n if gfile.Exists(eval_dir):\n for event_file in gfile.Glob(\n os.path.join(eval_dir, _EVENT_FILE_GLOB_PATTERN)):\n for event in summary_iterator.summary_iterator(event_file):\n yield event\n\n\ndef _get_or_create_stop_var():\n with variable_scope.variable_scope(\n name_or_scope='signal_early_stopping',\n values=[],\n reuse=variable_scope.AUTO_REUSE):\n return variable_scope.get_variable(\n name='STOP',\n shape=[],\n dtype=dtypes.bool,\n initializer=init_ops.constant_initializer(False),\n collections=[ops.GraphKeys.GLOBAL_VARIABLES],\n trainable=False)\n\n\nclass _StopOnPredicateHook(session_run_hook.SessionRunHook):\n \"\"\"Hook that requests stop when `should_stop_fn` returns `True`.\"\"\"\n\n def __init__(self, should_stop_fn, run_every_secs=60, run_every_steps=None):\n if not callable(should_stop_fn):\n raise TypeError('`should_stop_fn` must be callable.')\n\n self._should_stop_fn = should_stop_fn\n self._timer = basic_session_run_hooks.SecondOrStepTimer(\n every_secs=run_every_secs, every_steps=run_every_steps)\n self._global_step_tensor = None\n self._stop_var = None\n self._stop_op = None\n\n def begin(self):\n self._global_step_tensor = training_util.get_global_step()\n self._stop_var = _get_or_create_stop_var()\n self._stop_op = state_ops.assign(self._stop_var, True)\n\n def before_run(self, run_context):\n del run_context\n return session_run_hook.SessionRunArgs(self._global_step_tensor)\n\n def after_run(self, run_context, run_values):\n global_step = run_values.results\n if self._timer.should_trigger_for_step(global_step):\n self._timer.update_last_triggered_step(global_step)\n if self._should_stop_fn():\n tf_logging.info('Requesting early stopping at global step %d',\n global_step)\n run_context.session.run(self._stop_op)\n run_context.request_stop()\n\n\nclass _CheckForStoppingHook(session_run_hook.SessionRunHook):\n \"\"\"Hook that requests stop if stop is requested by `_StopOnPredicateHook`.\n\n Args:\n ctrl_deps: List of control dependencies of the stop variable.\n \"\"\"\n\n def __init__(self, ctrl_deps=None):\n self._stop_var = None\n self._ctrl_deps = ctrl_deps or []\n\n def begin(self):\n with ops.control_dependencies(self._ctrl_deps):\n self._stop_var = _get_or_create_stop_var()\n\n def before_run(self, run_context):\n del run_context\n return session_run_hook.SessionRunArgs(self._stop_var)\n\n def after_run(self, run_context, run_values):\n should_early_stop = run_values.results\n if should_early_stop:\n tf_logging.info('Early stopping requested, suspending run.')\n run_context.request_stop()\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\"\"\"Tests for garbage collection utilities.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport os\nimport re\n\nfrom six.moves import xrange # pylint: disable=redefined-builtin\n\nfrom tensorflow.python.framework import test_util\nfrom tensorflow.python.platform import gfile\nfrom tensorflow.python.platform import test\nfrom tensorflow.python.util import compat\nfrom tensorflow_estimator.python.estimator import gc\n\n\ndef _create_parser(base_dir):\n # create a simple parser that pulls the export_version from the directory.\n def parser(path):\n # Modify the path object for RegEx match for Windows Paths\n if os.name == \"nt\":\n match = re.match(\n \"^\" + compat.as_str_any(base_dir).replace(\"\\\\\", \"/\") + \"/(\\\\d+)$\",\n compat.as_str_any(path.path).replace(\"\\\\\", \"/\"))\n else:\n match = re.match(\"^\" + compat.as_str_any(base_dir) + \"/(\\\\d+)$\",\n compat.as_str_any(path.path))\n if not match:\n return None\n return path._replace(export_version=int(match.group(1)))\n\n return parser\n\n\nclass GcTest(test_util.TensorFlowTestCase):\n\n def testLargestExportVersions(self):\n paths = [gc.Path(\"/foo\", 8), gc.Path(\"/foo\", 9), gc.Path(\"/foo\", 10)]\n newest = gc._largest_export_versions(2)\n n = newest(paths)\n self.assertEqual(n, [gc.Path(\"/foo\", 9), gc.Path(\"/foo\", 10)])\n\n def testLargestExportVersionsDoesNotDeleteZeroFolder(self):\n paths = [gc.Path(\"/foo\", 0), gc.Path(\"/foo\", 3)]\n newest = gc._largest_export_versions(2)\n n = newest(paths)\n self.assertEqual(n, [gc.Path(\"/foo\", 0), gc.Path(\"/foo\", 3)])\n\n def testModExportVersion(self):\n paths = [\n gc.Path(\"/foo\", 4), gc.Path(\"/foo\", 5), gc.Path(\"/foo\", 6),\n gc.Path(\"/foo\", 9)\n ]\n mod = gc._mod_export_version(2)\n self.assertEqual(mod(paths), [gc.Path(\"/foo\", 4), gc.Path(\"/foo\", 6)])\n mod = gc._mod_export_version(3)\n self.assertEqual(mod(paths), [gc.Path(\"/foo\", 6), gc.Path(\"/foo\", 9)])\n\n def testOneOfEveryNExportVersions(self):\n paths = [\n gc.Path(\"/foo\", 0), gc.Path(\"/foo\", 1), gc.Path(\"/foo\", 3),\n gc.Path(\"/foo\", 5), gc.Path(\"/foo\", 6), gc.Path(\"/foo\", 7),\n gc.Path(\"/foo\", 8), gc.Path(\"/foo\", 33)\n ]\n one_of = gc._one_of_every_n_export_versions(3)\n self.assertEqual(\n one_of(paths), [\n gc.Path(\"/foo\", 3), gc.Path(\"/foo\", 6), gc.Path(\"/foo\", 8),\n gc.Path(\"/foo\", 33)\n ])\n\n def testOneOfEveryNExportVersionsZero(self):\n # Zero is a special case since it gets rolled into the first interval.\n # Test that here.\n paths = [gc.Path(\"/foo\", 0), gc.Path(\"/foo\", 4), gc.Path(\"/foo\", 5)]\n one_of = gc._one_of_every_n_export_versions(3)\n self.assertEqual(one_of(paths), [gc.Path(\"/foo\", 0), gc.Path(\"/foo\", 5)])\n\n def testUnion(self):\n paths = []\n for i in xrange(10):\n paths.append(gc.Path(\"/foo\", i))\n f = gc._union(gc._largest_export_versions(3), gc._mod_export_version(3))\n self.assertEqual(\n f(paths), [\n gc.Path(\"/foo\", 0), gc.Path(\"/foo\", 3), gc.Path(\"/foo\", 6),\n gc.Path(\"/foo\", 7), gc.Path(\"/foo\", 8), gc.Path(\"/foo\", 9)\n ])\n\n def testNegation(self):\n paths = [\n gc.Path(\"/foo\", 4), gc.Path(\"/foo\", 5), gc.Path(\"/foo\", 6),\n gc.Path(\"/foo\", 9)\n ]\n mod = gc._negation(gc._mod_export_version(2))\n self.assertEqual(mod(paths), [gc.Path(\"/foo\", 5), gc.Path(\"/foo\", 9)])\n mod = gc._negation(gc._mod_export_version(3))\n self.assertEqual(mod(paths), [gc.Path(\"/foo\", 4), gc.Path(\"/foo\", 5)])\n\n def testPathsWithParse(self):\n base_dir = os.path.join(test.get_temp_dir(), \"paths_parse\")\n self.assertFalse(gfile.Exists(base_dir))\n for p in xrange(3):\n gfile.MakeDirs(os.path.join(base_dir, \"%d\" % p))\n # add a base_directory to ignore\n gfile.MakeDirs(os.path.join(base_dir, \"ignore\"))\n\n self.assertEqual(\n gc._get_paths(base_dir, _create_parser(base_dir)),\n [\n gc.Path(os.path.join(base_dir, \"0\"), 0),\n gc.Path(os.path.join(base_dir, \"1\"), 1),\n gc.Path(os.path.join(base_dir, \"2\"), 2)\n ])\n gfile.DeleteRecursively(base_dir)\n\n def testMixedStrTypes(self):\n temp_dir = compat.as_bytes(test.get_temp_dir())\n\n for sub_dir in [\"str\", b\"bytes\", u\"unicode\"]:\n base_dir = os.path.join(\n (temp_dir if isinstance(sub_dir, bytes) else temp_dir.decode()),\n sub_dir)\n self.assertFalse(gfile.Exists(base_dir))\n gfile.MakeDirs(os.path.join(compat.as_str_any(base_dir), \"42\"))\n gc._get_paths(base_dir, _create_parser(base_dir))\n gfile.DeleteRecursively(base_dir)\n\n def testGcsDirWithSeparator(self):\n base_dir = \"gs://bucket/foo\"\n with test.mock.patch.object(gfile, \"ListDirectory\") as mock_list_directory:\n # gfile.ListDirectory returns directory names with separator '/'\n mock_list_directory.return_value = [\"0/\", \"1/\"]\n self.assertEqual(\n gc._get_paths(base_dir, _create_parser(base_dir)),\n [\n gc.Path(os.path.join(base_dir, \"0\"), 0),\n gc.Path(os.path.join(base_dir, \"1\"), 1)\n ])\n\nif __name__ == \"__main__\":\n test.main()\n",
"# Copyright 2017 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"TensorFlow estimators for Linear and DNN joined training models.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport math\n\nimport six\n\nfrom tensorflow.python.framework import ops\nfrom tensorflow.python.keras.utils import losses_utils\nfrom tensorflow.python.ops import control_flow_ops\nfrom tensorflow.python.ops import nn\nfrom tensorflow.python.ops import partitioned_variables\nfrom tensorflow.python.ops import state_ops\nfrom tensorflow.python.ops import variable_scope\nfrom tensorflow.python.ops.losses import losses\nfrom tensorflow.python.summary import summary\nfrom tensorflow.python.training import sync_replicas_optimizer\nfrom tensorflow.python.training import training_util\nfrom tensorflow.python.util.tf_export import estimator_export\nfrom tensorflow_estimator.python.estimator import estimator\nfrom tensorflow_estimator.python.estimator.canned import dnn\nfrom tensorflow_estimator.python.estimator.canned import head as head_lib\nfrom tensorflow_estimator.python.estimator.canned import linear\nfrom tensorflow_estimator.python.estimator.canned import optimizers\nfrom tensorflow_estimator.python.estimator.head import head_utils\nfrom tensorflow_estimator.python.estimator.head import regression_head\nfrom tensorflow_estimator.python.estimator.mode_keys import ModeKeys\n\n# The default learning rates are a historical artifact of the initial\n# implementation.\n_DNN_LEARNING_RATE = 0.001\n_LINEAR_LEARNING_RATE = 0.005\n\n\ndef _check_no_sync_replicas_optimizer(optimizer):\n if isinstance(optimizer, sync_replicas_optimizer.SyncReplicasOptimizer):\n raise ValueError(\n 'SyncReplicasOptimizer does not support multi optimizers case. '\n 'Therefore, it is not supported in DNNLinearCombined model. '\n 'If you want to use this optimizer, please use either DNN or Linear '\n 'model.')\n\n\ndef _linear_learning_rate(num_linear_feature_columns):\n \"\"\"Returns the default learning rate of the linear model.\n\n The calculation is a historical artifact of this initial implementation, but\n has proven a reasonable choice.\n\n Args:\n num_linear_feature_columns: The number of feature columns of the linear\n model.\n\n Returns:\n A float.\n \"\"\"\n default_learning_rate = 1. / math.sqrt(num_linear_feature_columns)\n return min(_LINEAR_LEARNING_RATE, default_learning_rate)\n\n\ndef _add_layer_summary(value, tag):\n summary.scalar('%s/fraction_of_zero_values' % tag, nn.zero_fraction(value))\n summary.histogram('%s/activation' % tag, value)\n\n\ndef _validate_feature_columns(linear_feature_columns, dnn_feature_columns):\n \"\"\"Validates feature columns DNNLinearCombinedRegressor.\"\"\"\n linear_feature_columns = linear_feature_columns or []\n dnn_feature_columns = dnn_feature_columns or []\n feature_columns = (\n list(linear_feature_columns) + list(dnn_feature_columns))\n if not feature_columns:\n raise ValueError('Either linear_feature_columns or dnn_feature_columns '\n 'must be defined.')\n return feature_columns\n\n\ndef _dnn_linear_combined_model_fn_v2(features,\n labels,\n mode,\n head,\n linear_feature_columns=None,\n linear_optimizer='Ftrl',\n dnn_feature_columns=None,\n dnn_optimizer='Adagrad',\n dnn_hidden_units=None,\n dnn_activation_fn=nn.relu,\n dnn_dropout=None,\n config=None,\n batch_norm=False,\n linear_sparse_combiner='sum'):\n \"\"\"Deep Neural Net and Linear combined model_fn.\n\n Args:\n features: dict of `Tensor`.\n labels: `Tensor` of shape [batch_size, 1] or [batch_size] labels of dtype\n `int32` or `int64` in the range `[0, n_classes)`.\n mode: Defines whether this is training, evaluation or prediction. See\n `ModeKeys`.\n head: A `Head` instance.\n linear_feature_columns: An iterable containing all the feature columns used\n by the Linear model.\n linear_optimizer: string, `Optimizer` object, or callable that defines the\n optimizer to use for training the Linear model. Defaults to the Ftrl\n optimizer.\n dnn_feature_columns: An iterable containing all the feature columns used by\n the DNN model.\n dnn_optimizer: string, `Optimizer` object, or callable that defines the\n optimizer to use for training the DNN model. Defaults to the Adagrad\n optimizer.\n dnn_hidden_units: List of hidden units per DNN layer.\n dnn_activation_fn: Activation function applied to each DNN layer. If `None`,\n will use `tf.nn.relu`.\n dnn_dropout: When not `None`, the probability we will drop out a given DNN\n coordinate.\n config: `RunConfig` object to configure the runtime settings.\n batch_norm: Whether to use batch normalization after each hidden layer.\n linear_sparse_combiner: A string specifying how to reduce the linear model\n if a categorical column is multivalent. One of \"mean\", \"sqrtn\", and\n \"sum\".\n\n Returns:\n An `EstimatorSpec` instance.\n\n Raises:\n ValueError: If both `linear_feature_columns` and `dnn_features_columns`\n are empty at the same time, or `input_layer_partitioner` is missing,\n or features has the wrong type.\n \"\"\"\n if not isinstance(features, dict):\n raise ValueError('features should be a dictionary of `Tensor`s. '\n 'Given type: {}'.format(type(features)))\n if not linear_feature_columns and not dnn_feature_columns:\n raise ValueError(\n 'Either linear_feature_columns or dnn_feature_columns must be defined.')\n\n del config\n\n # Build DNN Logits.\n if not dnn_feature_columns:\n dnn_logits = None\n else:\n if mode == ModeKeys.TRAIN:\n dnn_optimizer = optimizers.get_optimizer_instance_v2(\n dnn_optimizer, learning_rate=_DNN_LEARNING_RATE)\n _check_no_sync_replicas_optimizer(dnn_optimizer)\n\n if not dnn_hidden_units:\n raise ValueError(\n 'dnn_hidden_units must be defined when dnn_feature_columns is '\n 'specified.')\n dnn_logits, dnn_trainable_variables, dnn_update_ops = (\n dnn._dnn_model_fn_builder_v2( # pylint: disable=protected-access\n units=head.logits_dimension,\n hidden_units=dnn_hidden_units,\n feature_columns=dnn_feature_columns,\n activation_fn=dnn_activation_fn,\n dropout=dnn_dropout,\n batch_norm=batch_norm,\n features=features,\n mode=mode))\n\n if not linear_feature_columns:\n linear_logits = None\n else:\n if mode == ModeKeys.TRAIN:\n linear_optimizer = optimizers.get_optimizer_instance_v2(\n linear_optimizer,\n learning_rate=_linear_learning_rate(len(linear_feature_columns)))\n _check_no_sync_replicas_optimizer(linear_optimizer)\n\n linear_logits, linear_trainable_variables = (\n linear._linear_model_fn_builder_v2( # pylint: disable=protected-access\n units=head.logits_dimension,\n feature_columns=linear_feature_columns,\n sparse_combiner=linear_sparse_combiner,\n features=features))\n _add_layer_summary(linear_logits, 'linear')\n\n # Combine logits and build full model.\n if dnn_logits is not None and linear_logits is not None:\n logits = dnn_logits + linear_logits\n elif dnn_logits is not None:\n logits = dnn_logits\n else:\n logits = linear_logits\n\n def _train_op_fn(loss):\n \"\"\"Returns the op to optimize the loss.\"\"\"\n train_ops = []\n if dnn_logits is not None:\n train_ops.extend(\n dnn_optimizer.get_updates(\n loss,\n dnn_trainable_variables))\n if dnn_update_ops is not None:\n train_ops.extend(dnn_update_ops)\n if linear_logits is not None:\n train_ops.extend(\n linear_optimizer.get_updates(\n loss,\n linear_trainable_variables))\n train_op = control_flow_ops.group(*train_ops)\n return train_op\n\n # In TRAIN mode, asssign global_step variable to optimizer.iterations to\n # make global_step increased correctly, as Hooks relies on global step as\n # step counter. Note that, Only one model's optimizer needs this assignment.\n if mode == ModeKeys.TRAIN:\n if dnn_logits is not None:\n dnn_optimizer.iterations = training_util.get_or_create_global_step()\n else:\n linear_optimizer.iterations = training_util.get_or_create_global_step()\n\n return head.create_estimator_spec(\n features=features,\n mode=mode,\n labels=labels,\n train_op_fn=_train_op_fn,\n logits=logits)\n\n\ndef _dnn_linear_combined_model_fn(features,\n labels,\n mode,\n head,\n linear_feature_columns=None,\n linear_optimizer='Ftrl',\n dnn_feature_columns=None,\n dnn_optimizer='Adagrad',\n dnn_hidden_units=None,\n dnn_activation_fn=nn.relu,\n dnn_dropout=None,\n input_layer_partitioner=None,\n config=None,\n batch_norm=False,\n linear_sparse_combiner='sum'):\n \"\"\"Deep Neural Net and Linear combined model_fn.\n\n Args:\n features: dict of `Tensor`.\n labels: `Tensor` of shape [batch_size, 1] or [batch_size] labels of dtype\n `int32` or `int64` in the range `[0, n_classes)`.\n mode: Defines whether this is training, evaluation or prediction.\n See `ModeKeys`.\n head: A `Head` instance.\n linear_feature_columns: An iterable containing all the feature columns used\n by the Linear model.\n linear_optimizer: string, `Optimizer` object, or callable that defines the\n optimizer to use for training the Linear model. Defaults to the Ftrl\n optimizer.\n dnn_feature_columns: An iterable containing all the feature columns used by\n the DNN model.\n dnn_optimizer: string, `Optimizer` object, or callable that defines the\n optimizer to use for training the DNN model. Defaults to the Adagrad\n optimizer.\n dnn_hidden_units: List of hidden units per DNN layer.\n dnn_activation_fn: Activation function applied to each DNN layer. If `None`,\n will use `tf.nn.relu`.\n dnn_dropout: When not `None`, the probability we will drop out a given DNN\n coordinate.\n input_layer_partitioner: Partitioner for input layer.\n config: `RunConfig` object to configure the runtime settings.\n batch_norm: Whether to use batch normalization after each hidden layer.\n linear_sparse_combiner: A string specifying how to reduce the linear model\n if a categorical column is multivalent. One of \"mean\", \"sqrtn\", and\n \"sum\".\n Returns:\n An `EstimatorSpec` instance.\n\n Raises:\n ValueError: If both `linear_feature_columns` and `dnn_features_columns`\n are empty at the same time, or `input_layer_partitioner` is missing,\n or features has the wrong type.\n \"\"\"\n if not isinstance(features, dict):\n raise ValueError('features should be a dictionary of `Tensor`s. '\n 'Given type: {}'.format(type(features)))\n if not linear_feature_columns and not dnn_feature_columns:\n raise ValueError(\n 'Either linear_feature_columns or dnn_feature_columns must be defined.')\n\n num_ps_replicas = config.num_ps_replicas if config else 0\n input_layer_partitioner = input_layer_partitioner or (\n partitioned_variables.min_max_variable_partitioner(\n max_partitions=num_ps_replicas,\n min_slice_size=64 << 20))\n\n # Build DNN Logits.\n dnn_parent_scope = 'dnn'\n\n if not dnn_feature_columns:\n dnn_logits = None\n else:\n dnn_optimizer = optimizers.get_optimizer_instance(\n dnn_optimizer, learning_rate=_DNN_LEARNING_RATE)\n _check_no_sync_replicas_optimizer(dnn_optimizer)\n if not dnn_hidden_units:\n raise ValueError(\n 'dnn_hidden_units must be defined when dnn_feature_columns is '\n 'specified.')\n dnn_partitioner = (\n partitioned_variables.min_max_variable_partitioner(\n max_partitions=num_ps_replicas))\n with variable_scope.variable_scope(\n dnn_parent_scope,\n values=tuple(six.itervalues(features)),\n partitioner=dnn_partitioner) as scope:\n dnn_absolute_scope = scope.name\n dnn_logit_fn = dnn.dnn_logit_fn_builder(\n units=head.logits_dimension,\n hidden_units=dnn_hidden_units,\n feature_columns=dnn_feature_columns,\n activation_fn=dnn_activation_fn,\n dropout=dnn_dropout,\n batch_norm=batch_norm,\n input_layer_partitioner=input_layer_partitioner)\n dnn_logits = dnn_logit_fn(features=features, mode=mode)\n\n linear_parent_scope = 'linear'\n\n if not linear_feature_columns:\n linear_logits = None\n else:\n linear_optimizer = optimizers.get_optimizer_instance(\n linear_optimizer,\n learning_rate=_linear_learning_rate(len(linear_feature_columns)))\n _check_no_sync_replicas_optimizer(linear_optimizer)\n with variable_scope.variable_scope(\n linear_parent_scope,\n values=tuple(six.itervalues(features)),\n partitioner=input_layer_partitioner) as scope:\n linear_absolute_scope = scope.name\n logit_fn = linear.linear_logit_fn_builder(\n units=head.logits_dimension,\n feature_columns=linear_feature_columns,\n sparse_combiner=linear_sparse_combiner)\n linear_logits = logit_fn(features=features)\n _add_layer_summary(linear_logits, scope.name)\n\n # Combine logits and build full model.\n if dnn_logits is not None and linear_logits is not None:\n logits = dnn_logits + linear_logits\n elif dnn_logits is not None:\n logits = dnn_logits\n else:\n logits = linear_logits\n\n def _train_op_fn(loss):\n \"\"\"Returns the op to optimize the loss.\"\"\"\n train_ops = []\n global_step = training_util.get_global_step()\n if dnn_logits is not None:\n train_ops.append(\n dnn_optimizer.minimize(\n loss,\n var_list=ops.get_collection(\n ops.GraphKeys.TRAINABLE_VARIABLES,\n scope=dnn_absolute_scope)))\n if linear_logits is not None:\n train_ops.append(\n linear_optimizer.minimize(\n loss,\n var_list=ops.get_collection(\n ops.GraphKeys.TRAINABLE_VARIABLES,\n scope=linear_absolute_scope)))\n\n train_op = control_flow_ops.group(*train_ops)\n with ops.control_dependencies([train_op]):\n return state_ops.assign_add(global_step, 1).op\n\n return head.create_estimator_spec(\n features=features,\n mode=mode,\n labels=labels,\n train_op_fn=_train_op_fn,\n logits=logits)\n\n\n@estimator_export('estimator.DNNLinearCombinedClassifier', v1=[])\nclass DNNLinearCombinedClassifierV2(estimator.EstimatorV2):\n \"\"\"An estimator for TensorFlow Linear and DNN joined classification models.\n\n Note: This estimator is also known as wide-n-deep.\n\n Example:\n\n ```python\n numeric_feature = numeric_column(...)\n categorical_column_a = categorical_column_with_hash_bucket(...)\n categorical_column_b = categorical_column_with_hash_bucket(...)\n\n categorical_feature_a_x_categorical_feature_b = crossed_column(...)\n categorical_feature_a_emb = embedding_column(\n categorical_column=categorical_feature_a, ...)\n categorical_feature_b_emb = embedding_column(\n categorical_id_column=categorical_feature_b, ...)\n\n estimator = DNNLinearCombinedClassifier(\n # wide settings\n linear_feature_columns=[categorical_feature_a_x_categorical_feature_b],\n linear_optimizer=tf.train.FtrlOptimizer(...),\n # deep settings\n dnn_feature_columns=[\n categorical_feature_a_emb, categorical_feature_b_emb,\n numeric_feature],\n dnn_hidden_units=[1000, 500, 100],\n dnn_optimizer=tf.train.ProximalAdagradOptimizer(...),\n # warm-start settings\n warm_start_from=\"/path/to/checkpoint/dir\")\n\n # To apply L1 and L2 regularization, you can set dnn_optimizer to:\n tf.train.ProximalAdagradOptimizer(\n learning_rate=0.1,\n l1_regularization_strength=0.001,\n l2_regularization_strength=0.001)\n # To apply learning rate decay, you can set dnn_optimizer to a callable:\n lambda: tf.AdamOptimizer(\n learning_rate=tf.exponential_decay(\n learning_rate=0.1,\n global_step=tf.get_global_step(),\n decay_steps=10000,\n decay_rate=0.96)\n # It is the same for linear_optimizer.\n\n # Input builders\n def input_fn_train:\n # Returns tf.data.Dataset of (x, y) tuple where y represents label's class\n # index.\n pass\n def input_fn_eval:\n # Returns tf.data.Dataset of (x, y) tuple where y represents label's class\n # index.\n pass\n def input_fn_predict:\n # Returns tf.data.Dataset of (x, None) tuple.\n pass\n estimator.train(input_fn=input_fn_train, steps=100)\n metrics = estimator.evaluate(input_fn=input_fn_eval, steps=10)\n predictions = estimator.predict(input_fn=input_fn_predict)\n ```\n\n Input of `train` and `evaluate` should have following features,\n otherwise there will be a `KeyError`:\n\n * for each `column` in `dnn_feature_columns` + `linear_feature_columns`:\n - if `column` is a `_CategoricalColumn`, a feature with `key=column.name`\n whose `value` is a `SparseTensor`.\n - if `column` is a `_WeightedCategoricalColumn`, two features: the first\n with `key` the id column name, the second with `key` the weight column\n name. Both features' `value` must be a `SparseTensor`.\n - if `column` is a `_DenseColumn`, a feature with `key=column.name`\n whose `value` is a `Tensor`.\n\n Loss is calculated by using softmax cross entropy.\n\n @compatibility(eager)\n Estimators can be used while eager execution is enabled. Note that `input_fn`\n and all hooks are executed inside a graph context, so they have to be written\n to be compatible with graph mode. Note that `input_fn` code using `tf.data`\n generally works in both graph and eager modes.\n @end_compatibility\n \"\"\"\n\n def __init__(self,\n model_dir=None,\n linear_feature_columns=None,\n linear_optimizer='Ftrl',\n dnn_feature_columns=None,\n dnn_optimizer='Adagrad',\n dnn_hidden_units=None,\n dnn_activation_fn=nn.relu,\n dnn_dropout=None,\n n_classes=2,\n weight_column=None,\n label_vocabulary=None,\n config=None,\n warm_start_from=None,\n loss_reduction=losses_utils.ReductionV2.SUM_OVER_BATCH_SIZE,\n batch_norm=False,\n linear_sparse_combiner='sum'):\n \"\"\"Initializes a DNNLinearCombinedClassifier instance.\n\n Args:\n model_dir: Directory to save model parameters, graph and etc. This can\n also be used to load checkpoints from the directory into a estimator\n to continue training a previously saved model.\n linear_feature_columns: An iterable containing all the feature columns\n used by linear part of the model. All items in the set must be\n instances of classes derived from `FeatureColumn`.\n linear_optimizer: An instance of `tf.Optimizer` used to apply gradients to\n the linear part of the model. Can also be a string (one of 'Adagrad',\n 'Adam', 'Ftrl', 'RMSProp', 'SGD'), or callable. Defaults to FTRL\n optimizer.\n dnn_feature_columns: An iterable containing all the feature columns used\n by deep part of the model. All items in the set must be instances of\n classes derived from `FeatureColumn`.\n dnn_optimizer: An instance of `tf.Optimizer` used to apply gradients to\n the deep part of the model. Can also be a string (one of 'Adagrad',\n 'Adam', 'Ftrl', 'RMSProp', 'SGD'), or callable. Defaults to Adagrad\n optimizer.\n dnn_hidden_units: List of hidden units per layer. All layers are fully\n connected.\n dnn_activation_fn: Activation function applied to each layer. If None,\n will use `tf.nn.relu`.\n dnn_dropout: When not None, the probability we will drop out\n a given coordinate.\n n_classes: Number of label classes. Defaults to 2, namely binary\n classification. Must be > 1.\n weight_column: A string or a `_NumericColumn` created by\n `tf.feature_column.numeric_column` defining feature column representing\n weights. It is used to down weight or boost examples during training. It\n will be multiplied by the loss of the example. If it is a string, it is\n used as a key to fetch weight tensor from the `features`. If it is a\n `_NumericColumn`, raw tensor is fetched by key `weight_column.key`,\n then weight_column.normalizer_fn is applied on it to get weight tensor.\n label_vocabulary: A list of strings represents possible label values. If\n given, labels must be string type and have any value in\n `label_vocabulary`. If it is not given, that means labels are\n already encoded as integer or float within [0, 1] for `n_classes=2` and\n encoded as integer values in {0, 1,..., n_classes-1} for `n_classes`>2 .\n Also there will be errors if vocabulary is not provided and labels are\n string.\n config: RunConfig object to configure the runtime settings.\n warm_start_from: A string filepath to a checkpoint to warm-start from, or\n a `WarmStartSettings` object to fully configure warm-starting. If the\n string filepath is provided instead of a `WarmStartSettings`, then all\n weights are warm-started, and it is assumed that vocabularies and Tensor\n names are unchanged.\n loss_reduction: One of `tf.losses.Reduction` except `NONE`. Describes how\n to reduce training loss over batch. Defaults to `SUM_OVER_BATCH_SIZE`.\n batch_norm: Whether to use batch normalization after each hidden layer.\n linear_sparse_combiner: A string specifying how to reduce the linear model\n if a categorical column is multivalent. One of \"mean\", \"sqrtn\", and\n \"sum\" -- these are effectively different ways to do example-level\n normalization, which can be useful for bag-of-words features. For more\n details, see `tf.feature_column.linear_model`.\n\n Raises:\n ValueError: If both linear_feature_columns and dnn_features_columns are\n empty at the same time.\n \"\"\"\n self._feature_columns = _validate_feature_columns(\n linear_feature_columns=linear_feature_columns,\n dnn_feature_columns=dnn_feature_columns)\n\n head = head_utils.binary_or_multi_class_head(\n n_classes, weight_column=weight_column,\n label_vocabulary=label_vocabulary,\n loss_reduction=loss_reduction)\n\n def _model_fn(features, labels, mode, config):\n \"\"\"Call the _dnn_linear_combined_model_fn.\"\"\"\n return _dnn_linear_combined_model_fn_v2(\n features=features,\n labels=labels,\n mode=mode,\n head=head,\n linear_feature_columns=linear_feature_columns,\n linear_optimizer=linear_optimizer,\n dnn_feature_columns=dnn_feature_columns,\n dnn_optimizer=dnn_optimizer,\n dnn_hidden_units=dnn_hidden_units,\n dnn_activation_fn=dnn_activation_fn,\n dnn_dropout=dnn_dropout,\n config=config,\n batch_norm=batch_norm,\n linear_sparse_combiner=linear_sparse_combiner)\n\n super(DNNLinearCombinedClassifierV2, self).__init__(\n model_fn=_model_fn,\n model_dir=model_dir,\n config=config,\n warm_start_from=warm_start_from)\n\n\n@estimator_export(v1=['estimator.DNNLinearCombinedClassifier']) # pylint: disable=missing-docstring\nclass DNNLinearCombinedClassifier(estimator.Estimator):\n __doc__ = DNNLinearCombinedClassifierV2.__doc__.replace(\n 'SUM_OVER_BATCH_SIZE', 'SUM')\n\n def __init__(self,\n model_dir=None,\n linear_feature_columns=None,\n linear_optimizer='Ftrl',\n dnn_feature_columns=None,\n dnn_optimizer='Adagrad',\n dnn_hidden_units=None,\n dnn_activation_fn=nn.relu,\n dnn_dropout=None,\n n_classes=2,\n weight_column=None,\n label_vocabulary=None,\n input_layer_partitioner=None,\n config=None,\n warm_start_from=None,\n loss_reduction=losses.Reduction.SUM,\n batch_norm=False,\n linear_sparse_combiner='sum'):\n self._feature_columns = _validate_feature_columns(\n linear_feature_columns=linear_feature_columns,\n dnn_feature_columns=dnn_feature_columns)\n\n head = head_lib._binary_logistic_or_multi_class_head( # pylint: disable=protected-access\n n_classes, weight_column, label_vocabulary, loss_reduction)\n\n def _model_fn(features, labels, mode, config):\n \"\"\"Call the _dnn_linear_combined_model_fn.\"\"\"\n return _dnn_linear_combined_model_fn(\n features=features,\n labels=labels,\n mode=mode,\n head=head,\n linear_feature_columns=linear_feature_columns,\n linear_optimizer=linear_optimizer,\n dnn_feature_columns=dnn_feature_columns,\n dnn_optimizer=dnn_optimizer,\n dnn_hidden_units=dnn_hidden_units,\n dnn_activation_fn=dnn_activation_fn,\n dnn_dropout=dnn_dropout,\n input_layer_partitioner=input_layer_partitioner,\n config=config,\n batch_norm=batch_norm,\n linear_sparse_combiner=linear_sparse_combiner)\n\n super(DNNLinearCombinedClassifier, self).__init__(\n model_fn=_model_fn,\n model_dir=model_dir,\n config=config,\n warm_start_from=warm_start_from)\n\n\ndef _init_dnn_linear_combined_estimator(\n head,\n linear_feature_columns,\n linear_optimizer,\n dnn_feature_columns,\n dnn_optimizer,\n dnn_hidden_units,\n dnn_activation_fn,\n dnn_dropout,\n input_layer_partitioner,\n linear_sparse_combiner):\n \"\"\"Helper function for the initialization of DNNLinearCombinedEstimator.\"\"\"\n linear_feature_columns = linear_feature_columns or []\n dnn_feature_columns = dnn_feature_columns or []\n feature_columns = (\n list(linear_feature_columns) + list(dnn_feature_columns))\n if not feature_columns:\n raise ValueError('Either linear_feature_columns or dnn_feature_columns '\n 'must be defined.')\n\n def _model_fn(features, labels, mode, config):\n \"\"\"Call the _dnn_linear_combined_model_fn.\"\"\"\n return _dnn_linear_combined_model_fn(\n features=features,\n labels=labels,\n mode=mode,\n head=head,\n linear_feature_columns=linear_feature_columns,\n linear_optimizer=linear_optimizer,\n dnn_feature_columns=dnn_feature_columns,\n dnn_optimizer=dnn_optimizer,\n dnn_hidden_units=dnn_hidden_units,\n dnn_activation_fn=dnn_activation_fn,\n dnn_dropout=dnn_dropout,\n input_layer_partitioner=input_layer_partitioner,\n config=config,\n linear_sparse_combiner=linear_sparse_combiner)\n return feature_columns, _model_fn\n\n\n# TODO(b/117517419): Update these contrib references once head moves to core.\n# Also references to the \"_Head\" class need to be replaced with \"Head\".\n@estimator_export('estimator.DNNLinearCombinedEstimator', v1=[])\nclass DNNLinearCombinedEstimatorV2(estimator.EstimatorV2):\n \"\"\"An estimator for TensorFlow Linear and DNN joined models with custom head.\n\n Note: This estimator is also known as wide-n-deep.\n\n Example:\n\n ```python\n numeric_feature = numeric_column(...)\n categorical_column_a = categorical_column_with_hash_bucket(...)\n categorical_column_b = categorical_column_with_hash_bucket(...)\n\n categorical_feature_a_x_categorical_feature_b = crossed_column(...)\n categorical_feature_a_emb = embedding_column(\n categorical_column=categorical_feature_a, ...)\n categorical_feature_b_emb = embedding_column(\n categorical_column=categorical_feature_b, ...)\n\n estimator = DNNLinearCombinedEstimator(\n head=tf.contrib.estimator.multi_label_head(n_classes=3),\n # wide settings\n linear_feature_columns=[categorical_feature_a_x_categorical_feature_b],\n linear_optimizer=tf.train.FtrlOptimizer(...),\n # deep settings\n dnn_feature_columns=[\n categorical_feature_a_emb, categorical_feature_b_emb,\n numeric_feature],\n dnn_hidden_units=[1000, 500, 100],\n dnn_optimizer=tf.train.ProximalAdagradOptimizer(...))\n\n # To apply L1 and L2 regularization, you can set dnn_optimizer to:\n tf.train.ProximalAdagradOptimizer(\n learning_rate=0.1,\n l1_regularization_strength=0.001,\n l2_regularization_strength=0.001)\n # To apply learning rate decay, you can set dnn_optimizer to a callable:\n lambda: tf.AdamOptimizer(\n learning_rate=tf.exponential_decay(\n learning_rate=0.1,\n global_step=tf.get_global_step(),\n decay_steps=10000,\n decay_rate=0.96)\n # It is the same for linear_optimizer.\n\n # Input builders\n def input_fn_train:\n # Returns tf.data.Dataset of (x, y) tuple where y represents label's class\n # index.\n pass\n def input_fn_eval:\n # Returns tf.data.Dataset of (x, y) tuple where y represents label's class\n # index.\n pass\n def input_fn_predict:\n # Returns tf.data.Dataset of (x, None) tuple.\n pass\n estimator.train(input_fn=input_fn_train, steps=100)\n metrics = estimator.evaluate(input_fn=input_fn_eval, steps=10)\n predictions = estimator.predict(input_fn=input_fn_predict)\n ```\n\n Input of `train` and `evaluate` should have following features,\n otherwise there will be a `KeyError`:\n\n * for each `column` in `dnn_feature_columns` + `linear_feature_columns`:\n - if `column` is a `_CategoricalColumn`, a feature with `key=column.name`\n whose `value` is a `SparseTensor`.\n - if `column` is a `_WeightedCategoricalColumn`, two features: the first\n with `key` the id column name, the second with `key` the weight column\n name. Both features' `value` must be a `SparseTensor`.\n - if `column` is a `_DenseColumn`, a feature with `key=column.name`\n whose `value` is a `Tensor`.\n\n Loss is calculated by using mean squared error.\n\n @compatibility(eager)\n Estimators can be used while eager execution is enabled. Note that `input_fn`\n and all hooks are executed inside a graph context, so they have to be written\n to be compatible with graph mode. Note that `input_fn` code using `tf.data`\n generally works in both graph and eager modes.\n @end_compatibility\n \"\"\"\n\n def __init__(self,\n head,\n model_dir=None,\n linear_feature_columns=None,\n linear_optimizer='Ftrl',\n dnn_feature_columns=None,\n dnn_optimizer='Adagrad',\n dnn_hidden_units=None,\n dnn_activation_fn=nn.relu,\n dnn_dropout=None,\n config=None,\n linear_sparse_combiner='sum'):\n \"\"\"Initializes a DNNLinearCombinedEstimator instance.\n\n Args:\n head: A `_Head` instance constructed with a method such as\n `tf.contrib.estimator.multi_label_head`.\n model_dir: Directory to save model parameters, graph and etc. This can\n also be used to load checkpoints from the directory into an estimator\n to continue training a previously saved model.\n linear_feature_columns: An iterable containing all the feature columns\n used by linear part of the model. All items in the set must be\n instances of classes derived from `FeatureColumn`.\n linear_optimizer: An instance of `tf.Optimizer` used to apply gradients to\n the linear part of the model. Can also be a string (one of 'Adagrad',\n 'Adam', 'Ftrl', 'RMSProp', 'SGD'), or callable. Defaults to FTRL\n optimizer.\n dnn_feature_columns: An iterable containing all the feature columns used\n by deep part of the model. All items in the set must be instances of\n classes derived from `FeatureColumn`.\n dnn_optimizer: An instance of `tf.Optimizer` used to apply gradients to\n the deep part of the model. Can also be a string (one of 'Adagrad',\n 'Adam', 'Ftrl', 'RMSProp', 'SGD'), or callable. Defaults to Adagrad\n optimizer.\n dnn_hidden_units: List of hidden units per layer. All layers are fully\n connected.\n dnn_activation_fn: Activation function applied to each layer. If None,\n will use `tf.nn.relu`.\n dnn_dropout: When not None, the probability we will drop out\n a given coordinate.\n config: RunConfig object to configure the runtime settings.\n linear_sparse_combiner: A string specifying how to reduce the linear model\n if a categorical column is multivalent. One of \"mean\", \"sqrtn\", and\n \"sum\" -- these are effectively different ways to do example-level\n normalization, which can be useful for bag-of-words features. For more\n details, see `tf.feature_column.linear_model`.\n\n Raises:\n ValueError: If both linear_feature_columns and dnn_features_columns are\n empty at the same time.\n \"\"\"\n self._feature_columns = _validate_feature_columns(\n linear_feature_columns=linear_feature_columns,\n dnn_feature_columns=dnn_feature_columns)\n\n def _model_fn(features, labels, mode, config):\n \"\"\"Call the _dnn_linear_combined_model_fn.\"\"\"\n return _dnn_linear_combined_model_fn_v2(\n features=features,\n labels=labels,\n mode=mode,\n head=head,\n linear_feature_columns=linear_feature_columns,\n linear_optimizer=linear_optimizer,\n dnn_feature_columns=dnn_feature_columns,\n dnn_optimizer=dnn_optimizer,\n dnn_hidden_units=dnn_hidden_units,\n dnn_activation_fn=dnn_activation_fn,\n dnn_dropout=dnn_dropout,\n config=config,\n linear_sparse_combiner=linear_sparse_combiner)\n\n super(DNNLinearCombinedEstimatorV2, self).__init__(\n model_fn=_model_fn,\n model_dir=model_dir,\n config=config)\n\n\n@estimator_export(v1=['estimator.DNNLinearCombinedEstimator']) # pylint: disable=missing-docstring\nclass DNNLinearCombinedEstimator(estimator.Estimator):\n __doc__ = DNNLinearCombinedEstimatorV2.__doc__\n\n def __init__(self,\n head,\n model_dir=None,\n linear_feature_columns=None,\n linear_optimizer='Ftrl',\n dnn_feature_columns=None,\n dnn_optimizer='Adagrad',\n dnn_hidden_units=None,\n dnn_activation_fn=nn.relu,\n dnn_dropout=None,\n input_layer_partitioner=None,\n config=None,\n linear_sparse_combiner='sum'):\n self._feature_columns = _validate_feature_columns(\n linear_feature_columns=linear_feature_columns,\n dnn_feature_columns=dnn_feature_columns)\n\n def _model_fn(features, labels, mode, config):\n \"\"\"Call the _dnn_linear_combined_model_fn.\"\"\"\n return _dnn_linear_combined_model_fn(\n features=features,\n labels=labels,\n mode=mode,\n head=head,\n linear_feature_columns=linear_feature_columns,\n linear_optimizer=linear_optimizer,\n dnn_feature_columns=dnn_feature_columns,\n dnn_optimizer=dnn_optimizer,\n dnn_hidden_units=dnn_hidden_units,\n dnn_activation_fn=dnn_activation_fn,\n dnn_dropout=dnn_dropout,\n input_layer_partitioner=input_layer_partitioner,\n config=config,\n linear_sparse_combiner=linear_sparse_combiner)\n\n super(DNNLinearCombinedEstimator, self).__init__(\n model_fn=_model_fn,\n model_dir=model_dir,\n config=config)\n\n\n@estimator_export('estimator.DNNLinearCombinedRegressor', v1=[])\nclass DNNLinearCombinedRegressorV2(estimator.EstimatorV2):\n \"\"\"An estimator for TensorFlow Linear and DNN joined models for regression.\n\n Note: This estimator is also known as wide-n-deep.\n\n Example:\n\n ```python\n numeric_feature = numeric_column(...)\n categorical_column_a = categorical_column_with_hash_bucket(...)\n categorical_column_b = categorical_column_with_hash_bucket(...)\n\n categorical_feature_a_x_categorical_feature_b = crossed_column(...)\n categorical_feature_a_emb = embedding_column(\n categorical_column=categorical_feature_a, ...)\n categorical_feature_b_emb = embedding_column(\n categorical_column=categorical_feature_b, ...)\n\n estimator = DNNLinearCombinedRegressor(\n # wide settings\n linear_feature_columns=[categorical_feature_a_x_categorical_feature_b],\n linear_optimizer=tf.train.FtrlOptimizer(...),\n # deep settings\n dnn_feature_columns=[\n categorical_feature_a_emb, categorical_feature_b_emb,\n numeric_feature],\n dnn_hidden_units=[1000, 500, 100],\n dnn_optimizer=tf.train.ProximalAdagradOptimizer(...),\n # warm-start settings\n warm_start_from=\"/path/to/checkpoint/dir\")\n\n # To apply L1 and L2 regularization, you can set dnn_optimizer to:\n tf.train.ProximalAdagradOptimizer(\n learning_rate=0.1,\n l1_regularization_strength=0.001,\n l2_regularization_strength=0.001)\n # To apply learning rate decay, you can set dnn_optimizer to a callable:\n lambda: tf.AdamOptimizer(\n learning_rate=tf.exponential_decay(\n learning_rate=0.1,\n global_step=tf.get_global_step(),\n decay_steps=10000,\n decay_rate=0.96)\n # It is the same for linear_optimizer.\n\n # Input builders\n def input_fn_train:\n # Returns tf.data.Dataset of (x, y) tuple where y represents label's class\n # index.\n pass\n def input_fn_eval:\n # Returns tf.data.Dataset of (x, y) tuple where y represents label's class\n # index.\n pass\n def input_fn_predict:\n # Returns tf.data.Dataset of (x, None) tuple.\n pass\n estimator.train(input_fn=input_fn_train, steps=100)\n metrics = estimator.evaluate(input_fn=input_fn_eval, steps=10)\n predictions = estimator.predict(input_fn=input_fn_predict)\n ```\n\n Input of `train` and `evaluate` should have following features,\n otherwise there will be a `KeyError`:\n\n * for each `column` in `dnn_feature_columns` + `linear_feature_columns`:\n - if `column` is a `_CategoricalColumn`, a feature with `key=column.name`\n whose `value` is a `SparseTensor`.\n - if `column` is a `_WeightedCategoricalColumn`, two features: the first\n with `key` the id column name, the second with `key` the weight column\n name. Both features' `value` must be a `SparseTensor`.\n - if `column` is a `_DenseColumn`, a feature with `key=column.name`\n whose `value` is a `Tensor`.\n\n Loss is calculated by using mean squared error.\n\n @compatibility(eager)\n Estimators can be used while eager execution is enabled. Note that `input_fn`\n and all hooks are executed inside a graph context, so they have to be written\n to be compatible with graph mode. Note that `input_fn` code using `tf.data`\n generally works in both graph and eager modes.\n @end_compatibility\n \"\"\"\n\n def __init__(self,\n model_dir=None,\n linear_feature_columns=None,\n linear_optimizer='Ftrl',\n dnn_feature_columns=None,\n dnn_optimizer='Adagrad',\n dnn_hidden_units=None,\n dnn_activation_fn=nn.relu,\n dnn_dropout=None,\n label_dimension=1,\n weight_column=None,\n config=None,\n warm_start_from=None,\n loss_reduction=losses_utils.ReductionV2.SUM_OVER_BATCH_SIZE,\n batch_norm=False,\n linear_sparse_combiner='sum'):\n \"\"\"Initializes a DNNLinearCombinedRegressor instance.\n\n Args:\n model_dir: Directory to save model parameters, graph and etc. This can\n also be used to load checkpoints from the directory into a estimator\n to continue training a previously saved model.\n linear_feature_columns: An iterable containing all the feature columns\n used by linear part of the model. All items in the set must be\n instances of classes derived from `FeatureColumn`.\n linear_optimizer: An instance of `tf.Optimizer` used to apply gradients to\n the linear part of the model. Can also be a string (one of 'Adagrad',\n 'Adam', 'Ftrl', 'RMSProp', 'SGD'), or callable. Defaults to FTRL\n optimizer.\n dnn_feature_columns: An iterable containing all the feature columns used\n by deep part of the model. All items in the set must be instances of\n classes derived from `FeatureColumn`.\n dnn_optimizer: An instance of `tf.Optimizer` used to apply gradients to\n the deep part of the model. Can also be a string (one of 'Adagrad',\n 'Adam', 'Ftrl', 'RMSProp', 'SGD'), or callable. Defaults to Adagrad\n optimizer.\n dnn_hidden_units: List of hidden units per layer. All layers are fully\n connected.\n dnn_activation_fn: Activation function applied to each layer. If None,\n will use `tf.nn.relu`.\n dnn_dropout: When not None, the probability we will drop out\n a given coordinate.\n label_dimension: Number of regression targets per example. This is the\n size of the last dimension of the labels and logits `Tensor` objects\n (typically, these have shape `[batch_size, label_dimension]`).\n weight_column: A string or a `_NumericColumn` created by\n `tf.feature_column.numeric_column` defining feature column representing\n weights. It is used to down weight or boost examples during training. It\n will be multiplied by the loss of the example. If it is a string, it is\n used as a key to fetch weight tensor from the `features`. If it is a\n `_NumericColumn`, raw tensor is fetched by key `weight_column.key`,\n then weight_column.normalizer_fn is applied on it to get weight tensor.\n config: RunConfig object to configure the runtime settings.\n warm_start_from: A string filepath to a checkpoint to warm-start from, or\n a `WarmStartSettings` object to fully configure warm-starting. If the\n string filepath is provided instead of a `WarmStartSettings`, then all\n weights are warm-started, and it is assumed that vocabularies and Tensor\n names are unchanged.\n loss_reduction: One of `tf.losses.Reduction` except `NONE`. Describes how\n to reduce training loss over batch. Defaults to `SUM_OVER_BATCH_SIZE`.\n batch_norm: Whether to use batch normalization after each hidden layer.\n linear_sparse_combiner: A string specifying how to reduce the linear model\n if a categorical column is multivalent. One of \"mean\", \"sqrtn\", and\n \"sum\" -- these are effectively different ways to do example-level\n normalization, which can be useful for bag-of-words features. For more\n details, see `tf.feature_column.linear_model`.\n\n Raises:\n ValueError: If both linear_feature_columns and dnn_features_columns are\n empty at the same time.\n \"\"\"\n self._feature_columns = _validate_feature_columns(\n linear_feature_columns=linear_feature_columns,\n dnn_feature_columns=dnn_feature_columns)\n\n head = regression_head.RegressionHead(\n label_dimension=label_dimension,\n weight_column=weight_column,\n loss_reduction=loss_reduction)\n\n def _model_fn(features, labels, mode, config):\n \"\"\"Call the _dnn_linear_combined_model_fn.\"\"\"\n return _dnn_linear_combined_model_fn_v2(\n features=features,\n labels=labels,\n mode=mode,\n head=head,\n linear_feature_columns=linear_feature_columns,\n linear_optimizer=linear_optimizer,\n dnn_feature_columns=dnn_feature_columns,\n dnn_optimizer=dnn_optimizer,\n dnn_hidden_units=dnn_hidden_units,\n dnn_activation_fn=dnn_activation_fn,\n dnn_dropout=dnn_dropout,\n config=config,\n batch_norm=batch_norm,\n linear_sparse_combiner=linear_sparse_combiner)\n\n super(DNNLinearCombinedRegressorV2, self).__init__(\n model_fn=_model_fn,\n model_dir=model_dir,\n config=config,\n warm_start_from=warm_start_from)\n\n\n@estimator_export(v1=['estimator.DNNLinearCombinedRegressor']) # pylint: disable=missing-docstring\nclass DNNLinearCombinedRegressor(estimator.Estimator):\n __doc__ = DNNLinearCombinedRegressorV2.__doc__.replace(\n 'SUM_OVER_BATCH_SIZE', 'SUM')\n\n def __init__(self,\n model_dir=None,\n linear_feature_columns=None,\n linear_optimizer='Ftrl',\n dnn_feature_columns=None,\n dnn_optimizer='Adagrad',\n dnn_hidden_units=None,\n dnn_activation_fn=nn.relu,\n dnn_dropout=None,\n label_dimension=1,\n weight_column=None,\n input_layer_partitioner=None,\n config=None,\n warm_start_from=None,\n loss_reduction=losses.Reduction.SUM,\n batch_norm=False,\n linear_sparse_combiner='sum'):\n self._feature_columns = _validate_feature_columns(\n linear_feature_columns=linear_feature_columns,\n dnn_feature_columns=dnn_feature_columns)\n\n head = head_lib._regression_head( # pylint: disable=protected-access\n label_dimension=label_dimension,\n weight_column=weight_column,\n loss_reduction=loss_reduction)\n\n def _model_fn(features, labels, mode, config):\n \"\"\"Call the _dnn_linear_combined_model_fn.\"\"\"\n return _dnn_linear_combined_model_fn(\n features=features,\n labels=labels,\n mode=mode,\n head=head,\n linear_feature_columns=linear_feature_columns,\n linear_optimizer=linear_optimizer,\n dnn_feature_columns=dnn_feature_columns,\n dnn_optimizer=dnn_optimizer,\n dnn_hidden_units=dnn_hidden_units,\n dnn_activation_fn=dnn_activation_fn,\n dnn_dropout=dnn_dropout,\n input_layer_partitioner=input_layer_partitioner,\n config=config,\n batch_norm=batch_norm,\n linear_sparse_combiner=linear_sparse_combiner)\n\n super(DNNLinearCombinedRegressor, self).__init__(\n model_fn=_model_fn,\n model_dir=model_dir,\n config=config,\n warm_start_from=warm_start_from)\n"
] | [
[
"numpy.linspace",
"tensorflow.python.data.ops.dataset_ops.Dataset.from_tensor_slices",
"tensorflow.python.framework.ops.Graph",
"tensorflow.python.data.ops.dataset_ops.make_one_shot_iterator",
"tensorflow.python.data.ops.dataset_ops.Dataset.zip",
"tensorflow.python.client.session.Session",
"tensorflow.python.platform.test.main",
"numpy.array"
],
[
"tensorflow.python.feature_column.feature_column_lib.categorical_column_with_hash_bucket",
"tensorflow.core.example.feature_pb2.BytesList",
"tensorflow.python.keras.layers.SimpleRNN",
"tensorflow.python.data.experimental.ops.readers.make_batched_features_dataset",
"tensorflow.python.training.monitored_session.MonitoredTrainingSession",
"tensorflow.python.ops.variables.Variable",
"tensorflow.python.platform.test.TestCase.__init__",
"tensorflow.python.platform.gfile.Exists",
"tensorflow.python.platform.test.mock.Mock",
"tensorflow.python.ops.math_ops.to_float",
"numpy.random.randint",
"tensorflow.python.keras.layers.StackedRNNCells",
"tensorflow.python.ops.math_ops.abs",
"tensorflow.python.feature_column.feature_column_lib.embedding_column",
"tensorflow.python.framework.ops.get_collection",
"tensorflow.python.keras.initializers.Zeros",
"tensorflow.python.framework.sparse_tensor.SparseTensor",
"tensorflow.python.platform.test.main",
"tensorflow.python.feature_column.feature_column_lib.sequence_categorical_column_with_identity",
"tensorflow.python.keras.optimizer_v2.adam.Adam",
"tensorflow.python.framework.ops.control_dependencies",
"tensorflow.python.ops.check_ops.assert_equal",
"tensorflow.core.example.feature_pb2.Int64List",
"tensorflow.python.framework.ops.convert_to_tensor",
"tensorflow.python.training.training_util.create_global_step",
"numpy.array",
"tensorflow.python.lib.io.python_io.TFRecordWriter",
"tensorflow.python.feature_column.feature_column_lib.numeric_column",
"tensorflow.python.keras.losses.BinaryCrossentropy",
"tensorflow.python.ops.check_ops.assert_less",
"tensorflow.python.feature_column.feature_column_lib.sequence_categorical_column_with_hash_bucket",
"tensorflow.python.framework.ops.Graph",
"tensorflow.python.framework.ops.name_scope",
"tensorflow.python.keras.initializers.Constant",
"tensorflow.python.platform.test.mock.patch.object",
"tensorflow.python.keras.layers.SimpleRNNCell",
"tensorflow.python.ops.variables.global_variables_initializer",
"tensorflow.python.feature_column.feature_column_lib.sequence_numeric_column"
],
[
"tensorflow.python.util.tf_export.estimator_export",
"tensorflow.python.summary.summary_iterator.summary_iterator",
"tensorflow.python.training.training_util.get_global_step",
"tensorflow.python.platform.tf_logging.info",
"tensorflow.python.framework.ops.control_dependencies",
"tensorflow.python.platform.gfile.Exists",
"tensorflow.python.ops.variable_scope.variable_scope",
"tensorflow.python.ops.state_ops.assign",
"tensorflow.python.ops.init_ops.constant_initializer",
"tensorflow.python.training.basic_session_run_hooks.SecondOrStepTimer",
"tensorflow.python.training.session_run_hook.SessionRunArgs"
],
[
"tensorflow.python.util.compat.as_str_any",
"tensorflow.python.platform.gfile.DeleteRecursively",
"tensorflow.python.platform.gfile.Exists",
"tensorflow.python.platform.test.mock.patch.object",
"tensorflow.python.platform.test.main",
"tensorflow.python.platform.test.get_temp_dir"
],
[
"tensorflow.python.util.tf_export.estimator_export",
"tensorflow.python.training.training_util.get_global_step",
"tensorflow.python.ops.control_flow_ops.group",
"tensorflow.python.training.training_util.get_or_create_global_step",
"tensorflow.python.ops.state_ops.assign_add",
"tensorflow.python.framework.ops.get_collection",
"tensorflow.python.summary.summary.histogram",
"tensorflow.python.ops.partitioned_variables.min_max_variable_partitioner",
"tensorflow.python.ops.nn.zero_fraction",
"tensorflow.python.framework.ops.control_dependencies"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"2.7",
"2.6",
"2.2",
"1.13",
"2.3",
"2.4",
"2.9",
"2.5",
"2.8",
"2.10"
]
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"2.8",
"2.7",
"2.6",
"2.4",
"2.3",
"2.9",
"2.5",
"2.2",
"2.10"
]
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"1.10",
"2.7",
"1.12",
"2.6",
"1.4",
"1.13",
"2.3",
"2.4",
"2.2",
"2.9",
"1.5",
"1.7",
"2.5",
"1.0",
"2.8",
"1.2",
"2.10"
]
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"2.8",
"1.10",
"1.12",
"2.7",
"2.6",
"1.4",
"1.13",
"2.3",
"2.4",
"2.9",
"1.5",
"1.7",
"2.5",
"0.12",
"1.0",
"2.2",
"1.2",
"2.10"
]
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"2.8",
"1.10",
"1.12",
"2.7",
"1.4",
"2.2",
"1.13",
"2.3",
"2.4",
"2.9",
"1.5",
"1.7",
"2.5",
"2.6",
"1.2",
"2.10"
]
}
] |
kavigupta/program_synthesis | [
"0b04b1d3b63954ba3d404a8d96c4da18667a1b02",
"0b04b1d3b63954ba3d404a8d96c4da18667a1b02"
] | [
"program_synthesis/algolisp/dataset/evaluation.py",
"program_synthesis/algolisp/dataset/dataset.py"
] | [
"import numpy as np\n\nfrom program_synthesis.algolisp.tools import bleu\nfrom program_synthesis.algolisp.dataset import executor\n\n\ndef is_same_code(example, res):\n correct = False\n if hasattr(res, 'code_sequence'):\n if res.code_sequence is not None:\n correct = res.code_sequence == example.code_sequence\n elif res.code_tree is not None:\n correct = res.code_tree == example.code_tree\n else:\n correct = res == example.code_sequence\n return correct\n\n\ndef compute_bleu(example, res):\n try:\n if hasattr(res, 'code_sequence'):\n if res.code_sequence is not None:\n score = bleu.compute_bleu([example.code_sequence], [res.code_sequence])\n else:\n score = bleu.compute_bleu([example.code_sequence], [res])\n return np.asscalar(score)\n except ZeroDivisionError:\n return 0.0\n\n\ndef get_stats_from_code(args):\n res, example, executor_ = args\n if len(example.tests) == 0:\n return None\n if executor_ is not None:\n stats = executor.evaluate_code(\n res.code_tree if res.code_tree else res.code_sequence, example.schema.args, example.tests,\n executor_)\n stats['exact-code-match'] = is_same_code(example, res)\n stats['correct-program'] = int(stats['tests-executed'] == stats['tests-passed'])\n else:\n stats = {'tests-executed': 0, 'tests-passed': 0, 'result-none': 0, 'syntax-error': 0,\n 'runtime-exception': 0, 'exceptions': []}\n stats['correct-program'] = stats['exact-code-match'] = is_same_code(example, res)\n stats['bleu'] = compute_bleu(example, res)\n stats['example'] = example.to_dict()\n stats['res'] = res.to_dict() if hasattr(res, 'to_dict') else res\n return stats\n\n\ndef run_inference(dataset, model, executor_):\n \"\"\"Runs inference of given model on eval set, and executes resulting code.\n\n Args:\n dataset: Dataset, iterable of CodeExample to evaluate on.\n model: Model that runs the inference.\n executor: executor class from executor.py.\n \"\"\"\n for batch in dataset:\n results = model.inference(batch)\n for stats in model.worker_pool.imap(get_stats_from_code, zip(results, batch, [executor_]*len(batch))):\n if stats is not None:\n yield stats\n return\n\n\ndef compute_metrics(all_stats):\n tests_num = 0\n programs_num = 0\n bleu_acc = 0.0\n correct_program_acc = 0\n # Almost correct programs are those that were executed on more than one test and passed at least 50% tests.\n almost_correct_program_acc = 0\n exact_code_match_acc = 0\n syntax_error_acc = 0\n runtime_exception_acc = 0\n other_exception_acc = 0\n for stats in all_stats:\n tests_num += stats['tests-executed']\n programs_num += 1\n bleu_acc += stats['bleu']\n correct_program_acc += stats['correct-program']\n if (stats['correct-program'] != 0 or\n stats['tests-executed'] > 1 and stats['tests-passed']/stats['tests-executed'] >= 0.5):\n almost_correct_program_acc += 1\n exact_code_match_acc += stats['exact-code-match']\n syntax_error_acc += stats['syntax-error']\n runtime_exception_acc += stats['runtime-exception']\n other_exception_acc += len(stats['exceptions'])\n\n return {'bleu': (bleu_acc/programs_num) if programs_num else 0.0,\n 'accuracy': (correct_program_acc/programs_num) if programs_num else 0.0,\n '50p_accuracy': (almost_correct_program_acc/programs_num) if programs_num else 0.0,\n 'exact_match_accuracy': (exact_code_match_acc/programs_num) if programs_num else 0.0,\n 'syntax_error_freq': (syntax_error_acc/tests_num) if tests_num else 0.0,\n 'runtime_exception_freq': (runtime_exception_acc/tests_num) if tests_num else 0.0,\n 'other_exception_freq': (other_exception_acc/tests_num) if tests_num else 0.0,\n 'programs_num': programs_num,\n 'tests_num': tests_num,\n 'correct_program_num': correct_program_acc,\n 'almost_correct_program_num': almost_correct_program_acc,\n 'exact_code_match_num': exact_code_match_acc,\n }\n",
"import argparse\nimport collections\nimport multiprocessing\nimport os\n\nimport numpy as np\nimport six\n\nif six.PY2:\n import cPickle as pickle\nelse:\n import pickle\nimport gzip\nimport random\nimport json\nimport time\n\nimport torch.utils.data\nfrom program_synthesis.algolisp.dataset import data\n\n\nSchema = collections.namedtuple(\"Schema\", [\"args\", \"return_type\"])\n\n\ndef _basepath(path):\n return os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(__file__)))), path)\n\n\ndef build_vocabs(data_, min_freq=50):\n \"\"\"Builds separate vocabs for text and code.\"\"\"\n word_freqs = collections.defaultdict(int)\n code_freqs = collections.defaultdict(int)\n for example in data_:\n for word in example.text:\n word_freqs[word] += 1\n for word in example.code_sequence:\n code_freqs[word] += 1\n return data.get_vocab(word_freqs, min_freq), data.get_vocab(code_freqs, min_freq)\n\n\ndef build_vocab(data_, min_freq=50):\n \"\"\"Builds single vocab.\"\"\"\n freqs = collections.defaultdict(int)\n def update_freqs(words):\n for word in words:\n freqs[word] += 1\n for example in data_:\n update_freqs(example.text)\n update_freqs(example.code_sequence)\n for column in example.schema.args.items():\n update_freqs(column)\n return data.get_vocab(freqs, min_freq)\n\n\nclass CodeFunc(object):\n\n def __init__(\n self, name, schema,\n code_tree, code_sequence):\n self.name = name\n self.schema = schema\n self.code_tree = code_tree\n self.code_sequence = code_sequence\n\n def to_dict(self):\n return {\n 'name': self.name,\n 'return_type': self.schema.return_type,\n 'args': [(name, type_) for name, type_ in self.schema.args.items()],\n 'code_tree': self.code_tree,\n }\n\n @classmethod\n def from_dict(cls, d):\n # TODO: Don't pass None for code_sequence\n return cls(d['name'],\n Schema(d['args'], d['return_type']), d['short_tree'], None)\n\n\nclass CodeExample(object):\n\n def __init__(\n self, text, schema, input_tests,\n code_tree, code_sequence, funcs=[], tests=[],\n candidate_code_sequence=None,\n task_types=[], tags=[], language='lisp'):\n self.text = text\n self.schema = schema\n self.input_tests = input_tests\n self.code_tree = code_tree\n self.code_sequence = code_sequence\n self.funcs = funcs\n self.tests = tests\n # Add candidate_code_tree in the future\n self.candidate_code_sequence = candidate_code_sequence\n self.task_types = task_types\n self.tags = tags\n self.language = language\n\n def to_dict(self):\n return {\n 'text': self.text,\n 'return_type': self.schema.return_type,\n 'args': [(arg, type_) for arg, type_ in self.schema.args.items()],\n 'code_sequence': self.code_sequence,\n 'code_tree': self.code_tree,\n 'funcs': [f.to_dict() for f in self.funcs],\n 'tests': self.input_tests + self.tests,\n 'tags': self.tags,\n 'nodes': self.task_types,\n 'language': self.language\n }\n\n @classmethod\n def from_dict(cls, d, input_test_ratio=0.7):\n input_test_count = int(len(d['tests']) * input_test_ratio)\n return cls(\n d['text'],\n Schema(d['args'], d['return_type']),\n d['tests'][:input_test_count],\n d['short_tree'],\n d['code_sequence'], [CodeFunc.from_dict(f) for f in d['funcs']],\n d['tests'][input_test_count:],\n task_types=d['nodes'],\n tags=d['tags'])\n\n\nclass NearDataset(object):\n\n def _line_to_code_example(self, line):\n try:\n line = json.loads(line)\n except ValueError:\n return None\n args = line['args']\n if not isinstance(args, dict):\n args = collections.OrderedDict(args)\n return_type = line.get('return_type', None)\n language = line['language'] if 'language' in line else 'lisp'\n if 'text' in line and line['text']:\n text = line['text']\n if not isinstance(text, list):\n try:\n text = data.tokenize_text_line(text)\n except Exception as e:\n print(\"Exception while tokenizing %s\" % text)\n print(e)\n return None\n elif 'statement' in line and line['statement']:\n try:\n text = data.tokenize_text_line(line['statement'])\n except Exception as e:\n print(\"Exception while tokenizing %s\" % line['statement'])\n print(e)\n return None\n else:\n text = []\n funcs = [\n CodeFunc(\n name=func['name'],\n schema=Schema(func['args'], func['return_type']),\n code_tree=func['short_tree'],\n code_sequence=data.flatten_code(func['short_tree']))\n for func in line['funcs']\n ] if 'funcs' in line else []\n\n code_tree = code_sequence = None\n if 'uast' in line and line['uast']:\n code_tree = line['uast']\n language = 'uast'\n if 'code_sequence' in line and line['code_sequence']:\n code_sequence = line['code_sequence']\n else:\n code_sequence = data.flatten_code(code_tree, language)\n elif 'short_tree' in line and line['short_tree']:\n code_tree = line['short_tree']\n code_sequence = data.flatten_code(code_tree, language)\n elif 'code_tree' in line and line['code_tree']:\n code_tree = line['code_tree']\n if isinstance(code_tree, dict):\n language = 'uast'\n if 'code_sequence' in line and line['code_sequence']:\n code_sequence = line['code_sequence']\n else:\n try:\n code_sequence = data.flatten_code(code_tree, language)\n except Exception as e:\n print(e)\n print(line['tags'])\n print(code_tree)\n raise\n elif 'code_sequence' in line:\n code_sequence = line['code_sequence']\n if not isinstance(code_sequence, list):\n code_sequence = data.tokenize_code_line(line['code_sequence'])\n\n if self.strip_brackets:\n code_sequence = [x for x in code_sequence if x not in ('(', ')', '[')]\n if self.filter_code_length > 0 and len(code_sequence) > self.filter_code_length:\n return None\n if self.max_code_length > 0 and code_sequence is not None:\n code_sequence = code_sequence[:self.max_code_length]\n\n if self.skip_empty_code and not code_tree and not code_sequence:\n print(\"Found no code in record: %s\" % line)\n return None\n\n if len(line['tests']) > 1:\n if len(line['tests']) < 4:\n split_idx = 1\n elif len(line['tests']) < 5:\n split_idx = 2\n else:\n split_idx = 3\n input_tests, tests = line['tests'][:split_idx], line['tests'][split_idx:]\n else:\n input_tests, tests = [], line['tests']\n\n example = CodeExample(\n text=text,\n schema=Schema(args, return_type),\n code_sequence=code_sequence,\n code_tree=code_tree,\n funcs=funcs,\n input_tests=input_tests,\n tests=tests,\n task_types=line['nodes'] if 'nodes' in line else [],\n tags=line['tags'] if 'tags' in line else [],\n language=language\n )\n\n if self.pseudocode_match:\n example.code_tree = base._prepare_code_tree(example.code_tree, True, False)\n example.match = example.text\n example.text = []\n return example\n\n def build_vocabs(self, min_freq=50, ignore_constants=False):\n return build_vocabs(self.data, min_freq)\n\n def build_vocab(self, min_freq=50):\n return build_vocab(self.data, min_freq)\n\n class TorchNearDataset(torch.utils.data.Dataset):\n def __init__(self, _len, _get_item):\n self._len = _len\n self._get_item = _get_item\n\n def __len__(self):\n return self._len()\n\n def __getitem__(self, idx):\n return self._get_item(idx)\n\n def augment_example(self, example):\n return example\n\n def _get_item(self, idx):\n if self.load_in_ram:\n return self.augment_example(self.cache[idx])\n else:\n offset = self.offsets[idx]\n self.f.seek(offset)\n line = self.f.readline()\n example = self._line_to_code_example(line)\n # This assert should always pass because we have filtered invalid examples when constructing offsets.\n assert example is not None\n return self.augment_example(example)\n\n def _len(self):\n return len(self.cache) if self.load_in_ram else len(self.offsets)\n\n def __init__(self, filename, args, shuffle=False, \n max_code_length=0, filter_code_length=0,\n skip_empty_code=True, \n pseudocode=False, strip_brackets=False,\n variable_shuffle=False,\n pseudocode_match=False,\n is_training=True):\n batch_size = args.batch_size\n max_size = getattr(args, 'dataset_max_size', 0)\n self.load_in_ram = getattr(args, 'dataset_load_in_ram', False)\n self.max_code_length = max_code_length\n self.filter_code_length = filter_code_length\n self.skip_empty_code = skip_empty_code\n self.pseudocode = pseudocode\n self.strip_brackets = strip_brackets\n self.variable_shuffle = variable_shuffle\n self.pseudocode_match = pseudocode_match\n self.f = open(filename)\n\n if self.load_in_ram:\n self.cache = []\n else:\n self.offsets = []\n\n with open(filename) as tmp_f:\n if self.pseudocode_match:\n templates = json.loads(tmp_f.readline())\n while True:\n # We should not use f as an iterator, because tell() will not work correctly\n # due to the read-ahead buffering. https://stackoverflow.com/a/19731163\n offset = tmp_f.tell()\n line = tmp_f.readline()\n if not line:\n break\n example = self._line_to_code_example(line)\n if example is not None:\n if self.load_in_ram:\n self.cache.append(example)\n else:\n self.offsets.append(offset)\n if max_size > 0 and self._len() >= max_size:\n break\n\n print(\"Loaded %s, total records: %d\" % (filename, self._len()))\n if self.pseudocode_match:\n templates = [base.CodeTemplate.from_dict(dct) for dct in templates]\n self.matcher = base.Matcher(templates, [])\n print(\"Loaded matcher with %d templates.\" % (len(templates)))\n\n # Create dataset and DataLoader using offset.\n self.data = NearDataset.TorchNearDataset(self._len, self._get_item)\n\n if args.dataset_bucketing:\n self.iterator = BucketIterator(\n dataset=self.data,\n batch_size=batch_size,\n sort_key=lambda ex: interleave_keys(len(ex.text), len(ex.code_sequence)),\n sort_within_batch_key=lambda ex: len(ex.text),\n shuffle=shuffle,\n sort_within_batch=True, # Sort in desc order using sort_key,\n marcobucket_size=args.dataset_macrobucket_size,\n sort_all=not is_training\n )\n else:\n def collate_fn(batch):\n # Sort sequences by their length so that we don't have to worry about packing/unpacking sequences.\n return sorted(batch, key=lambda ex: len(ex.text), reverse=True)\n self.iterator = torch.utils.data.DataLoader(self.data,\n batch_size=batch_size,\n # Note, unlike previous implementation of NearDataset, this\n # shuffle will reshuffle the data at each epoch.\n shuffle=shuffle,\n num_workers=0,\n collate_fn=collate_fn,\n drop_last=False)\n\n def __iter__(self):\n return self.iterator.__iter__()\n\n def __next__(self):\n return self.iterator.__iter__().__next__()\n\n def __len__(self):\n return self.iterator.__len__()\n\n\ndef get_metagen_dataset(args):\n args.code_vocab = args.word_vocab = _basepath('data/generated/word.vocab')\n train_data = NearDataset(\n _basepath('data/generated/metaset3.train.jsonl'),\n args, shuffle=True, max_code_length=getattr(args, 'dataset_max_code_length', 0),\n filter_code_length=getattr(args, 'dataset_filter_code_length', 0),\n is_training=True)\n if not os.path.exists(args.word_vocab):\n data.save_vocab(args.word_vocab, train_data.build_vocab(min_freq=args.vocab_min_freq))\n dev_data = NearDataset(\n _basepath('data/generated/metaset3.dev.jsonl'),\n args, shuffle=False,\n is_training=False)\n return train_data, dev_data\n\n\ndef get_metagen_eval_dataset(args):\n args.code_vocab = args.word_vocab = _basepath('data/generated/word.vocab')\n return NearDataset(\n _basepath('data/generated/metaset3.dev.jsonl'),\n args, shuffle=True,\n is_training=False)\n\n\ndef get_dataset(args):\n if args.dataset == 'metagen':\n return get_metagen_dataset(args)\n else:\n raise ValueError(\"Unknown dataset %s\" % args.dataset)\n\n\ndef get_eval_dataset(args):\n if args.dataset == 'handcrafted':\n return get_metagen_handcrafted_dataset(args)\n elif args.dataset == 'metagen':\n return get_metagen_eval_dataset(args)\n else:\n raise ValueError(\"Unknown dataset %s\" % args.dataset)\n\n\ndef dataset_split(args, dataset, filenames, proportions, dedup_non_first=False):\n def _renormalize(lst):\n total = sum(lst)\n return [float(x) / total for x in lst]\n datastats = [stats.DatasetStats(args) for _ in filenames]\n files = [open(filename, 'w') for filename in filenames]\n real_proportions = [x for x in proportions]\n candidates = list(range(len(proportions)))\n expected_size = [len(dataset.data) * p for p in proportions]\n for example in dataset.data:\n fidx = -1\n for i, s in enumerate(datastats):\n if (example.code_sequence and str(example.code_sequence) in s.code_map) or (example.text and str(example.text) in s.text_map):\n fidx = i\n # If this is not first file and we dedup the rest, skip duplicate solutions for this text.\n if fidx > 0 and dedup_non_first:\n continue\n if fidx == -1:\n fidx = np.random.choice(candidates, p=proportions)\n datastats[fidx].update(example)\n files[fidx].write(json.dumps(example.to_dict()) + \"\\n\")\n if datastats[fidx].stats['total'] >= expected_size[fidx] and fidx in candidates:\n idx = candidates.index(fidx)\n candidates.pop(idx)\n proportions.pop(idx)\n proportions = _renormalize(proportions)\n\n for f in files:\n f.close()\n for i, ds in enumerate(datastats):\n print(\"=== %.2f%% ===\" % real_proportions[i])\n ds.display()\n\n\nif __name__ == \"__main__\":\n parser = argparse.ArgumentParser(description='')\n parser.add_argument('--train-test-split', action='store_true', default=False)\n parser.add_argument('--train-dev-split', action='store_true', default=False)\n parser.add_argument('--original', type=str, default=None)\n parser.add_argument('--show_tags', action='store_true', default=False)\n parsed_args = parser.parse_args()\n\n dataset_args = collections.namedtuple('Args', ['batch_size'])(batch_size=1)\n\n base_name = '.'.join(parsed_args.original.split('.')[:-1])\n\n if parsed_args.train_test_split:\n d = NearDataset(parsed_args.original, dataset_args, shuffle=False, skip_empty_code=False)\n print(\"Loaded dataset from %s\" % parsed_args.original)\n dataset_split(\n parsed_args, d,\n [base_name + '.train.jsonl',\n base_name + '.dev.jsonl',\n base_name + '.test.jsonl'],\n [0.8, 0.1, 0.1])\n\n if parsed_args.train_dev_split:\n start = time.time()\n d = NearDataset(parsed_args.original, dataset_args, shuffle=True, skip_empty_code=False)\n print(\"Loaded dataset from %s in %ss\" % (parsed_args.original, time.time() - start))\n dataset_split(\n parsed_args, d,\n [base_name + '.train.jsonl',\n base_name + '.dev.jsonl'],\n [0.9, 0.1], dedup_non_first=True\n )\n"
] | [
[
"numpy.asscalar"
],
[
"numpy.random.choice"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
oliverkinch/dtu_mlops | [
"ce3a1f8f02ee95105b7b907735c39ad082321a4b"
] | [
"s2_organisation_and_version_control/exercise_files/typing_exercise_solution.py"
] | [
"from typing import Callable, Tuple, Union, Optional, List\nimport torch\nimport torch.nn.functional as F\nfrom torch import nn\n\n\nclass Network(nn.Module):\n def __init__(self, input_size: int, output_size: int, hidden_layers: List[int], drop_p: float = 0.5) -> None:\n ''' Builds a feedforward network with arbitrary hidden layers.\n \n Arguments\n ---------\n input_size: integer, size of the input layer\n output_size: integer, size of the output layer\n hidden_layers: list of integers, the sizes of the hidden layers\n \n '''\n super().__init__()\n # Input to a hidden layer\n self.hidden_layers = nn.ModuleList([nn.Linear(input_size, hidden_layers[0])])\n \n # Add a variable number of more hidden layers\n layer_sizes = zip(hidden_layers[:-1], hidden_layers[1:])\n self.hidden_layers.extend([nn.Linear(h1, h2) for h1, h2 in layer_sizes])\n \n self.output = nn.Linear(hidden_layers[-1], output_size)\n \n self.dropout = nn.Dropout(p=drop_p)\n \n def forward(self, x: torch.Tensor) -> torch.Tensor:\n ''' Forward pass through the network, returns the output logits '''\n \n for each in self.hidden_layers:\n x = F.relu(each(x))\n x = self.dropout(x)\n x = self.output(x)\n \n return F.log_softmax(x, dim=1)\n\n\ndef validation(\n model: nn.Module, \n testloader: torch.utils.data.DataLoader, \n criterion: Union[Callable, nn.Module]\n) -> Tuple[float, float]:\n accuracy = 0\n test_loss = 0\n for images, labels in testloader:\n\n images = images.resize_(images.size()[0], 784)\n\n output = model.forward(images)\n test_loss += criterion(output, labels).item()\n\n ## Calculating the accuracy \n # Model's output is log-softmax, take exponential to get the probabilities\n ps = torch.exp(output)\n # Class with highest probability is our predicted class, compare with true label\n equality = (labels.data == ps.max(1)[1])\n # Accuracy is number of correct predictions divided by all predictions, just take the mean\n accuracy += equality.type_as(torch.FloatTensor()).mean().item()\n\n return test_loss, accuracy\n\n\ndef train(\n model: nn.Module, \n trainloader: torch.utils.data.DataLoader, \n testloader: torch.utils.data.DataLoader, \n criterion: Union[Callable, nn.Module], \n optimizer: Optional[torch.optim.Optimizer] = None, \n epochs: int = 5, \n print_every: int = 40,\n) -> None:\n if optimizer is None:\n optimizer = torch.optim.Adam(model.parameters(), lr=1e-2)\n steps = 0\n running_loss = 0\n for e in range(epochs):\n # Model in training mode, dropout is on\n model.train()\n for images, labels in trainloader:\n steps += 1\n \n # Flatten images into a 784 long vector\n images.resize_(images.size()[0], 784)\n \n optimizer.zero_grad()\n \n output = model.forward(images)\n loss = criterion(output, labels)\n loss.backward()\n optimizer.step()\n \n running_loss += loss.item()\n\n if steps % print_every == 0:\n # Model in inference mode, dropout is off\n model.eval()\n \n # Turn off gradients for validation, will speed up inference\n with torch.no_grad():\n test_loss, accuracy = validation(model, testloader, criterion)\n \n print(\"Epoch: {}/{}.. \".format(e+1, epochs),\n \"Training Loss: {:.3f}.. \".format(running_loss/print_every),\n \"Test Loss: {:.3f}.. \".format(test_loss/len(testloader)),\n \"Test Accuracy: {:.3f}\".format(accuracy/len(testloader)))\n \n running_loss = 0\n \n # Make sure dropout and grads are on for training\n model.train()\n"
] | [
[
"torch.nn.Dropout",
"torch.nn.functional.log_softmax",
"torch.exp",
"torch.nn.Linear",
"torch.no_grad",
"torch.FloatTensor"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
yuyiming/mars | [
"5e6990d1ea022444dd646c56697e596ef5d7e747",
"5e6990d1ea022444dd646c56697e596ef5d7e747"
] | [
"mars/services/subtask/tests/test_service.py",
"mars/dataframe/datasource/from_records.py"
] | [
"# Copyright 1999-2021 Alibaba Group Holding 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 asyncio\nimport time\n\nimport numpy as np\nimport pytest\n\nfrom .... import oscar as mo\nfrom .... import tensor as mt\nfrom .... import remote as mr\nfrom ....core.graph import TileableGraph, TileableGraphBuilder, ChunkGraphBuilder\n\nfrom ....resource import Resource\nfrom ....utils import Timer\nfrom ... import start_services, stop_services, NodeRole\nfrom ...meta import MetaAPI\nfrom ...session import SessionAPI\nfrom ...storage import MockStorageAPI\nfrom ...task import new_task_id\nfrom ...task.supervisor.manager import TaskManagerActor\nfrom .. import SubtaskAPI, Subtask, SubtaskResult\n\n\nclass FakeTaskManager(TaskManagerActor):\n def set_subtask_result(self, subtask_result: SubtaskResult):\n return\n\n\ndef _gen_subtask(t, session_id):\n graph = TileableGraph([t.data])\n next(TileableGraphBuilder(graph).build())\n\n chunk_graph = next(ChunkGraphBuilder(graph, fuse_enabled=False).build())\n subtask = Subtask(new_task_id(), session_id, new_task_id(), chunk_graph)\n\n return subtask\n\n\[email protected]\nasync def actor_pools():\n async def start_pool(is_worker: bool):\n if is_worker:\n kw = dict(\n n_process=2,\n labels=[\"main\"] + [\"numa-0\"] * 2,\n subprocess_start_method=\"spawn\",\n )\n else:\n kw = dict(n_process=0, subprocess_start_method=\"spawn\")\n pool = await mo.create_actor_pool(\"127.0.0.1\", **kw)\n await pool.start()\n return pool\n\n sv_pool, worker_pool = await asyncio.gather(start_pool(False), start_pool(True))\n yield sv_pool, worker_pool\n await asyncio.gather(sv_pool.stop(), worker_pool.stop())\n\n\[email protected]\nasync def test_subtask_service(actor_pools):\n sv_pool, worker_pool = actor_pools\n\n config = {\n \"services\": [\n \"cluster\",\n \"session\",\n \"meta\",\n \"lifecycle\",\n \"scheduling\",\n \"subtask\",\n \"task\",\n \"mutable\",\n ],\n \"cluster\": {\n \"backend\": \"fixed\",\n \"lookup_address\": sv_pool.external_address,\n \"resource\": {\"numa-0\": Resource(num_cpus=2)},\n },\n \"meta\": {\"store\": \"dict\"},\n \"scheduling\": {},\n \"subtask\": {},\n }\n await start_services(NodeRole.SUPERVISOR, config, address=sv_pool.external_address)\n await start_services(NodeRole.WORKER, config, address=worker_pool.external_address)\n\n session_id = \"test_session\"\n session_api = await SessionAPI.create(sv_pool.external_address)\n await session_api.create_session(session_id)\n ref = await mo.actor_ref(\n FakeTaskManager.gen_uid(session_id), address=sv_pool.external_address\n )\n await mo.destroy_actor(ref)\n await mo.create_actor(\n FakeTaskManager,\n session_id,\n uid=FakeTaskManager.gen_uid(session_id),\n address=sv_pool.external_address,\n )\n\n subtask_api = await SubtaskAPI.create(worker_pool.external_address)\n # create mock meta and storage APIs\n meta_api = await MetaAPI.create(session_id, sv_pool.external_address)\n storage_api = await MockStorageAPI.create(session_id, worker_pool.external_address)\n\n a = mt.ones((10, 10), chunk_size=10)\n b = a + 1\n\n subtask = _gen_subtask(b, session_id)\n assert \"TensorAdd\" in repr(subtask)\n await subtask_api.run_subtask_in_slot(\"numa-0\", 0, subtask)\n\n # check storage\n expected = np.ones((10, 10)) + 1\n result_key = subtask.chunk_graph.results[0].key\n result = await storage_api.get(result_key)\n np.testing.assert_array_equal(expected, result)\n\n # check meta\n chunk_meta = await meta_api.get_chunk_meta(result_key)\n assert chunk_meta is not None\n assert chunk_meta[\"bands\"][0] == (worker_pool.external_address, \"numa-0\")\n\n def sleep(timeout: int):\n time.sleep(timeout)\n return timeout\n\n b = mr.spawn(sleep, 1)\n\n subtask2 = _gen_subtask(b, session_id)\n asyncio.create_task(subtask_api.run_subtask_in_slot(\"numa-0\", 0, subtask2))\n await asyncio.sleep(0.2)\n with Timer() as timer:\n # normal cancel by cancel asyncio Task\n await asyncio.wait_for(\n subtask_api.cancel_subtask_in_slot(\"numa-0\", 0), timeout=2\n )\n # need 1 sec to reach timeout, then killing actor and wait for auto recovering\n # the time would not be over 5 sec\n assert timer.duration < 2\n\n await MockStorageAPI.cleanup(worker_pool.external_address)\n await stop_services(NodeRole.WORKER, config, address=worker_pool.external_address)\n await stop_services(NodeRole.SUPERVISOR, config, address=sv_pool.external_address)\n",
"#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n# Copyright 1999-2021 Alibaba Group Holding 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 pandas as pd\n\nfrom ... import opcodes as OperandDef\nfrom ...core import OutputType\nfrom ...serialization.serializables import BoolField, ListField, Int32Field\nfrom ...tensor.core import TENSOR_TYPE\nfrom ..operands import DataFrameOperand, DataFrameOperandMixin\nfrom ..utils import parse_index\n\n\nclass DataFrameFromRecords(DataFrameOperand, DataFrameOperandMixin):\n _op_type_ = OperandDef.DATAFRAME_FROM_RECORDS\n\n _columns = ListField(\"columns\")\n _exclude = ListField(\"exclude\")\n _coerce_float = BoolField(\"coerce_float\")\n _nrows = Int32Field(\"nrows\")\n\n def __init__(\n self,\n index=None,\n columns=None,\n exclude=None,\n coerce_float=False,\n nrows=None,\n **kw\n ):\n if index is not None or columns is not None:\n raise NotImplementedError(\"Specifying index value is not supported for now\")\n super().__init__(\n _exclude=exclude,\n _columns=columns,\n _coerce_float=coerce_float,\n _nrows=nrows,\n _output_types=[OutputType.dataframe],\n **kw\n )\n\n @property\n def columns(self):\n return self._columns\n\n @property\n def exclude(self):\n return self._exclude\n\n @property\n def coerce_float(self):\n return self._coerce_float\n\n @property\n def nrows(self):\n return self._nrows\n\n def __call__(self, data):\n if self.nrows is None:\n nrows = data.shape[0]\n else:\n nrows = self.nrows\n index_value = parse_index(pd.RangeIndex(start=0, stop=nrows))\n dtypes = pd.Series(dict((k, np.dtype(v)) for k, v in data.dtype.descr))\n columns_value = parse_index(pd.Index(data.dtype.names), store_data=True)\n return self.new_dataframe(\n [data],\n (data.shape[0], len(data.dtype.names)),\n dtypes=dtypes,\n index_value=index_value,\n columns_value=columns_value,\n )\n\n @classmethod\n def tile(cls, op):\n df = op.outputs[0]\n tensor = op.inputs[0]\n\n nsplit_acc = np.cumsum(tensor.nsplits[0])\n out_chunks = []\n for chunk in tensor.chunks:\n begin_index = nsplit_acc[chunk.index[0]] - chunk.shape[0]\n end_index = nsplit_acc[chunk.index[0]]\n chunk_index_value = parse_index(\n pd.RangeIndex(start=begin_index, stop=end_index)\n )\n\n # Here the `new_chunk` is tricky:\n #\n # We can construct tensor that have identifcal chunks, for example, from `mt.ones(...)`, we know\n # that after tiling the chunk of the same shape (but at different position) in `mt.ones` is indeed\n # the same chunk (has the same key)!\n #\n # Thus, when we construct dataframe from such tensor, we will have dataframe chunks that only differ\n # in `index_value`. However the `index_value` field won't be used to calculate the chunk key of\n # the dataframe chunk, thus `new_chunk` generated the same keys for those indeed different chunks\n # (they have different `index_values`).\n #\n # Here, we construct new chunk with some unique `_extra_params` to make the `new_chunk` work as\n # expected.\n chunk_op = op.copy().reset_key()\n chunk_op.extra_params[\"begin_index\"] = begin_index\n chunk_op.extra_params[\"end_index\"] = end_index\n out_chunk = chunk_op.new_chunk(\n [chunk],\n shape=(chunk.shape[0], df.shape[1]),\n index=(chunk.index[0], 0),\n dtypes=df.dtypes,\n index_value=chunk_index_value,\n columns_value=df.columns_value,\n )\n out_chunks.append(out_chunk)\n\n new_op = op.copy()\n return new_op.new_dataframes(\n [tensor],\n df.shape,\n dtypes=df.dtypes,\n index_value=df.index_value,\n columns_value=df.columns_value,\n chunks=out_chunks,\n nsplits=[tensor.nsplits[0], [df.shape[1]]],\n )\n\n @classmethod\n def execute(cls, ctx, op):\n chunk = op.outputs[0]\n ctx[chunk.key] = pd.DataFrame.from_records(\n ctx[op.inputs[0].key],\n index=chunk.index_value.to_pandas(),\n columns=chunk.columns_value.to_pandas(),\n exclude=op.exclude,\n coerce_float=op.coerce_float,\n nrows=op.nrows,\n )\n\n\ndef from_records(\n data,\n index=None,\n exclude=None,\n columns=None,\n coerce_float=False,\n nrows=None,\n gpu=None,\n sparse=False,\n **kw\n):\n if isinstance(data, np.ndarray):\n from .dataframe import from_pandas\n\n return from_pandas(\n pd.DataFrame.from_records(\n data,\n index=index,\n exclude=exclude,\n columns=columns,\n coerce_float=coerce_float,\n nrows=nrows,\n ),\n **kw\n )\n elif isinstance(data, TENSOR_TYPE):\n if data.dtype.names is None:\n raise TypeError(\"Not a tensor with structured dtype {0}\", data.dtype)\n if data.ndim != 1:\n raise ValueError(\n \"Not a tensor with non 1-D structured dtype {0}\", data.shape\n )\n\n op = DataFrameFromRecords(\n index=None,\n exclude=exclude,\n columns=columns,\n coerce_float=coerce_float,\n nrows=nrows,\n gpu=gpu,\n sparse=sparse,\n **kw\n )\n return op(data)\n else:\n raise TypeError(\"Not support create DataFrame from {0}\", type(data))\n"
] | [
[
"numpy.testing.assert_array_equal",
"numpy.ones"
],
[
"pandas.RangeIndex",
"pandas.Index",
"numpy.cumsum",
"numpy.dtype",
"pandas.DataFrame.from_records"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [
"0.23",
"0.21",
"2.0",
"1.4",
"1.3",
"0.19",
"1.1",
"1.5",
"0.24",
"0.20",
"1.0",
"0.25",
"1.2"
],
"scipy": [],
"tensorflow": []
}
] |
emorynlp/stem-cell-hypothesis | [
"48a628093d93d653865fbac6409d179cddd99293",
"48a628093d93d653865fbac6409d179cddd99293",
"48a628093d93d653865fbac6409d179cddd99293"
] | [
"elit/components/srl/span_rank/span_ranking_srl_model.py",
"stem_cell_hypothesis/en_electra_base/head/vis/srl.py",
"stem_cell_hypothesis/en_bert_base/head/dep.py"
] | [
"from typing import Dict\n\nfrom alnlp.modules.feedforward import FeedForward\nfrom alnlp.modules.time_distributed import TimeDistributed\n\nfrom .highway_variational_lstm import *\nimport torch\nfrom alnlp.modules import util\n\nfrom ...parsers.biaffine.biaffine import Biaffine\n\n\ndef initializer_1d(input_tensor, initializer):\n assert len(input_tensor.size()) == 1\n input_tensor = input_tensor.view(-1, 1)\n input_tensor = initializer(input_tensor)\n return input_tensor.view(-1)\n\n\nclass SpanRankingSRLDecoder(nn.Module):\n\n def __init__(self, context_layer_output_dim, label_space_size, config) -> None:\n super().__init__()\n self.config = config\n self.label_space_size = label_space_size\n self.dropout = float(config.dropout)\n self.use_gold_predicates = config.use_gold_predicates\n # span width feature embedding\n self.span_width_embedding = nn.Embedding(self.config.max_arg_width, self.config.span_width_feature_size)\n # self.context_projective_layer = nn.Linear(2 * self.lstm_hidden_size, self.config.num_attention_heads)\n # span scores\n self.span_emb_size = 3 * context_layer_output_dim + self.config.span_width_feature_size\n self.arg_unary_score_layers = nn.ModuleList([nn.Linear(self.span_emb_size, self.config.ffnn_size) if i == 0\n else nn.Linear(self.config.ffnn_size, self.config.ffnn_size) for i\n in range(self.config.ffnn_depth)]) # [,150]\n self.arg_dropout_layers = nn.ModuleList([nn.Dropout(self.dropout) for _ in range(self.config.ffnn_depth)])\n self.arg_unary_score_projection = nn.Linear(self.config.ffnn_size, 1)\n # predicate scores\n self.pred_unary_score_layers = nn.ModuleList(\n [nn.Linear(context_layer_output_dim, self.config.ffnn_size) if i == 0\n else nn.Linear(self.config.ffnn_size, self.config.ffnn_size) for i\n in range(self.config.ffnn_depth)]) # [,150]\n self.pred_dropout_layers = nn.ModuleList([nn.Dropout(self.dropout) for _ in range(self.config.ffnn_depth)])\n self.pred_unary_score_projection = nn.Linear(self.config.ffnn_size, 1)\n # srl scores\n self.srl_unary_score_input_size = self.span_emb_size + context_layer_output_dim\n self.srl_unary_score_layers = nn.ModuleList([nn.Linear(self.srl_unary_score_input_size, self.config.ffnn_size)\n if i == 0 else nn.Linear(self.config.ffnn_size,\n self.config.ffnn_size)\n for i in range(self.config.ffnn_depth)])\n self.srl_dropout_layers = nn.ModuleList([nn.Dropout(self.dropout) for _ in range(self.config.ffnn_depth)])\n self.srl_unary_score_projection = nn.Linear(self.config.ffnn_size, self.label_space_size - 1)\n if config.use_biaffine:\n self.predicate_scale = TimeDistributed(FeedForward(context_layer_output_dim, 1, self.span_emb_size, 'ReLU'))\n self.biaffine = Biaffine(self.span_emb_size, self.label_space_size - 1)\n self.loss_reduction = config.loss_reduction\n self.reset_parameters()\n\n def reset_parameters(self):\n init.xavier_uniform_(self.span_width_embedding.weight)\n # init.xavier_uniform_(self.context_projective_layer.weight)\n # initializer_1d(self.context_projective_layer.bias, init.xavier_uniform_)\n\n for layer in self.arg_unary_score_layers:\n init.xavier_uniform_(layer.weight)\n initializer_1d(layer.bias, init.xavier_uniform_)\n init.xavier_uniform_(self.arg_unary_score_projection.weight)\n initializer_1d(self.arg_unary_score_projection.bias, init.xavier_uniform_)\n\n for layer in self.pred_unary_score_layers:\n init.xavier_uniform_(layer.weight)\n initializer_1d(layer.bias, init.xavier_uniform_)\n init.xavier_uniform_(self.pred_unary_score_projection.weight)\n initializer_1d(self.pred_unary_score_projection.bias, init.xavier_uniform_)\n\n for layer in self.srl_unary_score_layers:\n init.xavier_uniform_(layer.weight)\n initializer_1d(layer.bias, init.xavier_uniform_)\n init.xavier_uniform_(self.srl_unary_score_projection.weight)\n initializer_1d(self.srl_unary_score_projection.bias, init.xavier_uniform_)\n return None\n\n def forward(self, hidden_states, batch, mask=None):\n gold_arg_ends, gold_arg_labels, gold_arg_starts, gold_predicates, masks, sent_lengths = SpanRankingSRLModel.unpack(\n batch, mask=mask, training=self.training)\n return self.decode(hidden_states, sent_lengths, masks, gold_arg_starts, gold_arg_ends, gold_arg_labels,\n gold_predicates)\n\n @staticmethod\n def get_candidate_spans(sent_lengths: torch.Tensor, max_sent_length, max_arg_width):\n num_sentences = len(sent_lengths)\n device = sent_lengths.device\n candidate_starts = torch.arange(0, max_sent_length, device=device).expand(num_sentences, max_arg_width, -1)\n candidate_width = torch.arange(0, max_arg_width, device=device).view(1, -1, 1)\n candidate_ends = candidate_starts + candidate_width\n\n candidate_starts = candidate_starts.contiguous().view(num_sentences, max_sent_length * max_arg_width)\n candidate_ends = candidate_ends.contiguous().view(num_sentences, max_sent_length * max_arg_width)\n actual_sent_lengths = sent_lengths.view(-1, 1).expand(-1, max_sent_length * max_arg_width)\n candidate_mask = candidate_ends < actual_sent_lengths\n\n candidate_starts = candidate_starts * candidate_mask\n candidate_ends = candidate_ends * candidate_mask\n return candidate_starts, candidate_ends, candidate_mask\n\n @staticmethod\n def exclusive_cumsum(input: torch.Tensor, exclusive=True):\n \"\"\"\n\n Args:\n input: input is the sentence lengths tensor.\n exclusive: exclude the last sentence length (Default value = True)\n input(torch.Tensor :): \n input: torch.Tensor: \n\n Returns:\n\n \n \"\"\"\n assert exclusive is True\n if exclusive is True:\n exclusive_sent_lengths = input.new_zeros(1, dtype=torch.long)\n result = torch.cumsum(torch.cat([exclusive_sent_lengths, input], 0)[:-1], 0).view(-1, 1)\n else:\n result = torch.cumsum(input, 0).view(-1, 1)\n return result\n\n def flatten_emb(self, emb):\n num_sentences, max_sentence_length = emb.size()[0], emb.size()[1]\n assert len(emb.size()) == 3\n flatted_emb = emb.contiguous().view(num_sentences * max_sentence_length, -1)\n return flatted_emb\n\n def flatten_emb_in_sentence(self, emb, batch_sentences_mask):\n num_sentences, max_sentence_length = emb.size()[0], emb.size()[1]\n flatted_emb = self.flatten_emb(emb)\n return flatted_emb[batch_sentences_mask.reshape(num_sentences * max_sentence_length)]\n\n def get_span_emb(self, flatted_context_emb, flatted_candidate_starts, flatted_candidate_ends,\n config, dropout=0.0):\n batch_word_num = flatted_context_emb.size()[0]\n # gather slices from embeddings according to indices\n span_start_emb = flatted_context_emb[flatted_candidate_starts]\n span_end_emb = flatted_context_emb[flatted_candidate_ends]\n span_emb_feature_list = [span_start_emb, span_end_emb] # store the span vector representations for span rep.\n\n span_width = 1 + flatted_candidate_ends - flatted_candidate_starts # [num_spans], generate the span width\n max_arg_width = config.max_arg_width\n\n # get the span width feature emb\n span_width_index = span_width - 1\n span_width_emb = self.span_width_embedding(span_width_index)\n span_width_emb = F.dropout(span_width_emb, dropout, self.training)\n span_emb_feature_list.append(span_width_emb)\n\n \"\"\"head features\"\"\"\n cpu_flatted_candidte_starts = flatted_candidate_starts\n span_indices = torch.arange(0, max_arg_width, device=flatted_context_emb.device).view(1, -1) + \\\n cpu_flatted_candidte_starts.view(-1, 1) # For all the i, where i in [begin, ..i, end] for span\n # reset the position index to the batch_word_num index with index - 1\n span_indices = torch.clamp(span_indices, max=batch_word_num - 1)\n num_spans, spans_width = span_indices.size()[0], span_indices.size()[1]\n flatted_span_indices = span_indices.view(-1) # so Huge!!!, column is the span?\n # if torch.cuda.is_available():\n flatted_span_indices = flatted_span_indices\n span_text_emb = flatted_context_emb.index_select(0, flatted_span_indices).view(num_spans, spans_width, -1)\n span_indices_mask = util.lengths_to_mask(span_width, max_len=max_arg_width)\n # project context output to num head\n # head_scores = self.context_projective_layer.forward(flatted_context_emb)\n # get span attention\n # span_attention = head_scores.index_select(0, flatted_span_indices).view(num_spans, spans_width)\n # span_attention = torch.add(span_attention, expanded_span_indices_log_mask).unsqueeze(2) # control the span len\n # span_attention = F.softmax(span_attention, dim=1)\n span_text_emb = span_text_emb * span_indices_mask.unsqueeze(2).expand(-1, -1, span_text_emb.size()[-1])\n span_head_emb = torch.mean(span_text_emb, 1)\n span_emb_feature_list.append(span_head_emb)\n\n span_emb = torch.cat(span_emb_feature_list, 1)\n return span_emb, None, span_text_emb, span_indices, span_indices_mask\n\n def get_arg_unary_scores(self, span_emb):\n \"\"\"Compute span score with FFNN(span embedding)\n\n Args:\n span_emb: tensor of [num_sentences, num_spans, emb_size]\n config: param dropout:\n num_labels: param name:\n\n Returns:\n\n \n \"\"\"\n input = span_emb\n for i, ffnn in enumerate(self.arg_unary_score_layers):\n input = F.relu(ffnn.forward(input))\n input = self.arg_dropout_layers[i].forward(input)\n output = self.arg_unary_score_projection.forward(input)\n return output\n\n def get_pred_unary_scores(self, span_emb):\n input = span_emb\n for i, ffnn in enumerate(self.pred_unary_score_layers):\n input = F.relu(ffnn.forward(input))\n input = self.pred_dropout_layers[i].forward(input)\n output = self.pred_unary_score_projection.forward(input)\n return output\n\n def extract_spans(self, candidate_scores, candidate_starts, candidate_ends, topk, max_sentence_length,\n sort_spans, enforce_non_crossing):\n \"\"\"extract the topk span indices\n\n Args:\n candidate_scores: param candidate_starts:\n candidate_ends: param topk: [num_sentences]\n max_sentence_length: param sort_spans:\n enforce_non_crossing: return: indices [num_sentences, max_num_predictions]\n candidate_starts: \n topk: \n sort_spans: \n\n Returns:\n\n \n \"\"\"\n # num_sentences = candidate_scores.size()[0]\n # num_input_spans = candidate_scores.size()[1]\n max_num_output_spans = int(torch.max(topk))\n indices = [score.topk(k)[1] for score, k in zip(candidate_scores, topk)]\n output_span_indices_tensor = [F.pad(item, [0, max_num_output_spans - item.size()[0]], value=item[-1])\n for item in indices]\n output_span_indices_tensor = torch.stack(output_span_indices_tensor)\n return output_span_indices_tensor\n\n def batch_index_select(self, emb, indices):\n num_sentences = emb.size()[0]\n max_sent_length = emb.size()[1]\n flatten_emb = self.flatten_emb(emb)\n offset = (torch.arange(0, num_sentences, device=emb.device) * max_sent_length).unsqueeze(1)\n return torch.index_select(flatten_emb, 0, (indices + offset).view(-1)) \\\n .view(indices.size()[0], indices.size()[1], -1)\n\n def get_batch_topk(self, candidate_starts: torch.Tensor, candidate_ends, candidate_scores, topk_ratio, text_len,\n max_sentence_length, sort_spans=False, enforce_non_crossing=True):\n num_sentences = candidate_starts.size()[0]\n max_sentence_length = candidate_starts.size()[1]\n\n topk = torch.floor(text_len.to(torch.float) * topk_ratio).to(torch.long)\n topk = torch.max(topk, torch.ones(num_sentences, device=candidate_starts.device, dtype=torch.long))\n\n # this part should be implemented with C++\n predicted_indices = self.extract_spans(candidate_scores, candidate_starts, candidate_ends, topk,\n max_sentence_length, sort_spans, enforce_non_crossing)\n predicted_starts = torch.gather(candidate_starts, 1, predicted_indices)\n predicted_ends = torch.gather(candidate_ends, 1, predicted_indices)\n predicted_scores = torch.gather(candidate_scores, 1, predicted_indices)\n return predicted_starts, predicted_ends, predicted_scores, topk, predicted_indices\n\n def get_dense_span_labels(self, span_starts, span_ends, span_labels, max_sentence_length,\n span_parents=None):\n num_sentences = span_starts.size()[0]\n max_spans_num = span_starts.size()[1]\n\n # span_starts = span_starts + 1 - (span_labels > 0).to(torch.long)\n span_starts[(span_labels == 0) & (span_starts < max_sentence_length - 1)] += 1 # make start > end\n sentence_indices = torch.arange(0, num_sentences, device=span_starts.device).unsqueeze(1).expand(-1,\n max_spans_num)\n\n sparse_indices = torch.cat([sentence_indices.unsqueeze(2), span_starts.unsqueeze(2), span_ends.unsqueeze(2)],\n dim=2)\n if span_parents is not None: # semantic span predicate offset\n sparse_indices = torch.cat([sparse_indices, span_parents.unsqueeze(2)], 2)\n\n rank = 3 if span_parents is None else 4\n dense_labels = torch.sparse.LongTensor(sparse_indices.view(num_sentences * max_spans_num, rank).t(),\n span_labels.view(-1),\n torch.Size([num_sentences] + [max_sentence_length] * (rank - 1))) \\\n .to_dense()\n return dense_labels\n\n @staticmethod\n def gather_4d(params, indices):\n assert len(params.size()) == 4 and len(indices) == 4\n indices_a, indices_b, indices_c, indices_d = indices\n result = params[indices_a, indices_b, indices_c, indices_d]\n return result\n\n def get_srl_labels(self,\n arg_starts,\n arg_ends,\n predicates,\n gold_predicates,\n gold_arg_starts,\n gold_arg_ends,\n gold_arg_labels,\n max_sentence_length\n ):\n num_sentences = arg_starts.size()[0]\n max_arg_num = arg_starts.size()[1]\n max_pred_num = predicates.size()[1]\n\n sentence_indices_2d = torch.arange(0, num_sentences, device=arg_starts.device).unsqueeze(1).unsqueeze(2).expand(\n -1, max_arg_num, max_pred_num)\n expanded_arg_starts = arg_starts.unsqueeze(2).expand(-1, -1, max_pred_num)\n expanded_arg_ends = arg_ends.unsqueeze(2).expand(-1, -1, max_pred_num)\n expanded_predicates = predicates.unsqueeze(1).expand(-1, max_arg_num, -1)\n\n dense_srl_labels = self.get_dense_span_labels(gold_arg_starts,\n gold_arg_ends,\n gold_arg_labels,\n max_sentence_length, span_parents=gold_predicates) # ans\n srl_labels = self.gather_4d(dense_srl_labels,\n [sentence_indices_2d, expanded_arg_starts, expanded_arg_ends, expanded_predicates])\n return srl_labels\n\n def get_srl_unary_scores(self, span_emb):\n input = span_emb\n for i, ffnn in enumerate(self.srl_unary_score_layers):\n input = F.relu(ffnn.forward(input))\n input = self.srl_dropout_layers[i].forward(input)\n output = self.srl_unary_score_projection.forward(input)\n return output\n\n def get_srl_scores(self, arg_emb, pred_emb, arg_scores, pred_scores, num_labels, config, dropout):\n num_sentences = arg_emb.size()[0]\n num_args = arg_emb.size()[1] # [batch_size, max_arg_num, arg_emb_size]\n num_preds = pred_emb.size()[1] # [batch_size, max_pred_num, pred_emb_size]\n\n unsqueezed_arg_emb = arg_emb.unsqueeze(2)\n unsqueezed_pred_emb = pred_emb.unsqueeze(1)\n expanded_arg_emb = unsqueezed_arg_emb.expand(-1, -1, num_preds, -1)\n expanded_pred_emb = unsqueezed_pred_emb.expand(-1, num_args, -1, -1)\n pair_emb_list = [expanded_arg_emb, expanded_pred_emb]\n pair_emb = torch.cat(pair_emb_list, 3) # concatenate the argument emb and pre emb\n pair_emb_size = pair_emb.size()[3]\n flat_pair_emb = pair_emb.view(num_sentences * num_args * num_preds, pair_emb_size)\n # get unary scores\n flat_srl_scores = self.get_srl_unary_scores(flat_pair_emb)\n srl_scores = flat_srl_scores.view(num_sentences, num_args, num_preds, -1)\n if self.config.use_biaffine:\n srl_scores += self.biaffine(arg_emb, self.predicate_scale(pred_emb)).permute([0, 2, 3, 1])\n unsqueezed_arg_scores, unsqueezed_pred_scores = \\\n arg_scores.unsqueeze(2).unsqueeze(3), pred_scores.unsqueeze(1).unsqueeze(3)\n srl_scores = srl_scores + unsqueezed_arg_scores + unsqueezed_pred_scores\n dummy_scores = torch.zeros([num_sentences, num_args, num_preds, 1], device=arg_emb.device)\n srl_scores = torch.cat([dummy_scores, srl_scores], 3)\n return srl_scores\n\n def get_srl_softmax_loss(self, srl_scores, srl_labels, num_predicted_args, num_predicted_preds):\n srl_loss_mask = self.get_srl_loss_mask(srl_scores, num_predicted_args, num_predicted_preds)\n\n loss = torch.nn.functional.cross_entropy(srl_scores[srl_loss_mask], srl_labels[srl_loss_mask],\n reduction=self.loss_reduction)\n return loss, srl_loss_mask\n\n def get_srl_loss_mask(self, srl_scores, num_predicted_args, num_predicted_preds):\n max_num_arg = srl_scores.size()[1]\n max_num_pred = srl_scores.size()[2]\n # num_predicted_args, 1D tensor; max_num_arg: a int variable means the gold ans's max arg number\n args_mask = util.lengths_to_mask(num_predicted_args, max_num_arg)\n pred_mask = util.lengths_to_mask(num_predicted_preds, max_num_pred)\n srl_loss_mask = args_mask.unsqueeze(2) & pred_mask.unsqueeze(1)\n return srl_loss_mask\n\n def decode(self, contextualized_embeddings, sent_lengths, masks, gold_arg_starts, gold_arg_ends, gold_arg_labels,\n gold_predicates):\n num_sentences, max_sent_length = masks.size()\n device = sent_lengths.device\n \"\"\"generate candidate spans with argument pruning\"\"\"\n # candidate_starts [num_sentences, max_sent_length * max_arg_width]\n candidate_starts, candidate_ends, candidate_mask = self.get_candidate_spans(\n sent_lengths, max_sent_length, self.config.max_arg_width)\n flatted_candidate_mask = candidate_mask.view(-1)\n batch_word_offset = self.exclusive_cumsum(sent_lengths) # get the word offset in a batch\n # choose the flatted_candidate_starts with the actual existing positions, i.e. exclude the illegal starts\n flatted_candidate_starts = candidate_starts + batch_word_offset\n flatted_candidate_starts = flatted_candidate_starts.view(-1)[flatted_candidate_mask].to(torch.long)\n flatted_candidate_ends = candidate_ends + batch_word_offset\n flatted_candidate_ends = flatted_candidate_ends.view(-1)[flatted_candidate_mask].to(torch.long)\n # flatten the lstm output according to the sentence mask, i.e. exclude the illegal (padding) lstm output\n flatted_context_output = self.flatten_emb_in_sentence(contextualized_embeddings, masks)\n \"\"\"generate the span embedding\"\"\"\n candidate_span_emb, head_scores, span_head_emb, head_indices, head_indices_log_mask = self.get_span_emb(\n flatted_context_output, flatted_candidate_starts, flatted_candidate_ends,\n self.config, dropout=self.dropout)\n \"\"\"Get the span ids\"\"\"\n candidate_span_number = candidate_span_emb.size()[0]\n max_candidate_spans_num_per_sentence = candidate_mask.size()[1]\n sparse_indices = candidate_mask.nonzero(as_tuple=False)\n sparse_values = torch.arange(0, candidate_span_number, device=device)\n candidate_span_ids = torch.sparse.FloatTensor(sparse_indices.t(), sparse_values,\n torch.Size([num_sentences,\n max_candidate_spans_num_per_sentence])).to_dense()\n spans_log_mask = torch.log(candidate_mask.to(torch.float))\n predict_dict = {\"candidate_starts\": candidate_starts, \"candidate_ends\": candidate_ends,\n 'candidate_arg_mask': candidate_mask, \"head_scores\": head_scores}\n \"\"\"Get unary scores and topk of candidate argument spans.\"\"\"\n flatted_candidate_arg_scores = self.get_arg_unary_scores(candidate_span_emb)\n candidate_arg_scores = flatted_candidate_arg_scores.index_select(0, candidate_span_ids.view(-1)) \\\n .view(candidate_span_ids.size()[0], candidate_span_ids.size()[1])\n candidate_arg_scores = candidate_arg_scores + spans_log_mask\n arg_starts, arg_ends, arg_scores, num_args, top_arg_indices = \\\n self.get_batch_topk(candidate_starts, candidate_ends, candidate_arg_scores,\n self.config.argument_ratio, sent_lengths, max_sent_length,\n sort_spans=False, enforce_non_crossing=False)\n \"\"\"Get the candidate predicate\"\"\"\n candidate_pred_ids = torch.arange(0, max_sent_length, device=device).unsqueeze(0).expand(num_sentences, -1)\n candidate_pred_emb = contextualized_embeddings\n candidate_pred_scores = self.get_pred_unary_scores(candidate_pred_emb)\n candidate_pred_scores = candidate_pred_scores + torch.log(masks.to(torch.float).unsqueeze(2))\n candidate_pred_scores = candidate_pred_scores.squeeze(2)\n if self.use_gold_predicates is True:\n predicates = gold_predicates[0]\n num_preds = gold_predicates[1]\n pred_scores = torch.zeros_like(predicates)\n top_pred_indices = predicates\n else:\n predicates, _, pred_scores, num_preds, top_pred_indices = self.get_batch_topk(\n candidate_pred_ids, candidate_pred_ids, candidate_pred_scores, self.config.predicate_ratio,\n sent_lengths, max_sent_length,\n sort_spans=False, enforce_non_crossing=False)\n \"\"\"Get top arg embeddings\"\"\"\n arg_span_indices = torch.gather(candidate_span_ids, 1, top_arg_indices) # [num_sentences, max_num_args]\n arg_emb = candidate_span_emb.index_select(0, arg_span_indices.view(-1)).view(\n arg_span_indices.size()[0], arg_span_indices.size()[1], -1\n ) # [num_sentences, max_num_args, emb]\n \"\"\"Get top predicate embeddings\"\"\"\n pred_emb = self.batch_index_select(candidate_pred_emb,\n top_pred_indices) # [num_sentences, max_num_preds, emb]\n \"\"\"Get the srl scores according to the arg emb and pre emb.\"\"\"\n srl_scores = self.get_srl_scores(arg_emb, pred_emb, arg_scores, pred_scores, self.label_space_size, self.config,\n self.dropout) # [num_sentences, max_num_args, max_num_preds, num_labels]\n if gold_arg_labels is not None:\n \"\"\"Get the answers according to the labels\"\"\"\n srl_labels = self.get_srl_labels(arg_starts, arg_ends, predicates, gold_predicates, gold_arg_starts,\n gold_arg_ends, gold_arg_labels, max_sent_length)\n\n \"\"\"Compute the srl loss\"\"\"\n srl_loss, srl_mask = self.get_srl_softmax_loss(srl_scores, srl_labels, num_args, num_preds)\n predict_dict.update({\n 'srl_mask': srl_mask,\n 'loss': srl_loss\n })\n else:\n predict_dict['srl_mask'] = self.get_srl_loss_mask(srl_scores, num_args, num_preds)\n predict_dict.update({\n \"candidate_arg_scores\": candidate_arg_scores,\n \"candidate_pred_scores\": candidate_pred_scores,\n \"predicates\": predicates,\n \"arg_starts\": arg_starts,\n \"arg_ends\": arg_ends,\n \"arg_scores\": arg_scores,\n \"pred_scores\": pred_scores,\n \"num_args\": num_args,\n \"num_preds\": num_preds,\n \"arg_labels\": torch.max(srl_scores, 1)[1], # [num_sentences, num_args, num_preds]\n \"srl_scores\": srl_scores,\n })\n return predict_dict\n\n\nclass SpanRankingSRLModel(nn.Module):\n\n def __init__(self, config, embed: torch.nn.Module, context_layer: torch.nn.Module, label_space_size):\n super(SpanRankingSRLModel, self).__init__()\n self.config = config\n self.dropout = float(config.dropout)\n self.lexical_dropout = float(self.config.lexical_dropout)\n self.label_space_size = label_space_size\n\n # Initialize layers and parameters\n self.word_embedding_dim = embed.get_output_dim() # get the embedding dim\n self.embed = embed\n # Initialize context layer\n self.context_layer = context_layer\n context_layer_output_dim = context_layer.get_output_dim()\n self.decoder = SpanRankingSRLDecoder(context_layer_output_dim, label_space_size, config)\n\n def forward(self,\n batch: Dict[str, torch.Tensor]\n ):\n gold_arg_ends, gold_arg_labels, gold_arg_starts, gold_predicates, masks, sent_lengths = \\\n self.unpack(batch, training=self.training)\n\n context_embeddings = self.embed(batch)\n context_embeddings = F.dropout(context_embeddings, self.lexical_dropout, self.training)\n contextualized_embeddings = self.context_layer(context_embeddings, masks)\n\n return self.decoder.decode(contextualized_embeddings, sent_lengths, masks, gold_arg_starts, gold_arg_ends,\n gold_arg_labels, gold_predicates)\n\n @staticmethod\n def unpack(batch, mask=None, training=False):\n keys = 'token_length', 'predicate_offset', 'argument_begin_offset', 'argument_end_offset', 'srl_label_id'\n sent_lengths, gold_predicates, gold_arg_starts, gold_arg_ends, gold_arg_labels = [batch.get(k, None) for k in\n keys]\n if mask is None:\n mask = util.lengths_to_mask(sent_lengths)\n # elif not training:\n # sent_lengths = mask.sum(dim=1)\n return gold_arg_ends, gold_arg_labels, gold_arg_starts, gold_predicates, mask, sent_lengths\n",
"# -*- coding:utf-8 -*-\n# Author: hankcs\n# Date: 2021-05-11 19:50\nimport os\nfrom collections import defaultdict\n\nimport matplotlib.pyplot as plt\n\nprop_cycle = plt.rcParams['axes.prop_cycle']\nplt.rcParams[\"figure.figsize\"] = (4, 3)\nplt.rcParams.update({'font.size': 8})\n\ndef main():\n table = '''\n\tstatic\tsingle\tpos\tner\tdep\tcon\tjoint\nARG1\t79.86\t83.42 ± 0.52\t82.58 ± 0.60\t82.40 ± 0.42\t82.38 ± 0.61\t82.35 ± 0.90\t80.96 ± 0.43\nARG0\t83.62\t82.54 ± 1.34\t77.57 ± 1.05\t78.46 ± 0.16\t80.18 ± 0.98\t80.79 ± 1.03\t76.53 ± 2.01\nARG2\t78.97\t87.91 ± 0.79\t85.01 ± 1.70\t86.42 ± 0.43\t85.12 ± 0.97\t87.16 ± 1.21\t84.30 ± 1.70\nARGM-TMP\t66.43\t70.04 ± 0.89\t67.83 ± 2.67\t66.81 ± 2.18\t65.89 ± 1.50\t64.99 ± 2.50\t64.58 ± 1.26\nARGM-DIS\t53.21\t57.68 ± 6.55\t50.72 ± 4.17\t57.55 ± 5.80\t65.82 ± 2.23\t52.73 ± 3.04\t49.66 ± 3.58\nARGM-ADV\t41.46\t53.67 ± 2.96\t49.03 ± 4.43\t54.80 ± 1.66\t57.11 ± 2.07\t55.09 ± 1.18\t55.47 ± 2.27\nARGM-MOD\t74.32\t82.42 ± 1.44\t78.69 ± 2.18\t80.37 ± 1.49\t80.60 ± 0.45\t78.06 ± 0.75\t78.62 ± 1.20\nARGM-LOC\t70.40\t77.74 ± 0.26\t75.21 ± 0.29\t75.62 ± 1.35\t74.80 ± 0.07\t74.15 ± 1.61\t72.32 ± 1.78\nARGM-MNR\t75.31\t81.23 ± 1.87\t79.13 ± 0.36\t81.40 ± 1.29\t81.40 ± 1.30\t78.45 ± 0.41\t80.52 ± 0.81\nARGM-NEG\t78.57\t82.13 ± 2.09\t79.59 ± 1.35\t79.87 ± 1.16\t85.47 ± 2.26\t80.38 ± 0.78\t79.54 ± 0.73\nR-ARG1\t55.54\t71.93 ± 1.57\t67.32 ± 2.53\t74.38 ± 0.57\t75.46 ± 0.57\t71.93 ± 1.94\t73.78 ± 1.27\nR-ARG0\t70.70\t76.72 ± 3.28\t72.91 ± 3.26\t76.32 ± 1.23\t79.56 ± 0.74\t76.77 ± 1.02\t78.54 ± 1.80\nC-ARG1\t39.55\t46.65 ± 1.42\t52.07 ± 6.40\t48.55 ± 0.77\t50.78 ± 3.64\t46.79 ± 1.35\t44.22 ± 1.26\nARGM-PRP\t70.24\t77.94 ± 0.55\t72.78 ± 2.48\t77.94 ± 2.84\t80.56 ± 3.37\t77.86 ± 0.00\t74.84 ± 0.60\nARGM-DIR\t88.57\t92.06 ± 0.36\t91.11 ± 1.79\t91.98 ± 0.60\t91.82 ± 0.36\t91.19 ± 0.63\t91.66 ± 1.95\nARG3\t83.42\t90.55 ± 1.35\t86.72 ± 0.41\t88.32 ± 0.82\t90.11 ± 1.07\t88.24 ± 1.22\t85.74 ± 2.18\nARG4\t88.74\t93.04 ± 1.27\t91.94 ± 1.30\t93.23 ± 0.32\t92.13 ± 0.64\t91.12 ± 0.69\t91.76 ± 1.10\nARGM-CAU\t61.02\t71.38 ± 0.16\t67.61 ± 4.96\t73.73 ± 1.50\t82.58 ± 2.37\t77.78 ± 0.59\t76.18 ± 2.86\nARGM-PRD\t54.09\t61.48 ± 2.37\t55.12 ± 4.43\t59.79 ± 2.00\t62.26 ± 1.35\t61.61 ± 2.35\t58.75 ± 2.55\nARGM-ADJ\t76.00\t87.33 ± 0.23\t83.33 ± 4.97\t85.20 ± 0.40\t86.13 ± 0.23\t86.53 ± 0.23\t83.73 ± 2.44\nARGM-EXT\t87.58\t90.20 ± 1.13\t88.45 ± 1.36\t87.80 ± 1.00\t87.15 ± 1.00\t87.15 ± 0.38\t86.06 ± 1.00\nARGM-PNC\t69.74\t80.26 ± 0.00\t79.39 ± 2.74\t81.14 ± 0.76\t78.95 ± 4.56\t82.89 ± 2.64\t79.39 ± 2.01\nARGM-GOL\t87.67\t86.76 ± 3.16\t83.56 ± 3.62\t85.39 ± 0.79\t85.39 ± 2.85\t83.10 ± 3.16\t81.28 ± 1.58\nARGM-LVB\t98.59\t96.24 ± 1.62\t97.65 ± 0.81\t97.18 ± 0.00\t95.77 ± 2.44\t97.18 ± 1.41\t96.71 ± 0.81\nR-ARGM-LOC\t81.54\t85.13 ± 5.82\t76.41 ± 2.35\t88.72 ± 10.92\t76.92 ± 2.66\t75.38 ± 4.62\t74.87 ± 4.70\nR-ARGM-TMP\t66.67\t72.49 ± 4.00\t75.13 ± 6.61\t77.78 ± 4.20\t80.96 ± 2.75\t67.20 ± 2.42\t81.48 ± 0.92\nR-ARG2\t67.74\t79.03 ± 1.62\t70.97 ± 5.82\t80.11 ± 3.36\t76.88 ± 5.18\t77.42 ± 4.27\t70.97 ± 6.45\nC-ARG2\t32.65\t45.58 ± 4.71\t41.50 ± 3.12\t44.90 ± 5.40\t42.18 ± 2.36\t42.86 ± 3.53\t40.82 ± 0.00\nC-ARG0\t44.12\t60.78 ± 10.33\t55.88 ± 5.09\t56.86 ± 1.70\t59.80 ± 6.12\t55.88 ± 2.94\t56.86 ± 6.12\nARGM-REC\t76.47\t83.33 ± 1.70\t84.31 ± 6.13\t88.24 ± 2.95\t82.35 ± 0.00\t86.27 ± 1.70\t85.29 ± 2.95\nARGM-COM\t88.89\t88.89 ± 0.00\t88.89 ± 3.70\t92.59 ± 0.00\t93.83 ± 5.66\t91.36 ± 2.14\t92.59 ± 0.00\nC-ARGM-ADV\t45.45\t51.52 ± 5.25\t51.52 ± 5.25\t51.52 ± 5.25\t54.55 ± 9.10\t51.52 ± 5.25\t54.55 ± 0.00\nR-ARGM-MNR\t54.55\t63.64 ± 0.00\t63.64 ± 9.09\t60.61 ± 5.25\t75.76 ± 5.25\t63.64 ± 0.00\t75.76 ± 5.25\nARG5\t100.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\nC-ARGM-TMP\t42.86\t57.14 ± 0.00\t42.86 ± 0.00\t52.38 ± 8.24\t52.38 ± 8.24\t61.90 ± 8.25\t61.91 ± 16.49\nR-ARGM-CAU\t75.00\t91.67 ± 14.43\t58.33 ± 14.43\t83.33 ± 14.43\t100.00 ± 0.00\t83.33 ± 14.43\t91.67 ± 14.43\nC-ARGM-CAU\t66.67\t66.67 ± 0.00\t66.67 ± 0.00\t66.67 ± 0.00\t88.89 ± 19.24\t77.78 ± 19.24\t66.67 ± 0.00\nC-ARG3\t66.67\t88.89 ± 19.24\t88.89 ± 19.24\t77.78 ± 19.24\t100.00 ± 0.00\t100.00 ± 0.00\t77.78 ± 19.24\nR-ARG4\t100.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\nC-ARGM-EXT\t100.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\nR-ARGM-ADV\t50.00\t50.00 ± 0.00\t83.33 ± 28.87\t66.67 ± 28.87\t83.33 ± 28.87\t83.33 ± 28.87\t50.00 ± 0.00\nC-ARGM-LOC\t100.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\nC-ARGM-MNR\t100.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\nC-ARGM-MOD\t100.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\nR-ARGM-PRP\t100.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t83.33 ± 28.87\t100.00 ± 0.00\nARGM-PRX\t100.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\nARGA\t100.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\nR-ARGM-DIR\t100.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\nR-ARGM-PRD\t100.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\nC-ARGM-PRD\t100.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\nR-ARGM-EXT\t100.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\nC-ARGM-PRP\t100.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\nR-ARG3\t100.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\nARGM-PRR\t100.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\nARGM-DSP\t100.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t100.00 ± 0.00\t\n '''\n plt.axhline(y=0, color='r', linewidth=0.5, linestyle='--')\n head = True\n group = defaultdict(dict)\n names = ['ELECTRA', 'POS', 'NER', 'DEP', 'CON', 'MTL-5']\n nmax = 20\n c = 0\n for line in table.splitlines():\n line = line.strip()\n if not line:\n continue\n cells = line.split('\\t')\n if not cells:\n continue\n if head:\n head = False\n continue\n\n label, scores = cells[0], cells[1:]\n scores = [float(x.split()[0]) for x in scores]\n scores[0], scores[1] = scores[1], scores[0]\n for n, s in zip(names, scores[1:]):\n group[n][label] = s - scores[0]\n # c += 1\n # if c == nmax:\n # break\n texts = []\n xys = defaultdict(lambda: ([], []))\n for i, (n, scores) in enumerate(group.items()):\n for j, (label, diff) in enumerate(scores.items()):\n # plt.scatter(i + 1, diff)\n # xys[label][0].append(i + 1)\n # xys[label][1].append(diff-0.025)\n xys[label][0].append(i + 1)\n xys[label][1].append(diff)\n # xys[label][0].append(i + 1)\n # xys[label][1].append(diff+0.025)\n # texts.append(plt.text(i + 1, diff, label))\n # colors = prop_cycle.by_key()['color']\n # colors.extend(['r', 'g', 'b', 'c', 'm', 'y'])\n # colors = ['#e6194b', '#3cb44b', '#ffe119', '#4363d8', '#f58231', '#911eb4', '#46f0f0', '#f032e6', '#bcf60c', '#fabebe', '#008080', '#e6beff', '#9a6324', '#fffac8', '#800000', '#aaffc3', '#808000', '#ffd8b1', '#000075', '#808080', '#ffffff', '#000000']\n colors = ['#696969', '#2e8b57', '#800000', '#191970', '#808000', '#ff0000', '#ff8c00', '#ffd700', '#ba55d3',\n '#00fa9a', '#00ffff', '#0000ff', '#adff2f', '#ff00ff', '#1e90ff', '#fa8072', '#eee8aa', '#dda0dd',\n '#ff1493', '#87cefa']\n for i, (label, xy) in enumerate(xys.items()):\n # label = {\n # 'ARG0': 'A0',\n # 'ARG1': 'A1',\n # 'ARG2': 'A2',\n # 'ARG3': 'A3',\n # 'ARG4': 'A4',\n # }.get(label, label)\n label = label.replace('ARGM-', 'M-')\n label = label.replace('-ARG', '-A')\n plt.scatter(*xy, label=label if i < nmax else '_nolegend_', color=colors[i % len(colors)], marker='_', s=300/(i+1))\n # adjust_text(texts)\n # plt.axhline(y=0, color='r', linewidth=0.5, linestyle='--')\n plt.legend(bbox_to_anchor=(1, 1.01), loc='upper left', labelspacing=0.2, borderpad=0.1, handletextpad=0.1)\n plt.xticks(list(range(1, 1 + len(group))), list(group.keys()))\n # plt.ylabel('Δacc')\n plt.tight_layout()\n pdf = 'EMNLP-2021-MTL/fig/electra/srl-acc-diff.pdf'\n os.makedirs(os.path.dirname(pdf), exist_ok=True)\n plt.savefig(pdf)\n plt.show()\n\n\nif __name__ == '__main__':\n main()\n",
"# -*- coding:utf-8 -*-\n# Author: hankcs\n# Date: 2021-01-06 16:12\nfrom collections import defaultdict, Counter\nfrom typing import List\n\nimport os\nimport torch\nimport matplotlib.pyplot as plt\nfrom elit.common.dataset import SortingSamplerBuilder\nfrom elit.common.transform import NormalizeToken\nfrom elit.components.mtl.gated.draw_attn import heatmap\nfrom elit.components.mtl.head_mtl import HeadMultiTaskLearning\nfrom elit.components.mtl.multi_task_learning import MultiTaskLearning\nfrom elit.components.mtl.tasks.constituency import CRFConstituencyParsing\nfrom elit.components.mtl.tasks.dep import BiaffineDependencyParsing\nfrom elit.components.mtl.tasks.ner.biaffine_ner import BiaffineNamedEntityRecognition\nfrom elit.components.mtl.tasks.pos import TransformerTagging\nfrom elit.components.mtl.tasks.srl.rank_srl import SpanRankingSemanticRoleLabeling\nfrom elit.datasets.parsing.ptb import PTB_TOKEN_MAPPING\nfrom elit.datasets.srl.ontonotes5.english import ONTONOTES5_POS_ENGLISH_TRAIN, ONTONOTES5_POS_ENGLISH_TEST, \\\n ONTONOTES5_POS_ENGLISH_DEV, ONTONOTES5_ENGLISH_TRAIN, ONTONOTES5_ENGLISH_TEST, ONTONOTES5_ENGLISH_DEV, \\\n ONTONOTES5_CON_ENGLISH_TRAIN, ONTONOTES5_CON_ENGLISH_DEV, ONTONOTES5_CON_ENGLISH_TEST, ONTONOTES5_DEP_ENGLISH_TEST, \\\n ONTONOTES5_DEP_ENGLISH_DEV, ONTONOTES5_DEP_ENGLISH_TRAIN\nfrom elit.layers.embeddings.contextual_word_embedding import ContextualWordEmbedding\nfrom elit.metrics.mtl import MetricDict\nfrom elit.utils.log_util import cprint\nfrom elit.utils.time_util import CountdownTimer\nfrom hanlp_common.constant import ROOT\nfrom stem_cell_hypothesis import cdroot\n\n\nclass DepAcc(object):\n\n def __init__(self) -> None:\n super().__init__()\n self.label_correct = dict()\n self.label_count = Counter()\n\n def finalize(self):\n for label, count in self.label_count.items():\n self.label_correct[label] /= count\n\n\ndef draw_acc(acc: torch.Tensor, title):\n im, cb = heatmap(acc, cbar=True, cmap=\"binary\",\n row_labels=[f'{x + 1}' for x in range(acc.shape[0])],\n col_labels=[f'{x + 1}' for x in range(acc.shape[1])],\n show_axis_labels=True\n )\n im.set_clim(0, 1)\n plt.xlabel('heads')\n plt.ylabel('layers')\n plt.title(title)\n\n\ndef main():\n cdroot()\n save_dir = 'data/model/mtl/ontonotes_bert_base_en/dep/0'\n # save_dir = 'data/model/mtl/ontonotes_bert_base_en/all/lw/3'\n # save_dir = 'data/model/mtl/ontonotes_albert_base_en/basic/dep_srl/lw/1'\n folder = 'pairwise-srl'\n # folder = 'joint-dep'\n # folder = 'single'\n folder = 'static'\n # print(save_dir, folder)\n records = calc_acc(save_dir, folder)\n records.finalize()\n overall = torch.zeros((12, 12))\n # print(len(records.label_count))\n for label, count in records.label_count.items():\n overall += records.label_correct[label] * count\n overall /= sum(records.label_count.values())\n # draw_acc(overall, 'Weighted Accuracy')\n # plt.savefig(f'{save_dir}/{folder}/overall.pdf')\n # plt.clf()\n for label, freq in records.label_count.most_common():\n acc = records.label_correct[label]\n print(f'{acc.max() * 100:.2f}')\n # print(f'{label}\\t{acc.max() * 100:.2f}')\n # draw_acc(acc, label)\n # plt.savefig(f'{save_dir}/{folder}/{label}.pdf')\n # plt.clf()\n\n\ndef calc_acc(save_dir, folder):\n tasks = {\n # 'pos': TransformerTagging(\n # ONTONOTES5_POS_ENGLISH_TRAIN,\n # ONTONOTES5_POS_ENGLISH_DEV,\n # ONTONOTES5_POS_ENGLISH_TEST,\n # SortingSamplerBuilder(batch_size=64, batch_max_tokens=6400),\n # lr=1e-3,\n # ),\n # 'ner': BiaffineNamedEntityRecognition(\n # ONTONOTES5_ENGLISH_TRAIN,\n # ONTONOTES5_ENGLISH_DEV,\n # ONTONOTES5_ENGLISH_TEST,\n # SortingSamplerBuilder(batch_size=64, batch_max_tokens=6400),\n # lr=1e-3,\n # doc_level_offset=True,\n # ),\n # 'srl': SpanRankingSemanticRoleLabeling(\n # ONTONOTES5_ENGLISH_TRAIN,\n # ONTONOTES5_ENGLISH_DEV,\n # ONTONOTES5_ENGLISH_TEST,\n # SortingSamplerBuilder(batch_size=64, batch_max_tokens=6400),\n # lr=1e-3,\n # doc_level_offset=True,\n # ),\n 'dep': BiaffineDependencyParsing(\n ONTONOTES5_DEP_ENGLISH_TRAIN,\n ONTONOTES5_DEP_ENGLISH_DEV,\n ONTONOTES5_DEP_ENGLISH_TEST,\n # 'data/parsing/ptb/short.conllx',\n SortingSamplerBuilder(batch_size=64, batch_max_tokens=6400),\n lr=1e-3,\n ),\n # 'con': CRFConstituencyParsing(\n # ONTONOTES5_CON_ENGLISH_TRAIN,\n # ONTONOTES5_CON_ENGLISH_DEV,\n # ONTONOTES5_CON_ENGLISH_TEST,\n # SortingSamplerBuilder(batch_size=64, batch_max_tokens=6400),\n # lr=1e-3,\n # ),\n }\n mtl = HeadMultiTaskLearning()\n # save_dir = f'data/model/mtl/ontonotes_bert_base_en/dep/0'\n path = f'{save_dir}/{folder}/records.pt'\n # if os.path.isfile(path):\n # return torch.load(path)\n os.makedirs(os.path.dirname(path), exist_ok=True)\n mtl.load(save_dir)\n # if 'dep' in mtl.tasks:\n # mtl['dep'].config.tree = True\n # mtl['dep'].config.proj = True\n # mtl.save_config(save_dir)\n\n for task_name in list(mtl.tasks.keys()):\n if task_name not in tasks:\n del mtl[task_name]\n\n for k, v in mtl.tasks.items():\n v.trn = tasks[k].trn\n v.dev = tasks[k].dev\n v.tst = tasks[k].tst\n # metric = mtl.evaluate(save_dir)[0]\n cache = mtl.dump_attention_per_head(save_dir)\n records = None\n timer = CountdownTimer(len(cache))\n for batch, attentions in cache:\n if records is None:\n num_layers = len(attentions)\n num_heads = attentions[0].size(1)\n records = DepAcc()\n for layer, attn_per_layer in enumerate(attentions):\n max_attn = attn_per_layer.argmax(dim=-1)\n for head in range(max_attn.size(1)):\n attn = max_attn[:, head, :]\n for b, (heads, rels) in enumerate(zip(batch['HEAD'], batch['DEPREL'])):\n for i, (h, r) in enumerate(zip([-1] + heads, [ROOT] + rels)):\n if not i: # skip root\n continue\n if attn[b][i].item() == h or attn[b][h].item() == i:\n correct = records.label_correct.get(r, None)\n if correct is None:\n # noinspection PyUnboundLocalVariable\n correct = records.label_correct[r] = torch.zeros([num_layers, num_heads])\n correct[layer][head] += 1\n records.label_count.update(sum(batch['DEPREL'], []))\n timer.log()\n torch.save(records, path)\n return records\n\n\nif __name__ == '__main__':\n main()\n"
] | [
[
"torch.mean",
"torch.Size",
"torch.ones",
"torch.max",
"torch.cat",
"torch.zeros",
"torch.nn.functional.cross_entropy",
"torch.gather",
"torch.zeros_like",
"torch.arange",
"torch.stack",
"torch.clamp",
"torch.cumsum"
],
[
"matplotlib.pyplot.legend",
"matplotlib.pyplot.axhline",
"matplotlib.pyplot.tight_layout",
"matplotlib.pyplot.savefig",
"matplotlib.pyplot.rcParams.update",
"matplotlib.pyplot.show"
],
[
"matplotlib.pyplot.title",
"torch.zeros",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.xlabel",
"torch.save"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
artyompal/kaggle_salt | [
"3c323755730745ac7bbfd106f1f20919cceef0ee",
"3c323755730745ac7bbfd106f1f20919cceef0ee",
"3c323755730745ac7bbfd106f1f20919cceef0ee"
] | [
"code_gazay/lenin/lenin/transforms.py",
"code_artyom/resnet50_classifier_01.py",
"code_florian/scripts/make_preds.py"
] | [
"import numpy as np\n\ndef hwc_to_chw(image):\n return np.einsum('hwc->chw', image) # change to pytorch format\n",
"#!/usr/bin/python3.6\n\n# Input data files are available in the \"../data/\" directory.\n# For example, running this (by clicking run or pressing Shift+Enter) will list the files in the input directory\n\nimport os\nimport sys\nimport random\n\nimport pandas as pd\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nimport albumentations as albu\n\nimport keras\nfrom keras.applications.resnet50 import ResNet50\nfrom keras.preprocessing.image import load_img\nfrom keras.models import Model, load_model, save_model\nfrom keras.layers import Input,Dropout,BatchNormalization,Activation,Add, Dense, Flatten\nfrom keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau\nfrom tqdm import tqdm\nfrom sklearn.model_selection import StratifiedKFold\nfrom keras.utils import to_categorical\nfrom keras import optimizers\nfrom keras.applications.imagenet_utils import preprocess_input\nfrom sklearn.utils.class_weight import compute_class_weight\nfrom segmentation_models import Unet\nfrom segmentation_models.backbones import get_preprocessing\n\n\n\nSEED = 42\nVERSION = 2\nBATCH_SIZE = 32\nNUM_FOLDS = 5\nimage_size = 197\n\n\n# Loading of training/testing ids and depths\ntrain_df = pd.read_csv(\"../data/train.csv\", index_col=\"id\", usecols=[0])\ndepths_df = pd.read_csv(\"../data/depths.csv\", index_col=\"id\")\ntrain_df = train_df.join(depths_df)\ntest_df = pd.DataFrame(index=depths_df[~depths_df.index.isin(train_df.index)].index)\ntest_df = test_df.join(depths_df)\n\nlen(train_df)\n\n\ntrain_df[\"images\"] = [np.array(load_img(\"../data/train/images/{}.png\".format(idx), interpolation='nearest',\n target_size=(image_size, image_size),\n color_mode = \"grayscale\",)) for idx in tqdm(train_df.index)]\n\ntrain_df[\"masks\"] = [np.array(load_img(\"../data/train/masks/{}.png\".format(idx), interpolation='nearest',\n target_size=(image_size, image_size),\n color_mode = \"grayscale\",)) for idx in tqdm(train_df.index)]\n\ntest_df[\"images\"] = [np.array(load_img(\"../data/test/images/{}.png\".format(idx), interpolation='nearest',\n target_size=(image_size, image_size),\n color_mode = \"grayscale\")) for idx in tqdm(test_df.index)]\n\ntrain_df[\"coverage\"] = train_df.masks.map(np.sum) / pow(image_size, 2) / 255\n\ndef cov_to_class(val):\n for i in range(0, 11):\n if val * 10 <= i :\n return i\n\ntrain_df[\"coverage_class\"] = train_df.coverage.map(cov_to_class)\n\n\ndef get_class(img, th=10):\n img_sum = np.array([i.sum() for i in img])\n return np.array(img_sum>th).astype(int)\n\ndef add_depth_coord(images):\n \"\"\" Takes dataset (N, W, H, 1) returns (N, W, H, 3). \"\"\"\n assert(len(images.shape) == 4)\n channel1 = np.zeros_like(images)\n\n h = images.shape[1]\n for row, const in enumerate(np.linspace(0, 1, h)):\n channel1[:, row, ...] = const\n\n channel2 = images * channel1\n images = np.concatenate([images, channel1, channel2], axis=-1)\n return images\n\n\nx_train = np.array(train_df.images.tolist()).reshape(-1, image_size, image_size, 1)\ny_train = np.array(train_df.masks.tolist()).reshape(-1, image_size, image_size, 1)\n# x_test = np.array(test_df.images.tolist()).reshape(-1, image_size, image_size, 1)\ntrain_cls = np.array(train_df.coverage_class)\n\nclass Datagen(keras.utils.Sequence):\n \"\"\" Returns batchs of images which are augmented and resized. \"\"\"\n def __init__(self, x, y, valid):\n assert(x.shape[0] == y.shape[0])\n self.x = x\n self.y = y\n self.valid = valid\n self.preprocessing_fn = get_preprocessing('resnet50')\n\n SZ = image_size\n\n self.augs = albu.Compose([\n # albu.OneOf([albu.RandomSizedCrop(min_max_height=(SZ//2, SZ), height=SZ, width=SZ, p=0.5),\n # albu.PadIfNeeded(min_height=SZ, min_width=SZ, p=0.5)], p=1),\n # albu.VerticalFlip(p=0.5),\n # albu.HorizontalFlip(p=0.5),\n # albu.RandomRotate90(p=0.5),\n albu.Rotate(p=0.5, limit=10),\n albu.OneOf([\n albu.ElasticTransform(p=0.5, alpha=120, sigma=120 * 0.05, alpha_affine=120 * 0.03),\n albu.GridDistortion(p=0.5),\n albu.OpticalDistortion(p=1, distort_limit=2, shift_limit=0.5)\n ], p=0.8),\n # albu.CLAHE(p=0.8),\n # albu.RandomContrast(p=0.8),\n albu.RandomBrightness(p=0.8),\n albu.RandomGamma(p=0.8)])\n\n print(\"created Datagen: x\", x.shape, \"y\", y.shape)\n\n def __getitem__(self, idx):\n assert(idx < len(self))\n\n x = self.x[idx * BATCH_SIZE : (idx + 1) * BATCH_SIZE]\n y = self.y[idx * BATCH_SIZE : (idx + 1) * BATCH_SIZE]\n\n if not self.valid:\n xa = []\n for image in x :\n augmented = self.augs(image=image)\n xa.append(augmented[\"image\"].reshape(image_size, image_size, 1))\n\n x = np.array(xa).reshape(-1, image_size, image_size, 1)\n\n x = add_depth_coord(x)\n return self.preprocessing_fn(x), y\n\n def __len__(self):\n return int(np.ceil(self.x.shape[0] / BATCH_SIZE))\n\nfolds = StratifiedKFold(NUM_FOLDS, shuffle=True, random_state=666)\n\nfor fold, indices in enumerate(folds.split(x_train, train_df.coverage_class)):\n print(\"==================== fold %d\" % fold)\n train_idx, valid_idx = indices\n x_tr, y_tr = x_train[train_idx], y_train[train_idx]\n x_val, y_val = x_train[valid_idx], y_train[valid_idx]\n\n\n #Data augmentation\n x_tr = np.append(x_tr, [np.fliplr(x) for x in x_tr], axis=0)\n y_tr = get_class(np.append(y_tr, [np.fliplr(x) for x in y_tr], axis=0)).flatten()\n y_val = get_class(y_val).flatten()\n\n resnet_model = ResNet50(input_shape=(image_size, image_size, 3), weights='imagenet', include_top=False)\n input_x = resnet_model.input\n output_layer = Flatten()(resnet_model.output)\n output_layer = Dense(1, activation='sigmoid')(output_layer)\n model = Model(input_x, output_layer)\n learning_rate = 0.001\n c = optimizers.adam(lr = learning_rate)\n model.compile(optimizer=c, loss='binary_crossentropy', metrics=['accuracy'])\n\n\n save_model_name = '../output/resnet50_class_v%d_fold%d_acc{val_acc:.02f}_epoch{epoch:02d}.model' % (VERSION, fold)\n early_stopping = EarlyStopping(monitor='val_acc', mode = 'max', patience=10, verbose=1)\n model_checkpoint = ModelCheckpoint(save_model_name, monitor='val_acc',\n mode = 'max', save_best_only=True, verbose=1)\n reduce_lr = ReduceLROnPlateau(monitor='val_acc', mode = 'max', factor=0.5, patience=5, min_lr=0.0001, verbose=1)\n\n epochs = 400\n batch_size = 32\n cw = compute_class_weight(\"balanced\", np.unique(y_tr), y_tr)\n print(\"class_weight: \", cw)\n history = model.fit_generator(Datagen(x_tr, y_tr, valid=False),\n validation_data=Datagen(x_val, y_val, valid=True),\n epochs=epochs, callbacks=[early_stopping, model_checkpoint, reduce_lr],\n use_multiprocessing=True, workers=12,\n shuffle=False, verbose=1,\n class_weight=cw)\n\n# classes_df = pd.DataFrame(index=test_df.index)\n# classes_df['class'] = model.predict(preprocess_input(add_depth_coord(x_test)))\n# test_df.to_csv(f'../output/resnet50_class_v{VERSION}.csv', index=True)\n",
"import os\nimport pickle\nimport sys\nimport time\nimport math\nimport argparse\n\nfrom typing import Any, List\n\nimport numpy as np\nimport pandas as pd\n\nimport torch\nimport torch.nn as nn\nimport torch.optim as optim\nfrom torch.autograd import Variable\nimport torch.backends.cudnn as cudnn\nimport torch.nn.functional as F\nimport torchvision as vsn\n\nfrom skimage.io import imread\nfrom tqdm import tqdm\n\nfrom skimage.transform import resize\n\nfrom models.nets import ResUNet\nfrom utils.data_loaders import get_data_loaders, get_test_loader\nfrom utils.data_vis import plot_from_torch\n\nfrom utils.evaluations import DiceLoss, calc_metric, get_iou_vector\n\nimport re\n\n# important: parse fold number from filename to avoid typos\ndef parse_fold_number(filename: str) -> int:\n match = re.match(r'.*_fold-(\\d)\\.pth', filename)\n if match:\n fold_num = int(match.group(1))\n print(\"detected fold\", fold_num)\n else:\n assert(False)\n return fold_num\n\nparser = argparse.ArgumentParser(description='Make Preds')\nparser.add_argument('--imsize', default=128, type=int,\n help='imsize to use for training')\nparser.add_argument('--batch_size', default=128, type=int,\n help='size of batches')\nparser.add_argument('--gpu', default=0, type=int,\n help='which gpu to run')\n# parser.add_argument('--fold_num', type=int, required=True, #default=0,\n# help='which fold to make predictions for')\nparser.add_argument('--weight_file', default='resunet.pth', type=str,\n help='which weight file to make predictions for')\nparser.add_argument('--num_folds', default=5, type=int,\n help='number of cross val folds')\n#parser.add_argument('--model_name', default='resunet', type=str,\n # help='name of model for saving/loading weights')\n#parser.add_argument('--exp_name', default='tgs_slt', type=str,\n# help='name of experiment for saving files')\nparser.add_argument('--debug', action='store_true',\n help='whether to display debug info')\nparser.add_argument('--flip_tta', action='store_true',\n help='whether to horizontal flip TTA')\n#parser.add_argument('--use_mt', action='store_true',\n# help='whether to use mean teacher model')\n#parser.add_argument('--use_swa', action='store_true',\n# help='whether to use mean teacher model')\nparser.add_argument('--use_bool', action='store_true',\n help='whether to use empty predictions')\nparser.add_argument('--save_raw', action='store_true',\n help='whether to export predicts without thresholds')\nparser.add_argument('--mosaic', default=0, type=int,\n help='how to use mosaic: 0-disabled, 1-channel 1, 2 - channel 2')\nparser.add_argument('--score_only', action='store_true',\n help='don\\'t generate predictions')\n\n\ndef predict(net: Any, test_loader: Any, fold_num: int, to_csv: bool, threshold: float) -> Any:\n net.eval()\n\n all_predicts = []\n all_masks = []\n rles = []\n ids = []\n\n # no gradients during validation\n with torch.no_grad():\n for i, data in enumerate(tqdm(test_loader)):\n test_imgs = data['img'].to(device)\n test_ids = data['id']\n blanks = data['blank']\n\n # get predictions\n preds, chck_preds, edges_preds = net(test_imgs)\n preds = preds.sigmoid()\n chck_preds = chck_preds.sigmoid() > 0.5\n\n if args.flip_tta:\n test_imgs_lr = data['img_lr'].to(device)\n preds_lr, check_lr, edges_preds_lr = net(test_imgs_lr)\n preds_lr_ = preds_lr.sigmoid()\n check_lr = check_lr.sigmoid() > 0.5\n\n chck_preds = (check_lr + chck_preds) / 2.\n preds_lr = np.zeros((preds_lr_.size())).astype(np.float32)\n # preds_lr = np.copy(preds_lr_.data.cpu().numpy()[:,:,:,::-1])\n preds_lr = np.copy(preds_lr_.data.cpu().numpy()[:,:,:,::-1])\n # print(preds_lr.shape)\n\n preds = (preds + torch.from_numpy(preds_lr).to(device)) / 2.\n\n # set masks to 0 with low probability of having mask\n if args.use_bool:\n chck_preds = chck_preds > 0.5\n preds *= chck_preds.view(chck_preds.size(0),1,1,1).expand_as(preds).float()\n preds *= blanks.view(blanks.size(0),1,1,1).expand_as(preds).float().to(device)\n\n if args.debug and i == 0:\n img_grid = vsn.utils.make_grid(test_imgs, normalize=True)\n msk_grid = vsn.utils.make_grid(preds)\n\n if args.flip_tta:\n img_lr_grid = vsn.utils.make_grid(test_imgs_lr, normalize=True)\n vsn.utils.save_image(img_lr_grid, '../imgs/test_imgs_lr.png')\n\n vsn.utils.save_image(img_grid, '../imgs/test_imgs.png')\n vsn.utils.save_image(msk_grid, '../imgs/test_pred.png')\n\n pred_np = preds.data.cpu().numpy()\n pred_np = pred_np.reshape((-1, pred_np.shape[2], pred_np.shape[3]))\n\n for j in range(pred_np.shape[0]):\n if args.imsize == 256:\n predicted_mask = resize(pred_np[j][27:229, 27:229], (101,101),\n preserve_range=True)\n else:\n predicted_mask = pred_np[j][13:114, 13:114]\n\n ids.append(test_ids[j])\n\n if to_csv:\n predicted_mask = np.where(predicted_mask > threshold, 1, 0)\n rles.append(rle_encode(predicted_mask.astype(np.int32)))\n else:\n all_predicts.append(predicted_mask)\n\n if 'msk' in data:\n masks = data['msk'].cpu().numpy()\n masks = masks.reshape(-1, masks.shape[2], masks.shape[3])\n all_masks.append(masks[j, 13:114, 13:114])\n\n return (ids, rles) if to_csv else (ids, np.array(all_predicts), np.array(all_masks))\n\ndef valid(net, valid_loader, fold_num, use_lovasz=False, save_imgs=False):\n pred = predict(net, valid_loader, fold_num, to_csv=False, threshold=0.4)\n return pred\n\n# src: https://www.kaggle.com/aglotero/another-iou-metric\ndef iou_metric(y_true_in, y_pred_in, print_table=False):\n labels = y_true_in\n y_pred = y_pred_in\n\n\n true_objects = 2\n pred_objects = 2\n\n # if all zeros, original code generate wrong bins [-0.5 0 0.5],\n temp1 = np.histogram2d(labels.flatten(), y_pred.flatten(), bins=([0,0.5,1], [0,0.5, 1]))\n intersection = temp1[0]\n # Compute areas (needed for finding the union between all objects)\n area_true = np.histogram(labels,bins=[0,0.5,1])[0]\n area_pred = np.histogram(y_pred, bins=[0,0.5,1])[0]\n area_true = np.expand_dims(area_true, -1)\n area_pred = np.expand_dims(area_pred, 0)\n\n # Compute union\n union = area_true + area_pred - intersection\n\n # Exclude background from the analysis\n intersection = intersection[1:,1:]\n intersection[intersection == 0] = 1e-9\n\n union = union[1:,1:]\n union[union == 0] = 1e-9\n\n # Compute the intersection over union\n iou = intersection / union\n # Precision helper function\n def precision_at(threshold, iou):\n matches = iou > threshold\n true_positives = np.sum(matches, axis=1) == 1 # Correct objects\n false_positives = np.sum(matches, axis=0) == 0 # Missed objects\n false_negatives = np.sum(matches, axis=1) == 0 # Extra objects\n tp, fp, fn = np.sum(true_positives), np.sum(false_positives), np.sum(false_negatives)\n return tp, fp, fn\n\n # Loop over IoU thresholds\n prec = []\n if print_table:\n print(\"Thresh\\tTP\\tFP\\tFN\\tPrec.\")\n for t in np.arange(0.5, 1.0, 0.05):\n tp, fp, fn = precision_at(t, iou)\n if (tp + fp + fn) > 0:\n p = tp / (tp + fp + fn)\n else:\n p = 0\n if print_table:\n print(\"{:1.3f}\\t{}\\t{}\\t{}\\t{:1.3f}\".format(t, tp, fp, fn, p))\n prec.append(p)\n\n if print_table:\n print(\"AP\\t-\\t-\\t-\\t{:1.3f}\".format(np.mean(prec)))\n return np.mean(prec)\n\ndef iou_metric_batch(y_true_in, y_pred_in, threshold):\n # print(\"iou_metric_batch: y_true_in\", y_true_in.shape, \"y_pred_in\", y_pred_in.shape)\n batch_size = y_true_in.shape[0]\n metric = []\n\n for batch in range(batch_size):\n value = iou_metric(y_true_in[batch], y_pred_in[batch] > threshold)\n metric.append(value)\n\n return np.mean(metric)\n\ndef load_masks(fold_num):\n train_df = pd.read_csv(\"../data/train.csv\", index_col=\"id\", usecols=[0])\n # depths_df = pd.read_csv(\"../data/depths.csv\", index_col=\"id\")\n # train_df = train_df.join(depths_df)\n # test_df = depths_df[~depths_df.index.isin(train_df.index)]\n print(\"train_df\", train_df.shape)\n assert(train_df.shape[0] == 4000)\n\n print(\"reading train masks\")\n masks = np.array([imread(\"../data/train/masks/%s.png\" % idx)\n for idx in train_df.index])\n masks = np.expand_dims(masks, axis=-1)\n print(\"masks range:\", np.amin(masks), np.amax(masks))\n masks = masks.astype(float) / np.amax(masks)\n masks = np.squeeze(masks)\n print(\"masks\", masks.dtype)\n\n with open(\"../data/fixed_folds.pkl\", \"rb\") as f:\n splits = pickle.load(f)\n\n train_idx, valid_idx = splits[fold_num]\n masks = masks[valid_idx]\n\n print(\"masks\", masks.shape)\n return masks\n\ndef rle_encode(im: Any) -> str:\n '''\n im: numpy array, 1-mask, 0-background\n Returns run length as string\n '''\n pixels = im.flatten(order='F')\n pixels = np.concatenate([[0], pixels, [0]])\n runs = np.where(pixels[1:] != pixels[:-1])[0] + 1\n runs[1::2] -= runs[::2]\n return ' '.join(str(x) for x in runs)\n\ndef write_csv(filename: str, ids: List[str], rles: List[str]):\n subm = pd.DataFrame.from_dict({'id':ids, 'rle_mask':rles}, orient='index').T\n #if args.use_mt:\n # subm.to_csv('../subm/{}_{}_mt_fold-{}.csv'.format(args.model_name, args.exp_name, fold_num), index=False)\n #elif args.use_swa:\n # subm.to_csv('../subm/{}_{}_swa_fold-{}.csv'.format(args.model_name, args.exp_name, fold_num), index=False)\n #else:\n # subm.to_csv('../subm/{}_{}_best_fold-{}.csv'.format(args.model_name, args.exp_name, fold_num), index=False)\n subm.to_csv(filename, index=False)\n\n subm.index.names = ['id']\n subm.columns = ['id', 'rle_mask']\n print(subm.head())\n\ndef make_preds():\n _, valid_loader = get_data_loaders(imsize=args.imsize,\n batch_size=args.batch_size,\n num_folds=args.num_folds,\n mosaic_mode=args.mosaic,\n fold=fold_num)\n print(\"predicting on the validation dataset\")\n ids, preds_val, masks = valid(net, valid_loader, fold_num)\n\n # TODO: scipy.optimize.minimize\n print(\"searching for the best threshold\")\n thresholds = np.linspace(0.3, 0.7, 31)\n ious = np.array([get_iou_vector(masks, preds_val, threshold) for threshold in tqdm(thresholds)])\n print(\"iou\", ious)\n\n threshold_best_index = np.argmax(ious)\n best_iou = ious[threshold_best_index]\n best_threshold = thresholds[threshold_best_index]\n print(\"validation:\", best_iou, \"best threshold\", best_threshold)\n\n if args.score_only:\n return\n\n # write predicts for the train set\n directory, name_ext = os.path.split(MODEL_CKPT)\n name, ext = os.path.splitext(name_ext)\n\n train_predicts = os.path.join(directory, \"loc%.04f_train_\" % best_iou + name +\n (\".pkl\" if args.save_raw else \".csv\" ))\n print('generating train predictions to %s' % train_predicts)\n rles = []\n\n if args.save_raw:\n with open(train_predicts, \"wb\") as f:\n pickle.dump(preds_val, f)\n else:\n for pred in preds_val:\n pred = np.where(pred > best_threshold, 1, 0)\n rles.append(rle_encode(pred.astype(np.int32)))\n\n write_csv(train_predicts, ids, rles)\n\n # write predicts for the test set\n print(\"predicting on the test dataset\")\n test_predicts = os.path.join(directory, \"loc%.04f_test_\" % best_iou + name +\n (\".pkl\" if args.save_raw else \".csv\" ))\n print('generating test predictions to %s' % test_predicts)\n\n if args.save_raw:\n ids, preds, masks = predict(net, test_loader, fold_num, False, 0)\n print(len(ids), len(preds))\n assert(len(ids) == len(preds))\n\n with open(test_predicts, \"wb\") as f:\n pickle.dump((ids, preds), f)\n else:\n ids, preds = predict(net, test_loader, fold_num, True, best_threshold)\n print(len(ids), len(preds))\n assert(len(ids) == len(preds))\n\n write_csv(test_predicts, ids, preds)\n\nif __name__ == '__main__':\n args = parser.parse_args()\n print(\"predicting on\", args.weight_file)\n fold_num = parse_fold_number(args.weight_file)\n\n # set model filenames\n #model_params = [args.model_name, args.exp_name, fold_num]\n #if args.use_mt:\n # MODEL_CKPT = '../model_weights/best_meanteacher_{}_{}_fold-{}.pth'.format(*model_params)\n #elif args.use_swa:\n # MODEL_CKPT = '../model_weights/swa_{}_{}_fold-{}.pth'.format(*model_params)\n #else:\n # MODEL_CKPT = '../model_weights/best_{}_{}_fold-{}.pth'.format(*model_params)\n\n MODEL_CKPT = args.weight_file\n\n # get the loaders\n test_loader = get_test_loader(imsize=args.imsize, batch_size=args.batch_size,\n mosaic_mode=args.mosaic)\n\n net = ResUNet(use_bool=True)\n if args.gpu == 99:\n device = torch.device(\"cuda:0\")\n net = nn.DataParallel(net, device_ids=[0,1]).cuda()\n else:\n device = torch.device(\"cuda:{}\".format(args.gpu) if torch.cuda.is_available() else \"cpu\")\n # torch.cuda.set_device(args.gpu)\n cudnn.benchmark = True\n net.to(device)\n\n state_dict = torch.load(MODEL_CKPT, map_location=lambda storage, loc: storage.cuda(args.gpu))\n net.load_state_dict(state_dict)\n\n\n make_preds()\n"
] | [
[
"numpy.einsum"
],
[
"pandas.read_csv",
"numpy.linspace",
"numpy.unique",
"numpy.fliplr",
"sklearn.model_selection.StratifiedKFold",
"numpy.concatenate",
"numpy.ceil",
"numpy.zeros_like",
"numpy.array"
],
[
"numpy.amax",
"numpy.expand_dims",
"numpy.linspace",
"numpy.squeeze",
"numpy.concatenate",
"numpy.mean",
"torch.no_grad",
"torch.cuda.is_available",
"torch.device",
"numpy.where",
"numpy.histogram",
"pandas.read_csv",
"numpy.arange",
"torch.from_numpy",
"numpy.argmax",
"numpy.amin",
"pandas.DataFrame.from_dict",
"numpy.array",
"numpy.sum",
"torch.nn.DataParallel"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [
"2.0",
"1.4",
"1.1",
"1.5",
"1.2",
"1.3"
],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [
"2.0",
"1.4",
"1.3",
"1.1",
"1.5",
"1.2"
],
"scipy": [],
"tensorflow": []
}
] |
miniTsl/IC3Net | [
"897ed3bae6ad5f65fb3cc4577d4392af6e456703"
] | [
"ic3net_envs/ic3net_envs/predator_prey_env.py"
] | [
"#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\"\"\"\nSimulate a predator prey environment.\nEach agent can just observe itself (it's own identity) i.e. s_j = j and vision sqaure around it.\n\nDesign Decisions:\n - Memory cheaper than time (compute)\n - Using Vocab for class of box:\n -1 out of bound,\n indexing for predator agent (from 2?)\n ??? for prey agent (1 for fixed case, for now)\n - Action Space & Observation Space are according to an agent\n - Rewards -0.05 at each time step till the time\n - Episode never ends\n - Obs. State: Vocab of 1-hot < predator, preys & units >\n\"\"\"\n\n# core modules\nimport random\nimport math\nimport curses\n\n# 3rd party modules\nimport gym\nimport numpy as np\nfrom gym import spaces\n\n\nclass PredatorPreyEnv(gym.Env):\n # metadata = {'render.modes': ['human']}\n\n def __init__(self,):\n self.__version__ = \"0.0.1\"\n\n # TODO: better config handling\n self.OUTSIDE_CLASS = 1\n self.PREY_CLASS = 2\n self.PREDATOR_CLASS = 3\n self.TIMESTEP_PENALTY = -0.05\n self.PREY_REWARD = 0\n self.POS_PREY_REWARD = 0.05\n self.episode_over = False\n\n def init_curses(self):\n self.stdscr = curses.initscr()\n curses.start_color()\n curses.use_default_colors()\n curses.init_pair(1, curses.COLOR_RED, -1)\n curses.init_pair(2, curses.COLOR_YELLOW, -1)\n curses.init_pair(3, curses.COLOR_CYAN, -1)\n curses.init_pair(4, curses.COLOR_GREEN, -1)\n\n\n def init_args(self, parser):\n env = parser.add_argument_group('Prey Predator task')\n env.add_argument('--nenemies', type=int, default=1,\n help=\"Total number of preys in play\")\n env.add_argument('--dim', type=int, default=5,\n help=\"Dimension of box\")\n env.add_argument('--vision', type=int, default=2,\n help=\"Vision of predator\")\n env.add_argument('--moving_prey', action=\"store_true\", default=False,\n help=\"Whether prey is fixed or moving\")\n env.add_argument('--no_stay', action=\"store_true\", default=False,\n help=\"Whether predators have an action to stay in place\")\n parser.add_argument('--mode', default='mixed', type=str,\n help='cooperative|competitive|mixed (default: mixed)')\n env.add_argument('--enemy_comm', action=\"store_true\", default=False,\n help=\"Whether prey can communicate.\")\n\n def multi_agent_init(self, args):\n\n # General variables defining the environment : CONFIG\n params = ['dim', 'vision', 'moving_prey', 'mode', 'enemy_comm']\n for key in params:\n setattr(self, key, getattr(args, key))\n\n self.nprey = args.nenemies\n self.npredator = args.nfriendly\n self.dims = dims = (self.dim, self.dim)\n self.stay = not args.no_stay\n\n if args.moving_prey:\n raise NotImplementedError\n # TODO\n\n # (0: UP, 1: RIGHT, 2: DOWN, 3: LEFT, 4: STAY)\n # Define what an agent can do -\n if self.stay:\n self.naction = 5\n else:\n self.naction = 4\n\n self.action_space = spaces.MultiDiscrete([self.naction])\n\n self.BASE = (dims[0] * dims[1])\n self.OUTSIDE_CLASS += self.BASE\n self.PREY_CLASS += self.BASE\n self.PREDATOR_CLASS += self.BASE\n\n # Setting max vocab size for 1-hot encoding\n self.vocab_size = 1 + 1 + self.BASE + 1 + 1\n # predator + prey + grid + outside\n\n # Observation for each agent will be vision * vision ndarray\n self.observation_space = spaces.Box(low=0, high=1, shape=(self.vocab_size, (2 * self.vision) + 1, (2 * self.vision) + 1), dtype=int)\n # Actual observation will be of the shape 1 * npredator * (2v+1) * (2v+1) * vocab_size\n\n return\n\n def step(self, action):\n \"\"\"\n The agents take a step in the environment.\n\n Parameters\n ----------\n action : list/ndarray of length m, containing the indexes of what lever each 'm' chosen agents pulled.\n\n Returns\n -------\n obs, reward, episode_over, info : tuple\n obs (object) :\n\n reward (float) : Ratio of Number of discrete levers pulled to total number of levers.\n episode_over (bool) : Will be true as episode length is 1\n info (dict) : diagnostic information useful for debugging.\n \"\"\"\n if self.episode_over:\n raise RuntimeError(\"Episode is done\")\n action = np.array(action).squeeze()\n action = np.atleast_1d(action)\n\n for i, a in enumerate(action):\n self._take_action(i, a)\n\n assert np.all(action <= self.naction), \"Actions should be in the range [0,naction).\"\n\n\n self.episode_over = False\n self.obs = self._get_obs()\n\n debug = {'predator_locs':self.predator_loc,'prey_locs':self.prey_loc}\n return self.obs, self._get_reward(), self.episode_over, debug\n\n def reset(self):\n \"\"\"\n Reset the state of the environment and returns an initial observation.\n\n Returns\n -------\n observation (object): the initial observation of the space.\n \"\"\"\n self.episode_over = False\n self.reached_prey = np.zeros(self.npredator)\n\n # Locations\n locs = self._get_cordinates()\n self.predator_loc, self.prey_loc = locs[:self.npredator], locs[self.npredator:]\n\n self._set_grid()\n\n # stat - like success ratio\n self.stat = dict()\n\n # Observation will be npredator * vision * vision ndarray\n self.obs = self._get_obs()\n return self.obs\n\n def seed(self):\n return\n\n def _get_cordinates(self):\n idx = np.random.choice(np.prod(self.dims),(self.npredator + self.nprey), replace=False)\n return np.vstack(np.unravel_index(idx, self.dims)).T\n\n def _set_grid(self):\n self.grid = np.arange(self.BASE).reshape(self.dims)\n # Mark agents in grid\n # self.grid[self.predator_loc[:,0], self.predator_loc[:,1]] = self.predator_ids\n # self.grid[self.prey_loc[:,0], self.prey_loc[:,1]] = self.prey_ids\n\n # Padding for vision\n self.grid = np.pad(self.grid, self.vision, 'constant', constant_values = self.OUTSIDE_CLASS)\n\n self.empty_bool_base_grid = self._onehot_initialization(self.grid)\n\n def _get_obs(self):\n self.bool_base_grid = self.empty_bool_base_grid.copy()\n\n for i, p in enumerate(self.predator_loc):\n self.bool_base_grid[p[0] + self.vision, p[1] + self.vision, self.PREDATOR_CLASS] += 1\n\n for i, p in enumerate(self.prey_loc):\n self.bool_base_grid[p[0] + self.vision, p[1] + self.vision, self.PREY_CLASS] += 1\n\n obs = []\n for p in self.predator_loc:\n slice_y = slice(p[0], p[0] + (2 * self.vision) + 1)\n slice_x = slice(p[1], p[1] + (2 * self.vision) + 1)\n obs.append(self.bool_base_grid[slice_y, slice_x])\n\n if self.enemy_comm:\n for p in self.prey_loc:\n slice_y = slice(p[0], p[0] + (2 * self.vision) + 1)\n slice_x = slice(p[1], p[1] + (2 * self.vision) + 1)\n obs.append(self.bool_base_grid[slice_y, slice_x])\n\n obs = np.stack(obs)\n return obs\n\n def _take_action(self, idx, act):\n # prey action\n if idx >= self.npredator:\n # fixed prey\n if not self.moving_prey:\n return\n else:\n raise NotImplementedError\n\n if self.reached_prey[idx] == 1:\n return\n\n # STAY action\n if act==5:\n return\n\n # UP\n if act==0 and self.grid[max(0,\n self.predator_loc[idx][0] + self.vision - 1),\n self.predator_loc[idx][1] + self.vision] != self.OUTSIDE_CLASS:\n self.predator_loc[idx][0] = max(0, self.predator_loc[idx][0]-1)\n\n # RIGHT\n elif act==1 and self.grid[self.predator_loc[idx][0] + self.vision,\n min(self.dims[1] -1,\n self.predator_loc[idx][1] + self.vision + 1)] != self.OUTSIDE_CLASS:\n self.predator_loc[idx][1] = min(self.dims[1]-1,\n self.predator_loc[idx][1]+1)\n\n # DOWN\n elif act==2 and self.grid[min(self.dims[0]-1,\n self.predator_loc[idx][0] + self.vision + 1),\n self.predator_loc[idx][1] + self.vision] != self.OUTSIDE_CLASS:\n self.predator_loc[idx][0] = min(self.dims[0]-1,\n self.predator_loc[idx][0]+1)\n\n # LEFT\n elif act==3 and self.grid[self.predator_loc[idx][0] + self.vision,\n max(0,\n self.predator_loc[idx][1] + self.vision - 1)] != self.OUTSIDE_CLASS:\n self.predator_loc[idx][1] = max(0, self.predator_loc[idx][1]-1)\n\n def _get_reward(self):\n n = self.npredator if not self.enemy_comm else self.npredator + self.nprey\n reward = np.full(n, self.TIMESTEP_PENALTY)\n\n on_prey = np.where(np.all(self.predator_loc == self.prey_loc,axis=1))[0]\n nb_predator_on_prey = on_prey.size\n\n if self.mode == 'cooperative':\n reward[on_prey] = self.POS_PREY_REWARD * nb_predator_on_prey\n elif self.mode == 'competitive':\n if nb_predator_on_prey:\n reward[on_prey] = self.POS_PREY_REWARD / nb_predator_on_prey\n elif self.mode == 'mixed':\n reward[on_prey] = self.PREY_REWARD\n else:\n raise RuntimeError(\"Incorrect mode, Available modes: [cooperative|competitive|mixed]\")\n\n self.reached_prey[on_prey] = 1\n\n if np.all(self.reached_prey == 1) and self.mode == 'mixed':\n self.episode_over = True\n\n # Prey reward\n if nb_predator_on_prey == 0:\n reward[self.npredator:] = -1 * self.TIMESTEP_PENALTY\n else:\n # TODO: discuss & finalise\n reward[self.npredator:] = 0\n\n # Success ratio\n if self.mode != 'competitive':\n if nb_predator_on_prey == self.npredator:\n self.stat['success'] = 1\n else:\n self.stat['success'] = 0\n\n return reward\n\n def reward_terminal(self):\n return np.zeros_like(self._get_reward())\n\n\n def _onehot_initialization(self, a):\n ncols = self.vocab_size\n out = np.zeros(a.shape + (ncols,), dtype=int)\n out[self._all_idx(a, axis=2)] = 1\n return out\n\n def _all_idx(self, idx, axis):\n grid = np.ogrid[tuple(map(slice, idx.shape))]\n grid.insert(axis, idx)\n return tuple(grid)\n\n def render(self, mode='human', close=False):\n grid = np.zeros(self.BASE, dtype=object).reshape(self.dims)\n self.stdscr.clear()\n\n for p in self.predator_loc:\n if grid[p[0]][p[1]] != 0:\n grid[p[0]][p[1]] = str(grid[p[0]][p[1]]) + 'X'\n else:\n grid[p[0]][p[1]] = 'X'\n\n for p in self.prey_loc:\n if grid[p[0]][p[1]] != 0:\n grid[p[0]][p[1]] = str(grid[p[0]][p[1]]) + 'P'\n else:\n grid[p[0]][p[1]] = 'P'\n\n for row_num, row in enumerate(grid):\n for idx, item in enumerate(row):\n if item != 0:\n if 'X' in item and 'P' in item:\n self.stdscr.addstr(row_num, idx * 4, item.center(3), curses.color_pair(3))\n elif 'X' in item:\n self.stdscr.addstr(row_num, idx * 4, item.center(3), curses.color_pair(1))\n else:\n self.stdscr.addstr(row_num, idx * 4, item.center(3), curses.color_pair(2))\n else:\n self.stdscr.addstr(row_num, idx * 4, '0'.center(3), curses.color_pair(4))\n\n self.stdscr.addstr(len(grid), 0, '\\n')\n self.stdscr.refresh()\n\n def exit_render(self):\n curses.endwin()\n"
] | [
[
"numpy.unravel_index",
"numpy.pad",
"numpy.arange",
"numpy.stack",
"numpy.full",
"numpy.atleast_1d",
"numpy.all",
"numpy.prod",
"numpy.array",
"numpy.zeros"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
antoyang/TubeDETR | [
"3c32cc92a0fdaa0c770d95a59d8764e0e212424c"
] | [
"util/box_ops.py"
] | [
"# Copyright (c) Aishwarya Kamath & Nicolas Carion. Licensed under the Apache License 2.0. All Rights Reserved\n# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved\n\"\"\"\nUtilities for bounding box manipulation and GIoU.\n\"\"\"\nimport torch\nimport numpy as np\nfrom torchvision.ops.boxes import box_area\nfrom typing import Tuple\n\n#### Bounding box utilities imported from torchvision and converted to numpy\ndef np_box_area(boxes: np.array) -> np.array:\n \"\"\"\n Computes the area of a set of bounding boxes, which are specified by its\n (x1, y1, x2, y2) coordinates.\n\n Args:\n boxes (Tensor[N, 4]): boxes for which the area will be computed. They\n are expected to be in (x1, y1, x2, y2) format with\n ``0 <= x1 < x2`` and ``0 <= y1 < y2``.\n\n Returns:\n area (Tensor[N]): area for each box\n \"\"\"\n assert boxes.ndim == 2 and boxes.shape[-1] == 4\n return (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1])\n\n\n# implementation from https://github.com/kuangliu/torchcv/blob/master/torchcv/utils/box.py\n# with slight modifications\ndef _box_inter_union(boxes1: np.array, boxes2: np.array) -> Tuple[np.array, np.array]:\n area1 = np_box_area(boxes1)\n area2 = np_box_area(boxes2)\n\n lt = np.maximum(boxes1[:, None, :2], boxes2[:, :2]) # [N,M,2]\n rb = np.minimum(boxes1[:, None, 2:], boxes2[:, 2:]) # [N,M,2]\n\n wh = (rb - lt).clip(min=0) # [N,M,2]\n inter = wh[:, :, 0] * wh[:, :, 1] # [N,M]\n\n union = area1[:, None] + area2 - inter\n\n return inter, union\n\n\ndef np_box_iou(boxes1: np.array, boxes2: np.array) -> np.array:\n \"\"\"\n Return intersection-over-union (Jaccard index) of boxes.\n\n Both sets of boxes are expected to be in ``(x1, y1, x2, y2)`` format with\n ``0 <= x1 < x2`` and ``0 <= y1 < y2``.\n\n Args:\n boxes1 (Tensor[N, 4])\n boxes2 (Tensor[M, 4])\n\n Returns:\n iou (Tensor[N, M]): the NxM matrix containing the pairwise IoU values for every element in boxes1 and boxes2\n \"\"\"\n inter, union = _box_inter_union(boxes1, boxes2)\n iou = inter / union\n return iou\n\n\ndef box_cxcywh_to_xyxy(x):\n x_c, y_c, w, h = x.unbind(-1)\n b = [(x_c - 0.5 * w), (y_c - 0.5 * h), (x_c + 0.5 * w), (y_c + 0.5 * h)]\n return torch.stack(b, dim=-1)\n\n\ndef box_xyxy_to_cxcywh(x):\n x0, y0, x1, y1 = x.unbind(-1)\n b = [(x0 + x1) / 2, (y0 + y1) / 2, (x1 - x0), (y1 - y0)]\n return torch.stack(b, dim=-1)\n\n\n# modified from torchvision to also return the union\ndef box_iou(boxes1, boxes2):\n area1 = box_area(boxes1)\n area2 = box_area(boxes2)\n\n lt = torch.max(boxes1[:, None, :2], boxes2[:, :2]) # [N,M,2]\n rb = torch.min(boxes1[:, None, 2:], boxes2[:, 2:]) # [N,M,2]\n\n wh = (rb - lt).clamp(min=0) # [N,M,2]\n inter = wh[:, :, 0] * wh[:, :, 1] # [N,M]\n\n union = area1[:, None] + area2 - inter\n\n iou = inter / union\n return iou, union\n\n\ndef generalized_box_iou(boxes1, boxes2):\n \"\"\"\n Generalized IoU from https://giou.stanford.edu/\n\n The boxes should be in [x0, y0, x1, y1] format\n\n Returns a [N, M] pairwise matrix, where N = len(boxes1)\n and M = len(boxes2)\n \"\"\"\n # degenerate boxes gives inf / nan results\n # so do an early check\n assert (boxes1[:, 2:] >= boxes1[:, :2]).all()\n assert (boxes2[:, 2:] >= boxes2[:, :2]).all()\n iou, union = box_iou(boxes1, boxes2)\n\n lt = torch.min(boxes1[:, None, :2], boxes2[:, :2])\n rb = torch.max(boxes1[:, None, 2:], boxes2[:, 2:])\n\n wh = (rb - lt).clamp(min=0) # [N,M,2]\n area = wh[:, :, 0] * wh[:, :, 1]\n\n return iou - (area - union) / area\n\n\ndef masks_to_boxes(masks):\n \"\"\"Compute the bounding boxes around the provided masks\n\n The masks should be in format [N, H, W] where N is the number of masks, (H, W) are the spatial dimensions.\n\n Returns a [N, 4] tensors, with the boxes in xyxy format\n \"\"\"\n if masks.numel() == 0:\n return torch.zeros((0, 4), device=masks.device)\n\n h, w = masks.shape[-2:]\n\n y = torch.arange(0, h, dtype=torch.float)\n x = torch.arange(0, w, dtype=torch.float)\n y, x = torch.meshgrid(y, x)\n\n x_mask = masks * x.unsqueeze(0)\n x_max = x_mask.flatten(1).max(-1)[0]\n x_min = x_mask.masked_fill(~(masks.bool()), 1e8).flatten(1).min(-1)[0]\n\n y_mask = masks * y.unsqueeze(0)\n y_max = y_mask.flatten(1).max(-1)[0]\n y_min = y_mask.masked_fill(~(masks.bool()), 1e8).flatten(1).min(-1)[0]\n\n return torch.stack([x_min, y_min, x_max, y_max], 1)\n"
] | [
[
"numpy.maximum",
"torch.max",
"numpy.minimum",
"torch.zeros",
"torch.min",
"torch.arange",
"torch.stack",
"torch.meshgrid"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
kejsitake/sktime | [
"5c608f09ce0f5216677ce9f6ad61d71584211db9"
] | [
"sktime/contrib/vector_classifiers/_rotation_forest.py"
] | [
"# -*- coding: utf-8 -*-\n\"\"\"RotationForest vector classifier.\n\nRotation Forest, sktime implementation for continuous values only.\n\"\"\"\n\n__author__ = [\"MatthewMiddlehurst\"]\n__all__ = [\"RotationForest\"]\n\nimport time\n\nimport numpy as np\nfrom joblib import Parallel, delayed\nfrom sklearn.base import BaseEstimator\nfrom sklearn.decomposition import PCA\nfrom sklearn.tree import DecisionTreeClassifier\nfrom sklearn.utils import check_random_state, check_X_y\n\nfrom sktime.base._base import _clone_estimator\nfrom sktime.exceptions import NotFittedError\nfrom sktime.utils.validation import check_n_jobs\n\n\nclass RotationForest(BaseEstimator):\n \"\"\"Rotation Forest Classifier.\n\n Implementation of the Rotation Forest classifier described in Rodriguez et al\n (2013). [1]_\n Intended as a benchmark for time series data and a base classifier for\n transformation based appraoches such as ShapeletTransformClassifier, this sktime\n implementation only works with continuous attributes.\n\n Parameters\n ----------\n n_estimators : int, default=200\n Number of estimators to build for the ensemble.\n min_group : int, default=3\n The minimum size of a group.\n max_group : int, default=3\n The maximum size of a group.\n remove_proportion : float, default=0.5\n The proportion of cases to be removed.\n base_estimator : BaseEstimator or None, default=\"None\"\n Base estimator for the ensemble. By default uses the sklearn\n DecisionTreeClassifier using entropy as a splitting measure.\n time_limit_in_minutes : int, default=0\n Time contract to limit build time in minutes, overriding n_estimators.\n Default of 0 means n_estimators is used.\n contract_max_n_estimators : int, default=500\n Max number of estimators when time_limit_in_minutes is set.\n save_transformed_data : bool, default=False\n Save the data transformed in fit for use in _get_train_probs.\n n_jobs : int, default=1\n The number of jobs to run in parallel for both `fit` and `predict`.\n ``-1`` means using all processors.\n random_state : int or None, default=None\n Seed for random number generation.\n\n Attributes\n ----------\n n_classes : int\n The number of classes.\n n_instances : int\n The number of train cases.\n n_atts : int\n The number of attributes in each train case.\n classes_ : list\n The classes labels.\n estimators_ : list of shape (n_estimators) of BaseEstimator\n The collections of estimators trained in fit.\n transformed_data : list of shape (n_estimators) of ndarray\n The transformed dataset for all classifiers. Only saved when\n save_transformed_data is true.\n\n See Also\n --------\n ShapeletTransformClassifier\n\n Notes\n -----\n For the Java version, see\n `TSML <https://github.com/uea-machine-learning/tsml/blob/master/src/main/java\n /weka/classifiers/meta/RotationForest.java>`_.\n\n References\n ----------\n .. [1] Rodriguez, Juan José, Ludmila I. Kuncheva, and Carlos J. Alonso. \"Rotation\n forest: A new classifier ensemble method.\" IEEE transactions on pattern analysis\n and machine intelligence 28.10 (2006).\n\n .. [2] Bagnall, A., et al. \"Is rotation forest the best classifier for problems\n with continuous features?.\" arXiv preprint arXiv:1809.06705 (2018).\n\n Examples\n --------\n >>> from sktime.contrib.vector_classifiers._rotation_forest import RotationForest\n >>> from sktime.datasets import load_unit_test\n >>> from sktime.datatypes._panel._convert import from_nested_to_3d_numpy\n >>> X_train, y_train = load_unit_test(split=\"train\", return_X_y=True)\n >>> X_test, y_test = load_unit_test(split=\"test\", return_X_y=True)\n >>> X_train = from_nested_to_3d_numpy(X_train)\n >>> X_test = from_nested_to_3d_numpy(X_test)\n >>> clf = RotationForest(n_estimators=10)\n >>> clf.fit(X_train, y_train)\n RotationForest(...)\n >>> y_pred = clf.predict(X_test)\n \"\"\"\n\n def __init__(\n self,\n n_estimators=200,\n min_group=3,\n max_group=3,\n remove_proportion=0.5,\n base_estimator=None,\n time_limit_in_minutes=0.0,\n contract_max_n_estimators=500,\n save_transformed_data=False,\n n_jobs=1,\n random_state=None,\n ):\n self.n_estimators = n_estimators\n self.min_group = min_group\n self.max_group = max_group\n self.remove_proportion = remove_proportion\n self.base_estimator = base_estimator\n\n self.time_limit_in_minutes = time_limit_in_minutes\n self.contract_max_n_estimators = contract_max_n_estimators\n self.save_transformed_data = save_transformed_data\n\n self.n_jobs = n_jobs\n self.random_state = random_state\n\n self.n_classes = 0\n self.n_instances = 0\n self.n_atts = 0\n self.classes_ = []\n self.estimators_ = []\n self.transformed_data = []\n\n self._n_estimators = n_estimators\n self._base_estimator = base_estimator\n self._min = 0\n self._ptp = 0\n self._useful_atts = []\n self._pcas = []\n self._groups = []\n self._class_dictionary = {}\n self._n_jobs = n_jobs\n self._n_atts = 0\n # We need to add is-fitted state when inheriting from scikit-learn\n self._is_fitted = False\n\n super(RotationForest, self).__init__()\n\n def fit(self, X, y):\n \"\"\"Fit a forest of trees on cases (X,y), where y is the target variable.\n\n Parameters\n ----------\n X : ndarray of shape = [n_instances,n_attributes]\n The training input samples.\n y : array-like, shape = [n_instances]\n The class labels.\n\n Returns\n -------\n self : object\n \"\"\"\n if isinstance(X, np.ndarray) and len(X.shape) == 3 and X.shape[1] == 1:\n X = np.reshape(X, (X.shape[0], -1))\n elif not isinstance(X, np.ndarray) or len(X.shape) > 2:\n raise ValueError(\n \"RotationForest is not a time series classifier. \"\n \"A 2d numpy array is required.\"\n )\n X, y = check_X_y(X, y)\n\n self._n_jobs = check_n_jobs(self.n_jobs)\n\n self.n_instances, self.n_atts = X.shape\n self.classes_ = np.unique(y)\n self.n_classes = self.classes_.shape[0]\n for index, classVal in enumerate(self.classes_):\n self._class_dictionary[classVal] = index\n\n time_limit = self.time_limit_in_minutes * 60\n start_time = time.time()\n train_time = 0\n\n if self.base_estimator is None:\n self._base_estimator = DecisionTreeClassifier(criterion=\"entropy\")\n\n # replace missing values with 0 and remove useless attributes\n X = np.nan_to_num(X, False, 0, 0, 0)\n self._useful_atts = ~np.all(X[1:] == X[:-1], axis=0)\n X = X[:, self._useful_atts]\n\n self._n_atts = X.shape[1]\n\n # normalise attributes\n self._min = X.min(axis=0)\n self._ptp = X.max(axis=0) - self._min\n X = (X - self._min) / self._ptp\n\n X_cls_split = [X[np.where(y == i)] for i in self.classes_]\n\n if time_limit > 0:\n self._n_estimators = 0\n self.estimators_ = []\n self._pcas = []\n self._groups = []\n\n while (\n train_time < time_limit\n and self._n_estimators < self.contract_max_n_estimators\n ):\n fit = Parallel(n_jobs=self._n_jobs)(\n delayed(self._fit_estimator)(\n X,\n X_cls_split,\n y,\n i,\n )\n for i in range(self._n_jobs)\n )\n\n estimators, pcas, groups, transformed_data = zip(*fit)\n\n self.estimators_ += estimators\n self._pcas += pcas\n self._groups += groups\n self.transformed_data += transformed_data\n\n self._n_estimators += self._n_jobs\n train_time = time.time() - start_time\n else:\n fit = Parallel(n_jobs=self._n_jobs)(\n delayed(self._fit_estimator)(\n X,\n X_cls_split,\n y,\n i,\n )\n for i in range(self._n_estimators)\n )\n\n self.estimators_, self._pcas, self._groups, self.transformed_data = zip(\n *fit\n )\n\n self._is_fitted = True\n return self\n\n def predict(self, X):\n \"\"\"Predict for all cases in X. Built on top of predict_proba.\n\n Parameters\n ----------\n X : ndarray of shape = [n_instances,n_attributes]\n\n Returns\n -------\n output : array of shape = [n_test_instances]\n \"\"\"\n rng = check_random_state(self.random_state)\n return np.array(\n [\n self.classes_[int(rng.choice(np.flatnonzero(prob == prob.max())))]\n for prob in self.predict_proba(X)\n ]\n )\n\n def predict_proba(self, X):\n \"\"\"Probability estimates for each class for all cases in X.\n\n Parameters\n ----------\n X : ndarray of shape = [n_instances,n_attributes]\n\n Returns\n -------\n output : array of shape = [n_test_instances, num_classes] of\n probabilities\n \"\"\"\n if not self._is_fitted:\n raise NotFittedError(\n f\"This instance of {self.__class__.__name__} has not \"\n f\"been fitted yet; please call `fit` first.\"\n )\n if isinstance(X, np.ndarray) and len(X.shape) == 3 and X.shape[1] == 1:\n X = np.reshape(X, (X.shape[0], -1))\n elif not isinstance(X, np.ndarray) or len(X.shape) > 2:\n raise ValueError(\n \"RotationForest is not a time series classifier. \"\n \"A 2d numpy array is required.\"\n )\n\n # replace missing values with 0 and remove useless attributes\n X = np.nan_to_num(X, False, 0, 0, 0)\n X = X[:, self._useful_atts]\n\n # normalise the data.\n X = (X - self._min) / self._ptp\n\n y_probas = Parallel(n_jobs=self._n_jobs)(\n delayed(self._predict_proba_for_estimator)(\n X,\n self.estimators_[i],\n self._pcas[i],\n self._groups[i],\n )\n for i in range(self._n_estimators)\n )\n\n output = np.sum(y_probas, axis=0) / (\n np.ones(self.n_classes) * self._n_estimators\n )\n return output\n\n def _get_train_probs(self, X, y):\n if not self._is_fitted:\n raise NotFittedError(\n f\"This instance of {self.__class__.__name__} has not \"\n f\"been fitted yet; please call `fit` first.\"\n )\n if isinstance(X, np.ndarray) and len(X.shape) == 3 and X.shape[1] == 1:\n X = np.reshape(X, (X.shape[0], -1))\n elif not isinstance(X, np.ndarray) or len(X.shape) > 2:\n raise ValueError(\n \"RotationForest is not a time series classifier. \"\n \"A 2d numpy array is required.\"\n )\n\n n_instances, n_atts = X.shape\n\n if n_instances != self.n_instances or n_atts != self.n_atts:\n raise ValueError(\n \"n_instances, n_dims, series_length mismatch. X should be \"\n \"the same as the training data used in fit for generating train \"\n \"probabilities.\"\n )\n\n if not self.save_transformed_data:\n raise ValueError(\"Currently only works with saved transform data from fit.\")\n\n p = Parallel(n_jobs=self._n_jobs)(\n delayed(self._train_probas_for_estimator)(\n y,\n i,\n )\n for i in range(self._n_estimators)\n )\n y_probas, oobs = zip(*p)\n\n results = np.sum(y_probas, axis=0)\n divisors = np.zeros(n_instances)\n for oob in oobs:\n for inst in oob:\n divisors[inst] += 1\n\n for i in range(n_instances):\n results[i] = (\n np.ones(self.n_classes) * (1 / self.n_classes)\n if divisors[i] == 0\n else results[i] / (np.ones(self.n_classes) * divisors[i])\n )\n\n return results\n\n def _fit_estimator(self, X, X_cls_split, y, idx):\n rs = 255 if self.random_state == 0 else self.random_state\n rs = (\n None\n if self.random_state is None\n else (rs * 37 * (idx + 1)) % np.iinfo(np.int32).max\n )\n rng = check_random_state(rs)\n\n groups = self._generate_groups(rng)\n pcas = []\n\n # construct the slices to fit the PCAs too.\n for group in groups:\n classes = rng.choice(\n range(self.n_classes),\n size=rng.randint(1, self.n_classes + 1),\n replace=False,\n )\n\n # randomly add the classes with the randomly selected attributes.\n X_t = np.zeros((0, len(group)))\n for cls_idx in classes:\n c = X_cls_split[cls_idx]\n X_t = np.concatenate((X_t, c[:, group]), axis=0)\n\n sample_ind = rng.choice(\n X_t.shape[0],\n int(X_t.shape[0] * self.remove_proportion),\n replace=False,\n )\n X_t = X_t[sample_ind]\n\n # try to fit the PCA if it fails, remake it, and add 10 random data instances.\n while True:\n # ignore err state on PCA because we account if it fails.\n with np.errstate(divide=\"ignore\", invalid=\"ignore\"):\n # differences between os occasionally. seems to happen when there\n # are low amounts of cases in the fit\n pca = PCA(random_state=rs).fit(X_t)\n\n if not np.isnan(pca.explained_variance_ratio_).all():\n break\n X_t = np.concatenate(\n (X_t, rng.random_sample((10, X_t.shape[1]))), axis=0\n )\n\n pcas.append(pca)\n\n # merge all the pca_transformed data into one instance and build a classifier on it.\n X_t = np.concatenate(\n [pcas[i].transform(X[:, group]) for i, group in enumerate(groups)], axis=1\n )\n tree = _clone_estimator(self._base_estimator, random_state=rs)\n tree.fit(X_t, y)\n\n return tree, pcas, groups, X_t if self.save_transformed_data else None\n\n def _predict_proba_for_estimator(self, X, clf, pcas, groups):\n X_t = np.concatenate(\n [pcas[i].transform(X[:, group]) for i, group in enumerate(groups)], axis=1\n )\n probas = clf.predict_proba(X_t)\n\n if probas.shape[1] != self.n_classes:\n new_probas = np.zeros((probas.shape[0], self.n_classes))\n for i, cls in enumerate(clf.classes_):\n cls_idx = self._class_dictionary[cls]\n new_probas[:, cls_idx] = probas[:, i]\n probas = new_probas\n\n return probas\n\n def _train_probas_for_estimator(self, y, idx):\n rs = 255 if self.random_state == 0 else self.random_state\n rs = (\n None\n if self.random_state is None\n else (rs * 37 * (idx + 1)) % np.iinfo(np.int32).max\n )\n rng = check_random_state(rs)\n\n indices = range(self.n_instances)\n subsample = rng.choice(self.n_instances, size=self.n_instances)\n oob = [n for n in indices if n not in subsample]\n\n clf = _clone_estimator(self._base_estimator, rs)\n clf.fit(self.transformed_data[idx][subsample], y[subsample])\n probas = clf.predict_proba(self.transformed_data[idx][oob])\n\n if probas.shape[1] != self.n_classes:\n new_probas = np.zeros((probas.shape[0], self.n_classes))\n for i, cls in enumerate(clf.classes_):\n cls_idx = self._class_dictionary[cls]\n new_probas[:, cls_idx] = probas[:, i]\n probas = new_probas\n\n results = np.zeros((self.n_instances, self.n_classes))\n for n, proba in enumerate(probas):\n results[oob[n]] += proba\n\n return [results, oob]\n\n def _generate_groups(self, rng):\n permutation = rng.permutation((np.arange(0, self._n_atts)))\n\n # select the size of each group.\n group_size_count = np.zeros(self.max_group - self.min_group + 1)\n n_attributes = 0\n n_groups = 0\n while n_attributes < self._n_atts:\n n = rng.randint(group_size_count.shape[0])\n group_size_count[n] += 1\n n_attributes += self.min_group + n\n n_groups += 1\n\n groups = []\n current_attribute = 0\n current_size = 0\n for i in range(0, n_groups):\n while group_size_count[current_size] == 0:\n current_size += 1\n group_size_count[current_size] -= 1\n\n n = self.min_group + current_size\n groups.append(np.zeros(n, dtype=int))\n for k in range(0, n):\n if current_attribute < permutation.shape[0]:\n groups[i][k] = permutation[current_attribute]\n else:\n groups[i][k] = permutation[rng.randint(permutation.shape[0])]\n current_attribute += 1\n\n return groups\n"
] | [
[
"numpy.sum",
"sklearn.utils.check_X_y",
"numpy.unique",
"numpy.reshape",
"numpy.arange",
"numpy.isnan",
"numpy.nan_to_num",
"numpy.ones",
"numpy.all",
"numpy.concatenate",
"sklearn.tree.DecisionTreeClassifier",
"numpy.where",
"numpy.iinfo",
"numpy.errstate",
"sklearn.decomposition.PCA",
"numpy.zeros",
"sklearn.utils.check_random_state"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
Benjamin15/shap | [
"4b6472c90c89aad403e00dff0cc8a6416f354fea"
] | [
"shap/plots/dependence.py"
] | [
"from __future__ import division\n\nfrom io import BytesIO\nimport base64\nimport numpy as np\nimport warnings\ntry:\n import matplotlib.pyplot as pl\n import matplotlib\nexcept ImportError:\n warnings.warn(\"matplotlib could not be loaded!\")\n pass\nfrom . import labels\nfrom . import colors\nfrom ..common import convert_name, approximate_interactions\n\ndef dependence_plot(ind, shap_values, features, feature_names=None, display_features=None,\n interaction_index=\"auto\",\n color=\"#1E88E5\", axis_color=\"#333333\", cmap=None,\n dot_size=16, x_jitter=0, alpha=1, title=None, xmin=None, xmax=None, ax=None, show=True,\n get_png=False):\n \"\"\" Create a SHAP dependence plot, colored by an interaction feature.\n\n Plots the value of the feature on the x-axis and the SHAP value of the same feature\n on the y-axis. This shows how the model depends on the given feature, and is like a\n richer extenstion of the classical parital dependence plots. Vertical dispersion of the\n data points represents interaction effects. Grey ticks along the y-axis are data\n points where the feature's value was NaN.\n\n\n Parameters\n ----------\n ind : int or string\n If this is an int it is the index of the feature to plot. If this is a string it is\n either the name of the feature to plot, or it can have the form \"rank(int)\" to specify\n the feature with that rank (ordered by mean absolute SHAP value over all the samples).\n\n shap_values : numpy.array\n Matrix of SHAP values (# samples x # features).\n\n features : numpy.array or pandas.DataFrame\n Matrix of feature values (# samples x # features).\n\n feature_names : list\n Names of the features (length # features).\n\n display_features : numpy.array or pandas.DataFrame\n Matrix of feature values for visual display (such as strings instead of coded values).\n\n interaction_index : \"auto\", None, int, or string\n The index of the feature used to color the plot. The name of a feature can also be passed\n as a string. If \"auto\" then shap.common.approximate_interactions is used to pick what\n seems to be the strongest interaction (note that to find to true stongest interaction you\n need to compute the SHAP interaction values).\n\n x_jitter : float (0 - 1)\n Adds random jitter to feature values. May increase plot readability when feature\n is discrete.\n\n alpha : float\n The transparency of the data points (between 0 and 1). This can be useful to the\n show density of the data points when using a large dataset.\n\n xmin : float or string\n Represents the lower bound of the plot's x-axis. It can be a string of the format\n \"percentile(float)\" to denote that percentile of the feature's value used on the x-axis.\n\n xmax : float or string\n Represents the upper bound of the plot's x-axis. It can be a string of the format\n \"percentile(float)\" to denote that percentile of the feature's value used on the x-axis.\n\n ax : matplotlib Axes object\n Optionally specify an existing matplotlib Axes object, into which the plot will be placed.\n In this case we do not create a Figure, otherwise we do.\n\n \"\"\"\n\n if cmap is None:\n cmap = colors.red_blue\n\n if type(shap_values) is list:\n raise TypeError(\"The passed shap_values are a list not an array! If you have a list of explanations try \" \\\n \"passing shap_values[0] instead to explain the first output class of a multi-output model.\")\n\n # convert from DataFrames if we got any\n if str(type(features)).endswith(\"'pandas.core.frame.DataFrame'>\"):\n if feature_names is None:\n feature_names = features.columns\n features = features.values\n if str(type(display_features)).endswith(\"'pandas.core.frame.DataFrame'>\"):\n if feature_names is None:\n feature_names = display_features.columns\n display_features = display_features.values\n elif display_features is None:\n display_features = features\n\n if feature_names is None:\n feature_names = [labels['FEATURE'] % str(i) for i in range(shap_values.shape[1])]\n\n # allow vectors to be passed\n if len(shap_values.shape) == 1:\n shap_values = np.reshape(shap_values, len(shap_values), 1)\n if len(features.shape) == 1:\n features = np.reshape(features, len(features), 1)\n\n ind = convert_name(ind, shap_values, feature_names)\n\n # guess what other feature as the stongest interaction with the plotted feature\n if not hasattr(ind, \"__len__\"):\n if interaction_index == \"auto\":\n interaction_index = approximate_interactions(ind, shap_values, features)[0]\n interaction_index = convert_name(interaction_index, shap_values, feature_names)\n categorical_interaction = False\n\n # create a matplotlib figure, if `ax` hasn't been specified.\n if not ax:\n figsize = (7.5, 5) if interaction_index != ind and interaction_index is not None else (6, 5)\n fig = pl.figure(figsize=figsize)\n ax = fig.gca()\n else:\n fig = ax.get_figure()\n\n # plotting SHAP interaction values\n if len(shap_values.shape) == 3 and hasattr(ind, \"__len__\") and len(ind) == 2:\n ind1 = convert_name(ind[0], shap_values, feature_names)\n ind2 = convert_name(ind[1], shap_values, feature_names)\n if ind1 == ind2:\n proj_shap_values = shap_values[:, ind2, :]\n else:\n proj_shap_values = shap_values[:, ind2, :] * 2 # off-diag values are split in half\n\n # there is no interaction coloring for the main effect\n if ind1 == ind2:\n fig.set_size_inches(6, 5, forward=True)\n\n # TODO: remove recursion; generally the functions should be shorter for more maintainable code\n dependence_plot(\n ind1, proj_shap_values, features, feature_names=feature_names,\n interaction_index=(None if ind1 == ind2 else ind2), display_features=display_features, ax=ax, show=False,\n xmin=xmin, xmax=xmax, x_jitter=x_jitter, alpha=alpha, get_png=get_png\n )\n if ind1 == ind2:\n ax.set_ylabel(labels['MAIN_EFFECT'] % feature_names[ind1])\n else:\n ax.set_ylabel(labels['INTERACTION_EFFECT'] % (feature_names[ind1], feature_names[ind2]))\n\n if show:\n pl.show()\n return\n\n assert shap_values.shape[0] == features.shape[0], \\\n \"'shap_values' and 'features' values must have the same number of rows!\"\n assert shap_values.shape[1] == features.shape[1], \\\n \"'shap_values' must have the same number of columns as 'features'!\"\n\n # get both the raw and display feature values\n oinds = np.arange(shap_values.shape[0]) # we randomize the ordering so plotting overlaps are not related to data ordering\n np.random.shuffle(oinds)\n xv = features[oinds, ind].astype(np.float64)\n xd = display_features[oinds, ind]\n s = shap_values[oinds, ind]\n if type(xd[0]) == str:\n name_map = {}\n for i in range(len(xv)):\n name_map[xd[i]] = xv[i]\n xnames = list(name_map.keys())\n\n # allow a single feature name to be passed alone\n if type(feature_names) == str:\n feature_names = [feature_names]\n name = feature_names[ind]\n\n # get both the raw and display color values\n color_norm = None\n if interaction_index is not None:\n cv = features[:, interaction_index]\n cd = display_features[:, interaction_index]\n clow = np.nanpercentile(cv.astype(np.float), 5)\n chigh = np.nanpercentile(cv.astype(np.float), 95)\n if clow == chigh:\n clow = np.nanmin(cv.astype(np.float))\n chigh = np.nanmax(cv.astype(np.float))\n if type(cd[0]) == str:\n cname_map = {}\n for i in range(len(cv)):\n cname_map[cd[i]] = cv[i]\n cnames = list(cname_map.keys())\n categorical_interaction = True\n elif clow % 1 == 0 and chigh % 1 == 0 and chigh - clow < 10:\n categorical_interaction = True\n\n # discritize colors for categorical features\n if categorical_interaction and clow != chigh:\n clow = np.nanmin(cv.astype(np.float))\n chigh = np.nanmax(cv.astype(np.float))\n bounds = np.linspace(clow, chigh, int(chigh - clow + 2))\n color_norm = matplotlib.colors.BoundaryNorm(bounds, cmap.N-1)\n\n # optionally add jitter to feature values\n if x_jitter > 0:\n if x_jitter > 1: x_jitter = 1\n xvals = xv.copy()\n if isinstance(xvals[0], float):\n xvals = xvals.astype(np.float)\n xvals = xvals[~np.isnan(xvals)]\n xvals = np.unique(xvals) # returns a sorted array\n if len(xvals) >= 2:\n smallest_diff = np.min(np.diff(xvals))\n jitter_amount = x_jitter * smallest_diff\n xv += (np.random.ranf(size = len(xv))*jitter_amount) - (jitter_amount/2)\n\n # the actual scatter plot, TODO: adapt the dot_size to the number of data points?\n xv_nan = np.isnan(xv)\n xv_notnan = np.invert(xv_nan)\n if interaction_index is not None:\n\n # plot the nan values in the interaction feature as grey\n cvals = features[oinds, interaction_index].astype(np.float64)\n cvals_imp = cvals.copy()\n cvals_imp[np.isnan(cvals)] = (clow + chigh) / 2.0\n cvals[cvals_imp > chigh] = chigh\n cvals[cvals_imp < clow] = clow\n p = ax.scatter(\n xv[xv_notnan], s[xv_notnan], s=dot_size, linewidth=0, c=cvals[xv_notnan],\n cmap=cmap, alpha=alpha, vmin=clow, vmax=chigh,\n norm=color_norm, rasterized=len(xv) > 500\n )\n p.set_array(cvals[xv_notnan])\n else:\n p = ax.scatter(xv, s, s=dot_size, linewidth=0, color=color,\n alpha=alpha, rasterized=len(xv) > 500)\n\n if interaction_index != ind and interaction_index is not None:\n # draw the color bar\n if type(cd[0]) == str:\n tick_positions = [cname_map[n] for n in cnames]\n if len(tick_positions) == 2:\n tick_positions[0] -= 0.25\n tick_positions[1] += 0.25\n cb = pl.colorbar(p, ticks=tick_positions, ax=ax)\n cb.set_ticklabels(cnames)\n else:\n cb = pl.colorbar(p, ax=ax)\n\n cb.set_label(feature_names[interaction_index], size=13)\n cb.ax.tick_params(labelsize=11)\n if categorical_interaction:\n cb.ax.tick_params(length=0)\n cb.set_alpha(1)\n cb.outline.set_visible(False)\n bbox = cb.ax.get_window_extent().transformed(fig.dpi_scale_trans.inverted())\n cb.ax.set_aspect((bbox.height - 0.7) * 20)\n\n # handles any setting of xmax and xmin\n # note that we handle None,float, or \"percentile(float)\" formats\n if xmin is not None or xmax is not None:\n if type(xmin) == str and xmin.startswith(\"percentile\"):\n xmin = np.nanpercentile(xv, float(xmin[11:-1]))\n if type(xmax) == str and xmax.startswith(\"percentile\"):\n xmax = np.nanpercentile(xv, float(xmax[11:-1]))\n\n if xmin is None or xmin == np.nanmin(xv):\n xmin = np.nanmin(xv) - (xmax - np.nanmin(xv))/20\n if xmax is None or xmax == np.nanmax(xv):\n xmax = np.nanmax(xv) + (np.nanmax(xv) - xmin)/20\n\n ax.set_xlim(xmin, xmax)\n\n # plot any nan feature values as tick marks along the y-axis\n xlim = ax.get_xlim()\n if interaction_index is not None:\n p = ax.scatter(\n xlim[0] * np.ones(xv_nan.sum()), s[xv_nan], marker=1,\n linewidth=2, c=cvals_imp[xv_nan], cmap=cmap, alpha=alpha,\n vmin=clow, vmax=chigh\n )\n p.set_array(cvals[xv_nan])\n else:\n ax.scatter(\n xlim[0] * np.ones(xv_nan.sum()), s[xv_nan], marker=1,\n linewidth=2, color=color, alpha=alpha\n )\n ax.set_xlim(xlim)\n\n # make the plot more readable\n ax.set_xlabel(name, color=axis_color, fontsize=13)\n ax.set_ylabel(labels['VALUE_FOR'] % name, color=axis_color, fontsize=13)\n if title is not None:\n ax.set_title(title, color=axis_color, fontsize=13)\n ax.xaxis.set_ticks_position('bottom')\n ax.yaxis.set_ticks_position('left')\n ax.spines['right'].set_visible(False)\n ax.spines['top'].set_visible(False)\n ax.tick_params(color=axis_color, labelcolor=axis_color, labelsize=11)\n for spine in ax.spines.values():\n spine.set_edgecolor(axis_color)\n if type(xd[0]) == str:\n ax.set_xticks([name_map[n] for n in xnames])\n ax.set_xticklabels(xnames, dict(rotation='vertical', fontsize=11))\n if show:\n with warnings.catch_warnings(): # ignore expected matplotlib warnings\n warnings.simplefilter(\"ignore\", RuntimeWarning)\n pl.show()\n if get_png:\n file = BytesIO()\n pl.savefig(file, format='png', bbox_inches=\"tight\")\n return file\n"
] | [
[
"numpy.nanmax",
"matplotlib.colors.BoundaryNorm",
"numpy.invert",
"numpy.unique",
"numpy.isnan",
"numpy.arange",
"numpy.nanmin",
"numpy.random.shuffle",
"matplotlib.pyplot.savefig",
"matplotlib.pyplot.colorbar",
"numpy.diff",
"matplotlib.pyplot.show",
"matplotlib.pyplot.figure"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
Awesomex005/CarND-Vehicle-Detection | [
"e12068887946605d148284aeea0262695d54743f"
] | [
"train_classifier.py"
] | [
"import matplotlib.image as mpimg\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport cv2\nimport glob\nimport time\nfrom sklearn.svm import LinearSVC\nfrom sklearn.preprocessing import StandardScaler\nfrom extract_feature import *\n# NOTE: the next import is only valid for scikit-learn version <= 0.17\n# for scikit-learn >= 0.18 use:\n# from sklearn.model_selection import train_test_split\nfrom sklearn.cross_validation import train_test_split\nimport pickle\n\n\n# Read in cars and notcars\ncars = glob.glob('./train_data/vehicles/*/*.png'); train_data_tpye = 'png'; notcars = glob.glob('./train_data/non-vehicles/*/*.png')\n#cars = glob.glob('./hog_test_imgs/vehicles_smallset/*/*.jpeg'); train_data_tpye = 'jpeg'; #notcars = glob.glob('./hog_test_imgs/non-vehicles_smallset/*/*.jpeg')\nsample_size = None\ncars = cars[0:sample_size]\nnotcars = notcars[0:sample_size]\n\ncolor_space = 'YCrCb' # Can be RGB, HSV, LUV, HLS, YUV, YCrCb\norient = 9 # HOG orientations\npix_per_cell = 8 # HOG pixels per cell\ncell_per_block = 2 # HOG cells per block\nhog_channel = \"ALL\" # Can be 0, 1, 2, or \"ALL\"\nspatial_size = (32, 32) # Spatial binning dimensions\nhist_bins = 32 # Number of histogram bins\nspatial_feat = True # Spatial features on or off\nhist_feat = True # Histogram features on or off\nhog_feat = True # HOG features on or off\ny_start_stop = [None, None] # Min and max in y to search in slide_window()\n\nt = time.time()\nprint(\"start extract car_features\")\ncar_features = extract_features(cars, train_data_tpye, color_space=color_space, \n spatial_size=spatial_size, hist_bins=hist_bins, \n orient=orient, pix_per_cell=pix_per_cell, \n cell_per_block=cell_per_block, \n hog_channel=hog_channel, spatial_feat=spatial_feat, \n hist_feat=hist_feat, hog_feat=hog_feat)\nprint(\"start extract notcar_features\")\nnotcar_features = extract_features(notcars, train_data_tpye, color_space=color_space, \n spatial_size=spatial_size, hist_bins=hist_bins, \n orient=orient, pix_per_cell=pix_per_cell, \n cell_per_block=cell_per_block, \n hog_channel=hog_channel, spatial_feat=spatial_feat, \n hist_feat=hist_feat, hog_feat=hog_feat)\n \nX = np.vstack((car_features, notcar_features)).astype(np.float64)\n\n# Define the labels vector\ny = np.hstack((np.ones(len(car_features)), np.zeros(len(notcar_features))))\n\n# Split up data into randomized training and test sets\nrand_state = np.random.randint(0, 100)\nX_train, X_test, y_train, y_test = train_test_split(\n X, y, test_size=0.2, random_state=rand_state)\n\nt2 = time.time()\nprint(round(t2-t, 2), 'Seconds to extract features SVC...')\n \nprint(\"X_train shape: {} \\X_test shape: {}\".format(X_train.shape, X_test.shape))\n \n# Fit a per-column scaler\nX_scaler = StandardScaler().fit(X_train)\n# Apply the scaler to X\nX_train = X_scaler.transform(X_train)\nX_test = X_scaler.transform(X_test)\n\nprint('Using:',orient,'orientations',pix_per_cell,\n 'pixels per cell and', cell_per_block,'cells per block')\nprint('Feature vector length:', len(X_train[0]))\n# Use a linear SVC \nsvc = LinearSVC()\nt=time.time()\nsvc.fit(X_train, y_train)\nt2 = time.time()\nprint(round(t2-t, 2), 'Seconds to train SVC...')\n\n# Check the score of the SVC\nprint('Test Accuracy of SVC = ', round(svc.score(X_test, y_test), 4))\n\n# pickle SVC\npickle_file = 'svc_acc_%f.p'%round(svc.score(X_test, y_test), 4)\ntry:\n with open(pickle_file, 'wb') as pfile:\n pickle.dump(\n {\n 'svc': svc,\n 'scaler': X_scaler,\n 'color_space': color_space,\n 'orient': orient,\n 'pix_per_cell': pix_per_cell,\n 'cell_per_block': cell_per_block,\n 'spatial_size': spatial_size,\n 'hist_bins': hist_bins,\n 'spatial_feat': spatial_feat,\n 'hist_feat': hist_feat,\n },\n pfile, pickle.HIGHEST_PROTOCOL)\nexcept Exception as e:\n print('Unable to save data to', pickle_file, ':', e)\n raise"
] | [
[
"sklearn.cross_validation.train_test_split",
"sklearn.svm.LinearSVC",
"sklearn.preprocessing.StandardScaler",
"numpy.vstack",
"numpy.random.randint"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
DannySalem/chemprop | [
"f99cea2c08f54640ccd8ad3851a93f47badc72dd"
] | [
"chemprop/models/FFNetwork.py"
] | [
"import torch.nn as nn\nfrom chemprop.nn_utils import get_activation_function\nfrom chemprop.args import TrainArgs\n\n\ndef create_ffn(output_size: int, input_size: int, args: TrainArgs):\n \"\"\"\n Creates the feed-forward layers for the model.\n\n :param args: A :class:`~chemprop.args.TrainArgs` object containing model arguments.\n \"\"\"\n\n first_linear_dim = args.hidden_size * args.number_of_molecules\n # need to also add other 2 network outputs\n if args.use_input_features:\n first_linear_dim += args.features_size\n\n if args.atom_descriptors == \"descriptor\":\n first_linear_dim += args.atom_descriptors_size\n\n first_linear_dim = input_size\n dropout = nn.Dropout(args.dropout)\n activation = get_activation_function(args.activation)\n\n # Create FFN layers\n if args.ffn_num_layers == 1:\n ffn = [dropout, nn.Linear(first_linear_dim, output_size)]\n else:\n ffn = [dropout, nn.Linear(first_linear_dim, args.ffn_hidden_size)]\n for _ in range(args.ffn_num_layers - 2):\n ffn.extend(\n [activation, dropout, nn.Linear(args.ffn_hidden_size, args.ffn_hidden_size),]\n )\n ffn.extend(\n [activation, dropout, nn.Linear(args.ffn_hidden_size, output_size),]\n )\n\n # return FFN model\n return nn.Sequential(*ffn)\n"
] | [
[
"torch.nn.Linear",
"torch.nn.Sequential",
"torch.nn.Dropout"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
lucasdornelles/2DBESO | [
"b92a42346ed4945a3668a3277d67ef412e200cbb"
] | [
"BESO.py"
] | [
"import numpy as np\r\nfrom FEM import get_element_dof\r\nfrom tqdm import tqdm\r\nfrom scipy.spatial.distance import pdist\r\n\r\n\r\ndef get_elements_sensibilities(local_matrix, minimum_density, elements_density,\r\n displacements, penalty, connectivity, nodes_dof):\r\n\r\n # calculate elements sensibilities\r\n\r\n sensibilities = []\r\n for i in tqdm(range(len(connectivity))):\r\n element_dof = get_element_dof(connectivity[i], nodes_dof)\r\n element_displacements = displacements[element_dof]\r\n\r\n element_sensibility = np.matmul(element_displacements,\r\n np.matmul(local_matrix[i],\r\n np.transpose(np.asmatrix(element_displacements))))\r\n if elements_density[i] == 1:\r\n sensibilities.append(element_sensibility[0, 0])\r\n\r\n else:\r\n element_sensibility[0, 0] = element_sensibility[0, 0] * (minimum_density ** (penalty - 1))\r\n sensibilities.append(element_sensibility[0, 0])\r\n\r\n return sensibilities\r\n\r\n\r\ndef get_elements_on_filtering_radius(centers, element_index, filter_radius):\r\n\r\n # identify elements index on filtering radius of element_index element\r\n\r\n element_center = centers[element_index]\r\n\r\n elements_on_filtering_radius = []\r\n for i in range(len(centers)):\r\n if (element_center[0] - filter_radius) <= centers[i][0] <= (element_center[0] + filter_radius) and \\\r\n (element_center[1] - filter_radius) <= centers[i][1] <= (element_center[1] + filter_radius) and \\\r\n pdist([centers[i], element_center]) <= filter_radius:\r\n elements_on_filtering_radius = elements_on_filtering_radius + [i]\r\n\r\n return elements_on_filtering_radius\r\n\r\n\r\ndef get_filtering_weights(centers, filter_radius, all_elements_on_filtering_radius):\r\n\r\n # calculate filtering weights for all elements\r\n\r\n filtering_weights = []\r\n for element_index in range(len(centers)):\r\n element_weights = []\r\n element_center = centers[element_index]\r\n elements_on_filtering_radius = all_elements_on_filtering_radius[element_index]\r\n for elements in elements_on_filtering_radius:\r\n center = centers[elements]\r\n weight = filter_radius - pdist([element_center, center])\r\n element_weights = element_weights + [weight]\r\n filtering_weights.append(element_weights)\r\n\r\n return filtering_weights\r\n\r\n\r\ndef filter_sensibilities(sensibilities, all_elements_on_filtering_radius, filtering_weights):\r\n\r\n # filter sensibilities using filtering weights and elements on filtering radius\r\n\r\n filtered_sensibilities = []\r\n for element_index in range(len(sensibilities)):\r\n element_sensibilitie = 0\r\n elements_on_filtering_radius = all_elements_on_filtering_radius[element_index]\r\n element_filtering_weights = filtering_weights[element_index]\r\n for index in range(len(elements_on_filtering_radius)):\r\n sensibilitie_index = elements_on_filtering_radius[index]\r\n element_sensibilitie = element_sensibilitie + element_filtering_weights[index] * sensibilities[sensibilitie_index]\r\n element_sensibilitie = element_sensibilitie / sum(element_filtering_weights)\r\n filtered_sensibilities.append(element_sensibilitie[0])\r\n\r\n return filtered_sensibilities\r\n\r\n\r\ndef average_sensibilities(last_sensibilities, filtered_sensibilities):\r\n\r\n # average sensibilities with last iteration sensibilities\r\n\r\n averaged_sensibilities = []\r\n\r\n for element_index in range(len(filtered_sensibilities)):\r\n element_sensibilitie = (last_sensibilities[element_index] + filtered_sensibilities[element_index]) / 2\r\n averaged_sensibilities.append(element_sensibilitie)\r\n\r\n return averaged_sensibilities\r\n\r\n\r\ndef update_elements_density(averaged_sensibilities, last_elements_density, minimum_area, evolutionary_rate, areas,\r\n surface_type, surface_elements):\r\n\r\n # update elements density using BESO softkill optimum criteria\r\n\r\n last_area = sum(list(np.array(last_elements_density) * np.array(areas)))\r\n new_area = max(minimum_area, last_area * (1 - evolutionary_rate))\r\n\r\n design_elements = []\r\n for i in range(len(surface_type)):\r\n if surface_type[i]:\r\n design_elements = design_elements + surface_elements[i]\r\n\r\n design_sensibilities = [averaged_sensibilities[i] for i in design_elements]\r\n\r\n low = min(design_sensibilities)\r\n high = max(design_sensibilities)\r\n residue = 10 ** (-5)\r\n new_elements_density = []\r\n while ((high - low) / high) > residue:\r\n new_elements_density = list(last_elements_density)\r\n threshold = (high + low) / 2\r\n\r\n for i in range(len(design_sensibilities)):\r\n if design_sensibilities[i] < threshold:\r\n new_elements_density[i] = 0\r\n else:\r\n new_elements_density[i] = 1\r\n\r\n area = sum(list(np.array(new_elements_density) * np.array(areas)))\r\n\r\n if area > new_area:\r\n low = threshold\r\n else:\r\n high = threshold\r\n\r\n new_area = area\r\n\r\n return new_elements_density, new_area\r\n\r\n\r\ndef get_minimum_area(areas, minimum_area_ratio):\r\n\r\n # get minimum area for optimization\r\n\r\n minimum_area = sum(areas) * minimum_area_ratio\r\n return minimum_area\r\n\r\n\r\ndef check_convergence(compliances_list, iteration):\r\n\r\n # check BESO algorithm convergence\r\n\r\n compliance_diference = (sum(compliances_list[(iteration - 5): iteration]) -\r\n sum(compliances_list[(iteration - 10): (iteration - 5)]))\r\n\r\n residue = 0.001\r\n convergence = bool(abs(compliance_diference) <= residue)\r\n\r\n return convergence, compliance_diference\r\n"
] | [
[
"numpy.asmatrix",
"numpy.array",
"scipy.spatial.distance.pdist"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [
"0.13",
"1.6",
"0.14",
"1.10",
"0.15",
"1.4",
"0.16",
"1.9",
"0.19",
"1.5",
"0.18",
"1.2",
"1.7",
"0.12",
"1.0",
"0.17",
"1.3",
"1.8"
],
"tensorflow": []
}
] |
ZJCV/PyCls | [
"1ef59301646b6134f2ffcc009b4fd76550fa4089",
"1ef59301646b6134f2ffcc009b4fd76550fa4089"
] | [
"tests/test_model/test_recognizer/test_sknet.py",
"zcls/model/layers/split_attention_conv2d.py"
] | [
"# -*- coding: utf-8 -*-\n\n\"\"\"\n@date: 2020/11/21 下午4:16\n@file: test_resnest.py\n@author: zj\n@description: \n\"\"\"\n\nimport torch\n\nfrom zcls.config import cfg\nfrom zcls.config.key_word import KEY_OUTPUT\nfrom zcls.model.recognizers.resnet.resnet import ResNet\n\n\ndef test_data(model, input_shape, output_shape):\n data = torch.randn(input_shape)\n outputs = model(data)[KEY_OUTPUT]\n print(outputs.shape)\n\n assert outputs.shape == output_shape\n\n\ndef test_sknet():\n config_file = 'configs/benchmarks/resnet-resnext/sknet50_zcls_imagenet_224.yaml'\n cfg.merge_from_file(config_file)\n\n model = ResNet(cfg)\n print(model)\n test_data(model, (3, 3, 224, 224), (3, 1000))\n\n\nif __name__ == '__main__':\n print('*' * 10 + ' sknet')\n test_sknet()\n",
"# -*- coding: utf-8 -*-\n\n\"\"\"\n@date: 2021/1/4 上午11:32\n@file: split_attention_conv2d.py\n@author: zj\n@description: \n\"\"\"\nfrom abc import ABC\n\nimport torch\n\nimport torch.nn as nn\nimport torch.nn.functional as F\n\nfrom ..init_helper import init_weights\n\n\nclass SplitAttentionConv2d(nn.Module, ABC):\n\n def __init__(self,\n in_channels,\n out_channels,\n radix=2,\n groups=1,\n reduction_rate=4,\n default_channels: int = 32,\n dimension: int = 2\n ):\n \"\"\"\n Implementation of SplitAttention in ResNetSt, refer to\n 1. https://github.com/open-mmlab/mmdetection/blob/master/mmdet/models/backbones/resnest.py\n 2. https://github.com/zhanghang1989/ResNeSt/blob/73b43ba63d1034dbf3e96b3010a8f2eb4cc3854f/resnest/torch/splat.py\n Partial reference ./selective_kernel_conv2d.py implementation\n :param in_channels:\n :param out_channels:\n :param radix:\n :param groups:\n :param reduction_rate:\n :param default_channels:\n :param dimension:\n \"\"\"\n super(SplitAttentionConv2d, self).__init__()\n\n # split\n self.split = nn.Sequential(\n nn.Conv2d(in_channels, out_channels * radix, kernel_size=3, stride=1, padding=1, bias=False,\n groups=groups * radix),\n nn.BatchNorm2d(out_channels * radix),\n nn.ReLU(inplace=True)\n )\n # self.conv1 = nn.Conv2d(in_channels, out_channels * radix, kernel_size=3, stride=1, padding=1, bias=False,\n # groups=groups * radix)\n # self.bn1 = nn.BatchNorm2d(out_channels * radix)\n # self.relu = nn.ReLU(inplace=True)\n # fuse\n self.pool = nn.AdaptiveAvgPool2d((1, 1))\n inner_channels = max(in_channels * radix // reduction_rate, 32)\n # inner_channels = max(out_channels // reduction_rate, default_channels)\n self.compact = nn.Sequential(\n nn.Conv2d(out_channels, inner_channels, kernel_size=1, stride=1, padding=0, bias=True,\n groups=groups),\n nn.BatchNorm2d(inner_channels),\n nn.ReLU(inplace=True)\n )\n # select\n self.select = nn.Conv2d(inner_channels, out_channels * radix, kernel_size=1, stride=1,\n groups=groups)\n # self.softmax = nn.Softmax(dim=0)\n self.rsoftmax = rSoftMax(radix, groups)\n self.dimension = dimension\n self.out_channels = out_channels\n self.radix = radix\n self.groups = groups\n\n init_weights(self.modules())\n\n def forward(self, x):\n N, C, H, W = x.shape[:4]\n # split\n out = self.split(x)\n # out = self.conv1(x)\n # out = self.bn1(out)\n # out = self.relu(out)\n split_out = torch.stack(torch.split(out, self.out_channels, dim=1))\n # fuse\n u = torch.sum(split_out, dim=0)\n s = self.pool(u)\n z = self.compact(s)\n # select\n c = self.select(z)\n softmax_c = self.rsoftmax(c).view(N, -1, 1, 1)\n\n attens = torch.split(softmax_c, self.out_channels, dim=1)\n v = sum([att * split for (att, split) in zip(attens, split_out)])\n return v.contiguous()\n # split_c = torch.stack(torch.split(c, self.out_channels, dim=1))\n # softmax_c = self.softmax(split_c)\n #\n # v = torch.sum(split_out.mul(softmax_c), dim=0)\n # return v.contiguous()\n\n\nclass rSoftMax(nn.Module):\n def __init__(self, radix, cardinality):\n super().__init__()\n self.radix = radix\n self.cardinality = cardinality\n\n def forward(self, x):\n batch = x.size(0)\n if self.radix > 1:\n x = x.view(batch, self.cardinality, self.radix, -1).transpose(1, 2)\n x = F.softmax(x, dim=1)\n x = x.reshape(batch, -1)\n else:\n x = torch.sigmoid(x)\n return x\n"
] | [
[
"torch.randn"
],
[
"torch.nn.functional.softmax",
"torch.sigmoid",
"torch.split",
"torch.nn.Conv2d",
"torch.sum",
"torch.nn.AdaptiveAvgPool2d",
"torch.nn.BatchNorm2d",
"torch.nn.ReLU"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.