NeuralVariable

Complexity

Total Complexity

14

Size/Duplication

Total Lines	54
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	getitem_wrapper()	0	5	2
A	__init__()	0	9	2
A	compute_test_tesnor()	0	2	1
A	compute_tensor()	0	2	1
A	apply()	0	6	2
A	shape()	0	2	1
A	dim()	0	2	1
A	__getitem__()	0	9	3
A	set_test_value()	0	2	1
A	__call__()	0	2	1
A	__getattr__()	0	2	1

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from layer import NeuralLayer
from deepy.utils.decorations import neural_computation


class NeuralVariable(NeuralLayer):
    """
    Create a constant layer with tensors.
    """

    def __init__(self, tensor, test_tensor=None, dim=0):
        """
        Create a tensor layer.
        """
        super(NeuralVariable, self).__init__("const")
        self.output_dim = dim
        self.tensor = tensor
        self.test_tensor = tensor if not test_tensor else test_tensor
        self.initialize(0)

    def __getitem__(self, index):
        @neural_computation
        def getitem_wrapper(t, index):
            if type(index) == list:
                index = tuple(index)
            return t.__getitem__(index)
        ret = getitem_wrapper(self, index)
        ret.output_dim = self.dim()
        return ret

    def __call__(self, *args, **kwargs):
        return NeuralVariable(self.tensor(*args, **kwargs), self.test_tensor(*args, **kwargs), dim=self.dim())

    def __getattr__(self, name):
        return NeuralVariable(getattr(self.tensor, name), getattr(self.test_tensor, name), dim=self.dim())



    def apply(self, func, dim=None):
        """
        Apply a function to tensors.
        """
        output_dim = dim if dim else self.output_dim
        return NeuralVariable(func(self.tensor), func(self.test_tensor), output_dim)

    def compute_tensor(self, x):
        return self.tensor

    def compute_test_tesnor(self, x):
        return self.test_tensor

    def set_test_value(self, value):
        self.tensor.tag.test_value = value

    def dim(self):
        return self.output_dim

    def shape(self, dim_index):
        return NeuralVariable(self.tensor.shape[dim_index], self.test_tensor.shape[dim_index])