mindspore 2.0.0a0__cp37-none-any.whl → 2.0.0rc1__cp37-none-any.whl

mindspore/nn/layer/rnn_utils.py

@@ -1,90 +0,0 @@
-# Copyright 2021 Huawei Technologies Co., Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ============================================================================
-"""Utils for RNNs CPU version, like Reverse operators."""
-from __future__ import absolute_import
-
-import numpy as np
-
-import mindspore.common.dtype as mstype
-import mindspore.ops as P
-from mindspore.ops.primitive import constexpr
-from mindspore.nn.cell import Cell
-from mindspore.common.tensor import Tensor
-
-
-@constexpr
-def arange(start, stop, step):
-    return Tensor(np.arange(start, stop, step), mstype.int32)
-
-
-class _Reverse(Cell):
-    """Reverse operator, like Reverse in mindspore"""
-    def __init__(self, dim):
-        super().__init__()
-        self.dim = dim
-
-    def construct(self, input_x):
-        dim_size = input_x.shape[self.dim]
-        reversed_indexes = arange(dim_size-1, -1, -1)
-        output = P.Gather()(input_x, reversed_indexes, self.dim)
-        return output
-
-
-class _ReverseSequence(Cell):
-    """Reverse sequence operator, like ReverseSequenceV2 in mindspore"""
-    def __init__(self, seq_dim, batch_dim=0):
-        super().__init__()
-        self.seq_dim = seq_dim
-        self.batch_dim = batch_dim
-
-
-    @staticmethod
-    def make_shape(shape, dtype, range_dim):
-        """Calculates the shape according by the inputs."""
-        output = P.Ones()(shape, mstype.float32)
-        output = P.CumSum()(output, range_dim)
-        output = P.Cast()(output, dtype)
-        output = output - 1
-        return output
-
-    def construct(self, x, seq_lengths):
-        """Defines the ReverseSequence operator computation performed."""
-        batch_size = x.shape[self.batch_dim]
-        max_seq_len = x.shape[self.seq_dim]
-        seq_lens_type = seq_lengths.dtype
-
-        back = P.Sub()(seq_lengths, P.OnesLike()(seq_lengths))
-
-        batch_idx = self.make_shape((batch_size, max_seq_len), seq_lens_type, 0)
-        forward_idx = self.make_shape((batch_size, max_seq_len), seq_lens_type, 1)
-
-        back = back.view(-1, 1)
-        reverse_idx = P.Sub()(back, forward_idx)
-
-        condition = P.Less()(reverse_idx, P.ZerosLike()(reverse_idx))
-        reverse_idx = P.Select()(condition, forward_idx, reverse_idx)
-
-        reverse_idx = P.ExpandDims()(reverse_idx, 2)
-        batch_idx = P.ExpandDims()(batch_idx, 2)
-
-        if self.batch_dim > self.seq_dim:
-            batch_idx = P.Transpose()(batch_idx, (1, 0, 2))
-            reverse_idx = P.Transpose()(reverse_idx, (1, 0, 2))
-            x = P.Transpose()(x, (1, 0, 2))
-        start_indices = P.Concat(2)((batch_idx, reverse_idx))
-
-        output = P.GatherNd()(x, start_indices)
-
-        return output

mindspore/nn/probability/dpn/__init__.py

@@ -1,22 +0,0 @@
-# Copyright 2020 Huawei Technologies Co., Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ============================================================================
-"""
-Deep probability network such as BNN and VAE network.
-"""
-
-from .vae import VAE, ConditionalVAE
-
-__all__ = []
-__all__.extend(vae.__all__)

mindspore/nn/probability/dpn/vae/__init__.py

@@ -1,25 +0,0 @@
-# Copyright 2020 Huawei Technologies Co., Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ============================================================================
-"""
-Variational auto-encoder (VAE).
-
-The interface of VAE, which allows to construct probablity model like DNN model.
-"""
-
-from .vae import VAE
-from .cvae import ConditionalVAE
-
-__all__ = ['VAE',
-           'ConditionalVAE']

mindspore/nn/probability/dpn/vae/cvae.py

@@ -1,140 +0,0 @@
-# Copyright 2020 Huawei Technologies Co., Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ============================================================================
-"""Conditional Variational auto-encoder (CVAE)."""
-from mindspore.ops import composite as C
-from mindspore.ops import operations as P
-from mindspore._checkparam import Validator
-from mindspore.common import dtype as mstype
-from ....cell import Cell
-from ....layer.basic import Dense, OneHot
-
-
-class ConditionalVAE(Cell):
-    r"""
-    Conditional Variational Auto-Encoder (CVAE).
-
-    The difference with VAE is that CVAE uses labels information.
-    For more details, refer to `Learning Structured Output Representation using Deep Conditional Generative Models
-    <http://papers.nips.cc/paper/5775-learning-structured-output-representation-using-deep-conditional-
-    generative-models>`_.
-
-    Note:
-        When encoder and decoder ard defined, the shape of the encoder's output tensor and decoder's input tensor
-        must be :math:`(N, hidden\_size)`.
-        The latent_size must be less than or equal to the hidden_size.
-
-    Args:
-        encoder(Cell): The Deep Neural Network (DNN) model defined as encoder.
-        decoder(Cell): The DNN model defined as decoder.
-        hidden_size(int): The size of encoder's output tensor.
-        latent_size(int): The size of the latent space.
-        num_classes(int): The number of classes.
-
-    Inputs:
-        - **input_x** (Tensor) - The shape of input tensor is :math:`(N, C, H, W)`, which is the same as the input of
-          encoder.
-
-        - **input_y** (Tensor) - The tensor of the target data, the shape is :math:`(N,)`.
-
-    Outputs:
-        - **output** (tuple) - (recon_x(Tensor), x(Tensor), mu(Tensor), std(Tensor)).
-
-    Supported Platforms:
-        ``Ascend`` ``GPU``
-    """
-
-    def __init__(self, encoder, decoder, hidden_size, latent_size, num_classes):
-        super(ConditionalVAE, self).__init__()
-        self.encoder = encoder
-        self.decoder = decoder
-        if (not isinstance(encoder, Cell)) or (not isinstance(decoder, Cell)):
-            raise TypeError('The encoder and decoder must be Cell type.')
-        self.hidden_size = Validator.check_positive_int(hidden_size)
-        self.latent_size = Validator.check_positive_int(latent_size)
-        if hidden_size < latent_size:
-            raise ValueError('The latent_size must be less than or equal to the hidden_size.')
-        self.num_classes = Validator.check_positive_int(num_classes)
-        self.normal = C.normal
-        self.exp = P.Exp()
-        self.reshape = P.Reshape()
-        self.shape = P.Shape()
-        self.concat = P.Concat(axis=1)
-        self.to_tensor = P.ScalarToTensor()
-        self.one_hot = OneHot(depth=num_classes)
-        self.dense1 = Dense(self.hidden_size, self.latent_size)
-        self.dense2 = Dense(self.hidden_size, self.latent_size)
-        self.dense3 = Dense(self.latent_size + self.num_classes, self.hidden_size)
-
-    def _encode(self, x, y):
-        en_x = self.encoder(x, y)
-        mu = self.dense1(en_x)
-        log_var = self.dense2(en_x)
-        return mu, log_var
-
-    def _decode(self, z):
-        z = self.dense3(z)
-        recon_x = self.decoder(z)
-        return recon_x
-
-    def construct(self, x, y):
-        mu, log_var = self._encode(x, y)
-        std = self.exp(0.5 * log_var)
-        z = self.normal(self.shape(mu), mu, std, seed=0)
-        y = self.one_hot(y)
-        z_c = self.concat((z, y))
-        recon_x = self._decode(z_c)
-        return recon_x, x, mu, std
-
-    def generate_sample(self, sample_y, generate_nums, shape):
-        """
-        Randomly sample from the latent space to generate samples.
-
-        Args:
-            sample_y (Tensor): Define the label of samples. Tensor of shape (generate_nums, ) and type mindspore.int32.
-            generate_nums (int): The number of samples to generate.
-            shape(tuple): The shape of sample, which must be the format of (generate_nums, C, H, W) or (-1, C, H, W).
-
-        Returns:
-            Tensor, the generated samples.
-        """
-        generate_nums = Validator.check_positive_int(generate_nums)
-        if not isinstance(shape, tuple) or len(shape) != 4 or (shape[0] != -1 and shape[0] != generate_nums):
-            raise ValueError('The shape must be (generate_nums, C, H, W) or (-1, C, H, W).')
-        sample_z = self.normal((generate_nums, self.latent_size), self.to_tensor(0.0, mstype.float32),
-                               self.to_tensor(1.0, mstype.float32), seed=0)
-        sample_y = self.one_hot(sample_y)
-        sample_c = self.concat((sample_z, sample_y))
-        sample = self._decode(sample_c)
-        sample = self.reshape(sample, shape)
-        return sample
-
-    def reconstruct_sample(self, x, y):
-        """
-        Reconstruct samples from original data.
-
-        Args:
-            x (Tensor): The input tensor to be reconstructed, the shape is (N, C, H, W).
-            y (Tensor): The label of the input tensor, the shape is (N,).
-
-        Returns:
-            Tensor, the reconstructed sample.
-        """
-        mu, log_var = self._encode(x, y)
-        std = self.exp(0.5 * log_var)
-        z = self.normal(mu.shape, mu, std, seed=0)
-        y = self.one_hot(y)
-        z_c = self.concat((z, y))
-        recon_x = self._decode(z_c)
-        return recon_x

mindspore/nn/probability/dpn/vae/vae.py

@@ -1,124 +0,0 @@
-# Copyright 2020 Huawei Technologies Co., Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ============================================================================
-"""Variational auto-encoder (VAE)"""
-from mindspore.ops import composite as C
-from mindspore.ops import operations as P
-from mindspore.common import dtype as mstype
-from mindspore._checkparam import Validator
-from ....cell import Cell
-from ....layer.basic import Dense
-
-
-class VAE(Cell):
-    r"""
-    Variational Auto-Encoder (VAE).
-
-    The VAE defines a generative model, `Z` is sampled from the prior, then used to reconstruct `X` by a decoder.
-    For more details, refer to `Auto-Encoding Variational Bayes <https://arxiv.org/abs/1312.6114>`_.
-
-    Note:
-        When the encoder and decoder are defined, the shape of the encoder's output tensor and decoder's input tensor
-        must be :math:`(N, hidden\_size)`.
-        The latent_size must be less than or equal to the hidden_size.
-
-    Args:
-        encoder(Cell): The Deep Neural Network (DNN) model defined as encoder.
-        decoder(Cell): The DNN model defined as decoder.
-        hidden_size(int): The size of encoder's output tensor.
-        latent_size(int): The size of the latent space.
-
-    Inputs:
-        - **input** (Tensor) - The shape of input tensor is :math:`(N, C, H, W)`, which is the same as the input of
-          encoder.
-
-    Outputs:
-        - **output** (Tuple) - (recon_x(Tensor), x(Tensor), mu(Tensor), std(Tensor)).
-
-    Supported Platforms:
-        ``Ascend`` ``GPU``
-    """
-
-    def __init__(self, encoder, decoder, hidden_size, latent_size):
-        super(VAE, self).__init__()
-        self.encoder = encoder
-        self.decoder = decoder
-        if (not isinstance(encoder, Cell)) or (not isinstance(decoder, Cell)):
-            raise TypeError('The encoder and decoder must be Cell type.')
-        self.hidden_size = Validator.check_positive_int(hidden_size)
-        self.latent_size = Validator.check_positive_int(latent_size)
-        if hidden_size < latent_size:
-            raise ValueError('The latent_size must be less than or equal to the hidden_size.')
-        self.normal = C.normal
-        self.exp = P.Exp()
-        self.reshape = P.Reshape()
-        self.shape = P.Shape()
-        self.to_tensor = P.ScalarToTensor()
-        self.dense1 = Dense(self.hidden_size, self.latent_size)
-        self.dense2 = Dense(self.hidden_size, self.latent_size)
-        self.dense3 = Dense(self.latent_size, self.hidden_size)
-
-    def _encode(self, x):
-        en_x = self.encoder(x)
-        mu = self.dense1(en_x)
-        log_var = self.dense2(en_x)
-        return mu, log_var
-
-    def _decode(self, z):
-        z = self.dense3(z)
-        recon_x = self.decoder(z)
-        return recon_x
-
-    def construct(self, x):
-        mu, log_var = self._encode(x)
-        std = self.exp(0.5 * log_var)
-        z = self.normal(self.shape(mu), mu, std, seed=0)
-        recon_x = self._decode(z)
-        return recon_x, x, mu, std
-
-    def generate_sample(self, generate_nums, shape):
-        """
-        Randomly sample from latent space to generate samples.
-
-        Args:
-            generate_nums (int): The number of samples to generate.
-            shape(tuple): The shape of sample, it must be (generate_nums, C, H, W) or (-1, C, H, W).
-
-        Returns:
-            Tensor, the generated samples.
-        """
-        generate_nums = Validator.check_positive_int(generate_nums)
-        if not isinstance(shape, tuple) or len(shape) != 4 or (shape[0] != -1 and shape[0] != generate_nums):
-            raise ValueError('The shape must be (generate_nums, C, H, W) or (-1, C, H, W).')
-        sample_z = self.normal((generate_nums, self.latent_size), self.to_tensor(0.0, mstype.float32),
-                               self.to_tensor(1.0, mstype.float32), seed=0)
-        sample = self._decode(sample_z)
-        sample = self.reshape(sample, shape)
-        return sample
-
-    def reconstruct_sample(self, x):
-        """
-        Reconstruct samples from original data.
-
-        Args:
-            x (Tensor): The input tensor to be reconstructed, the shape is (N, C, H, W).
-
-        Returns:
-            Tensor, the reconstructed sample.
-        """
-        mu, log_var = self._encode(x)
-        std = self.exp(0.5 * log_var)
-        z = self.normal(mu.shape, mu, std, seed=0)
-        recon_x = self._decode(z)
-        return recon_x

mindspore/nn/probability/infer/__init__.py

@@ -1,22 +0,0 @@
-# Copyright 2020 Huawei Technologies Co., Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ============================================================================
-"""
-Inference algorithms in Probabilistic Programming.
-"""
-
-from .variational import SVI, ELBO
-
-__all__ = []
-__all__.extend(variational.__all__)

mindspore/nn/probability/infer/variational/elbo.py

@@ -1,70 +0,0 @@
-# Copyright 2020 Huawei Technologies Co., Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ============================================================================
-"""The Evidence Lower Bound (ELBO)."""
-from mindspore.ops import operations as P
-from ...distribution.normal import Normal
-from ....cell import Cell
-from ....loss.loss import MSELoss
-
-
-class ELBO(Cell):
-    r"""
-    The Evidence Lower Bound (ELBO).
-
-    Variational inference minimizes the Kullback-Leibler (KL) divergence from the variational distribution to
-    the posterior distribution. It maximizes the ELBO, a lower bound on the logarithm of
-    the marginal probability of the observations log p(x). The ELBO is equal to the negative KL divergence up to
-    an additive constant.
-    For more details, refer to `Variational Inference: A Review for Statisticians <https://arxiv.org/abs/1601.00670>`_.
-
-    Args:
-        latent_prior(str): The prior distribution of latent space. Default: Normal.
-
-            - Normal: The prior distribution of latent space is Normal.
-
-        output_prior(str): The distribution of output data. Default: Normal.
-
-            - Normal: If the distribution of output data is Normal, the reconstruct loss is MSELoss.
-
-    Inputs:
-        - **input_data** (Tuple) - (recon_x(Tensor), x(Tensor), mu(Tensor), std(Tensor)).
-        - **target_data** (Tensor) - the target tensor of shape :math:`(N,)`.
-
-    Outputs:
-        Tensor, loss float tensor.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU``
-    """
-
-    def __init__(self, latent_prior='Normal', output_prior='Normal'):
-        super(ELBO, self).__init__()
-        self.sum = P.ReduceSum()
-        self.zeros = P.ZerosLike()
-        if latent_prior == 'Normal':
-            self.posterior = Normal()
-        else:
-            raise ValueError('The values of latent_prior now only support Normal')
-        if output_prior == 'Normal':
-            self.recon_loss = MSELoss(reduction='sum')
-        else:
-            raise ValueError('The values of output_dis now only support Normal')
-
-    def construct(self, data, label):
-        recon_x, x, mu, std = data
-        reconstruct_loss = self.recon_loss(x, recon_x)
-        kl_loss = self.posterior('kl_loss', 'Normal', self.zeros(mu), self.zeros(mu)+1, mu, std)
-        elbo = reconstruct_loss + self.sum(kl_loss)
-        return elbo

mindspore/nn/probability/infer/variational/svi.py

@@ -1,84 +0,0 @@
-# Copyright 2020 Huawei Technologies Co., Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ============================================================================
-"""Stochastic Variational Inference(SVI)."""
-import mindspore.common.dtype as mstype
-from mindspore.common.tensor import Tensor
-from mindspore._checkparam import Validator
-from ....cell import Cell
-from ....wrap.cell_wrapper import TrainOneStepCell
-from .elbo import ELBO
-
-
-class SVI:
-    r"""
-    Stochastic Variational Inference(SVI).
-
-    Variational inference casts the inference problem as an optimization. Some distributions over the hidden
-    variables are indexed by a set of free parameters, which are optimized to make distributions closest to
-    the posterior of interest.
-    For more details, refer to `Variational Inference: A Review for Statisticians <https://arxiv.org/abs/1601.00670>`_.
-
-    Args:
-        net_with_loss(Cell): Cell with loss function.
-        optimizer (Cell): Optimizer for updating the weights.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU``
-
-    """
-
-    def __init__(self, net_with_loss, optimizer):
-        self.net_with_loss = net_with_loss
-        self.loss_fn = getattr(net_with_loss, '_loss_fn')
-        if not isinstance(self.loss_fn, ELBO):
-            raise TypeError('The loss function for variational inference must be ELBO.')
-        self.optimizer = optimizer
-        if not isinstance(optimizer, Cell):
-            raise TypeError('The optimizer must be Cell type.')
-        self._loss = 0.0
-
-    def run(self, train_dataset, epochs=10):
-        """
-        Optimize the parameters by training the probability network, and return the trained network.
-
-        Args:
-            train_dataset (Dataset): A training dataset iterator.
-            epochs (int): Total number of iterations on the data. Default: 10.
-
-        Returns:
-            Cell, the trained probability network.
-        """
-        epochs = Validator.check_positive_int(epochs)
-        train_net = TrainOneStepCell(self.net_with_loss, self.optimizer)
-        train_net.set_train()
-        for _ in range(1, epochs+1):
-            train_loss = 0
-            dataset_size = 0
-            for data in train_dataset.create_dict_iterator(num_epochs=1):
-                x = Tensor(data['image'], dtype=mstype.float32)
-                y = Tensor(data['label'], dtype=mstype.int32)
-                dataset_size += len(x)
-                loss = train_net(x, y).asnumpy()
-                train_loss += loss
-            self._loss = train_loss / dataset_size
-        model = self.net_with_loss.backbone_network
-        return model
-
-    def get_train_loss(self):
-        """
-        Returns:
-            numpy.dtype, the loss after training.
-        """
-        return self._loss

mindspore/nn/probability/toolbox/__init__.py

@@ -1,22 +0,0 @@
-# Copyright 2020 Huawei Technologies Co., Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ============================================================================
-"""
-Uncertainty toolbox.
-"""
-
-from .uncertainty_evaluation import UncertaintyEvaluation
-from .anomaly_detection import VAEAnomalyDetection
-
-__all__ = ['UncertaintyEvaluation', 'VAEAnomalyDetection']