TensorArray 0.0.1a0__py3-none-any.whl

TensorArray-0.0.1a0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 TensorArray-Creators
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

TensorArray-0.0.1a0.dist-info/METADATA

@@ -0,0 +1,19 @@
+Metadata-Version: 2.1
+Name: TensorArray
+Version: 0.0.1a0
+Summary: A machine learning package
+Author-email: TensorArray-Creators <noob_taken@outlook.com>
+Project-URL: Homepage, https://github.com/BigNoobWasTaken/TensorArray-Python
+Project-URL: Issues, https://github.com/BigNoobWasTaken/TensorArray-Python/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Environment :: GPU :: NVIDIA CUDA :: 12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# Tensor-Array-Python
+This machine learning library using [Tensor-Array](https://github.com/Tensor-Array/Tensor-Array) library
+
+This project is still in alpha version, we are trying to make this look like the main framework but it is easier to code.

TensorArray-0.0.1a0.dist-info/RECORD

@@ -0,0 +1,20 @@
+tensor_array/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tensor_array/activation.py,sha256=zqscUcoAqoZsiRN8mOLjOAyaKnroFgTQdxuxYFXBN7s,322
+tensor_array/core/__init__.py,sha256=Wz1zYL75GTyBCbFKFvjNjDVdh6E4npstHClPXrEeCas,136
+tensor_array/layers/__init__.py,sha256=WqKCNIfpWt0vKgPibGs_hLOsog2BXsqkZCKpiEcJz14,57
+tensor_array/layers/layer.py,sha256=NBuZPdaIaui4ZBYxy_f2L5mPcsdiO8KqFQcS-BWTFE8,6422
+tensor_array/layers/parameter.py,sha256=13pYvLl0IMVIoVolYiPDpN-KB37fzy_U7FibRyvrryA,72
+tensor_array/layers/attention/__init__.py,sha256=GhIlCdr64wafd1hTNAVAwcirXNTFiin0yyC_0Muh6M4,70
+tensor_array/layers/attention/attention.py,sha256=d8u1tTrCHEffjnwxGgm9gq16JTIaond40SR_Pa6v5v0,1598
+tensor_array/layers/attention/transformer.py,sha256=uzuPk4uOWL-kwDHMjIanuA3oopfXyNmMnDRQohQAQjg,838
+tensor_array/layers/normalization/__init__.py,sha256=WygUO1GTeW1UOeZ0vNLNaFZrtcEVlHVADDOnr4a0wRo,59
+tensor_array/layers/normalization/normalization.py,sha256=t4cwoPEXEgqXfQOp5ZkKjb-jPBJ59dwVYBapdcYX4X8,58
+tensor_array/layers/util/__init__.py,sha256=yTbs7IqBcvTT6DwB7FqAixCzOgWGqmkvk4l64Qgs5-c,169
+tensor_array/layers/util/activation.py,sha256=7P2ydio6aiXeh5ygBNowERH_pzfONQQuHfpG92xb3d4,337
+tensor_array/layers/util/linear.py,sha256=zCktqHCRz7gr8EIHA5qWg--moMCloZvVWkDC5zZUNnY,573
+tensor_array/layers/util/sequential.py,sha256=ZR7DieysFh-ot12Oxi2S4GePscO7o75uRSHQ6ZzALhc,490
+TensorArray-0.0.1a0.dist-info/LICENSE,sha256=dwa4jJce6OUzSE8wx_T1u7gJHRszgJnb5pBLrz__xkk,1077
+TensorArray-0.0.1a0.dist-info/METADATA,sha256=UOQRCykxNcF7vCMvm6wHpyOTJtrSzMtJO0xbGFaRJ2Y,843
+TensorArray-0.0.1a0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+TensorArray-0.0.1a0.dist-info/top_level.txt,sha256=o65g4Z8Rpjh8WDCwgtBA-2oGlqc-gC6J_I2jL5bBLdE,13
+TensorArray-0.0.1a0.dist-info/RECORD,,

TensorArray-0.0.1a0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.42.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

TensorArray-0.0.1a0.dist-info/top_level.txt

@@ -0,0 +1 @@
+tensor_array

tensor_array/activation.py

@@ -0,0 +1,12 @@
+from tensor_array.core import Tensor
+from tensor_array.core import zeros
+
+def relu(input):
+    tensor_zeros = zeros(shape = input.shape(), dtype = input.dtype())
+    return (input > tensor_zeros).condition(input, tensor_zeros)
+
+def sigmoid(input):
+    return input.sigmoid()
+
+def softmax(input, dim = 0):
+    return input

tensor_array/core/__init__.py

@@ -0,0 +1,3 @@
+from tensor_array.core.tensor2 import Tensor
+from tensor_array.core.tensor2 import zeros
+from tensor_array.core.tensor2 import DataType

tensor_array/layers/__init__.py

@@ -0,0 +1,2 @@
+from .layer import Layer
+from .parameter import Parameter

tensor_array/layers/attention/__init__.py

@@ -0,0 +1 @@
+from tensor_array.layers.attention.attention import MultiheadAttention

tensor_array/layers/attention/attention.py

@@ -0,0 +1,34 @@
+from typing import Any
+from .. import Layer
+from ..util import Linear
+from tensor_array.core import Tensor
+from tensor_array.activation import softmax
+
+def scaled_dot_product_attention(q, k, v, mask = None):
+    attn_scores = q @ k.transpose(len(k.shape()) - 2, len(k.shape()) - 1)
+    attn_probs = softmax(attn_scores, len(attn_scores.shape()) - 1)
+    return attn_probs @ v
+
+class MultiheadAttention(Layer):
+    def __init__(self, d_model, n_head) -> None:
+        super().__init__()
+        self.linear_q = Linear(d_model)
+        self.linear_k = Linear(d_model)
+        self.linear_v = Linear(d_model)
+        self.linear_o = Linear(d_model)
+        self.n_head = n_head
+
+    def calculate(self, input_q, input_k, input_v, mask = None) -> Any:
+        temp_q = self.linear_q(input_q)
+        temp_k = self.linear_k(input_k)
+        temp_v = self.linear_v(input_v)
+
+        temp_q = temp_q.reshape((temp_q.shape()[0], temp_q.shape()[1], self.n_head, temp_q.shape()[-1] / self.n_head)).transpose(1, 2)
+        temp_k = temp_k.reshape((temp_k.shape()[0], temp_k.shape()[1], self.n_head, temp_k.shape()[-1] / self.n_head)).transpose(1, 2)
+        temp_v = temp_v.reshape((temp_v.shape()[0], temp_v.shape()[1], self.n_head, temp_v.shape()[-1] / self.n_head)).transpose(1, 2)
+
+        attention_output = scaled_dot_product_attention(temp_q, temp_k, temp_v, mask)
+
+        attention_output = attention_output.transpose(1, 2)
+        attention_output = attention_output.reshape((temp_q.shape()[0], temp_q.shape()[1], temp_q.shape[-2] * temp_q.shape[-1]))
+        return self.linear_o(attention_output)

tensor_array/layers/attention/transformer.py

@@ -0,0 +1,24 @@
+from typing import Any
+from .. import Layer
+from .attention import MultiheadAttention
+from tensor_array.activation import relu
+from ..util import Sequential
+from ..util import Linear
+from ..util import Activation
+
+class TransformerEncoderImpl(Layer):
+    def __init__(self, d_model, n_head, ff_size) -> None:
+        self.feed_forward = Sequential([
+            Linear(ff_size),
+            Activation(relu),
+            Linear(d_model)
+        ])
+        self.multihead_attn = MultiheadAttention(d_model, n_head)
+        self.layer_norm_1
+        self.layer_norm_2
+
+    def calculate(self, input) -> Any:
+        attn_output = self.multihead_attn(input, input, input)
+        attn_output = self.layer_norm_1(input + attn_output)
+        ff_output = self.feed_forward(attn_output)
+        return self.layer_norm_2(attn_output + ff_output)

tensor_array/layers/layer.py

@@ -0,0 +1,142 @@
+from collections import OrderedDict, namedtuple
+from typing import Union, Tuple, Any, Callable, Iterator, Set, Optional, overload, TypeVar, Mapping, Dict, List
+from typing import Any
+from tensor_array.core import Tensor
+from .parameter import Parameter
+
+class Layer:
+    """
+    Layer class
+    """
+    is_running: bool
+    _layers: Dict[str, Optional['Layer']]
+    _parameters: Dict[str, Optional[Parameter]]
+    _tensors: Dict[str, Optional[Tensor]]
+
+    def __init__(self) -> None:
+        super().__setattr__('is_running', False)
+        super().__setattr__('_layers', OrderedDict())
+        super().__setattr__('_parameters', OrderedDict())
+        super().__setattr__('_tensors', OrderedDict())
+
+    def __call__(self, *args: Any, **kwds: Any) -> Any:
+        if not self.__dict__['is_running']:
+            list_arg = (t.shape() for t in args if isinstance(t, Tensor))
+            dict_kwargs = {
+                key: val.shape()
+                for key, val in kwds
+                if isinstance(val, Tensor)
+            }
+            self.layer_init(*list_arg, **dict_kwargs)
+        super().__setattr__('is_running', True)
+        return self.calculate(*args, **kwds)
+
+    def layer_init(self, *args: Tuple, **kwds: Tuple) -> None:
+        pass
+
+    def calculate(self, *args: Any, **kwds: Any) -> Any:
+        pass
+
+    def register_parameter(self, name: str, param: Optional[Parameter]) -> None:
+        if '_parameters' not in self.__dict__:
+            raise AttributeError("cannot assign parameter before Module.__init__() call")
+        elif not isinstance(name, str):
+            raise TypeError(f"parameter name should be a string. Got {name}")
+        elif '.' in name:
+            raise KeyError("parameter name can't contain \".\"")
+        elif name == '':
+            raise KeyError("parameter name can't be empty string \"\"")
+        elif hasattr(self, name) and name not in self._parameters:
+            raise KeyError(f"attribute '{name}' already exists")
+        elif not isinstance(param, Parameter) and param is not None:
+            raise TypeError(f"cannot assign '{param}' object to parameter '{name}' "
+                            "(tensor_array.util.Parameter or None required)")
+        else:
+            self._parameters[name] = param
+
+    def register_tensor(self, name: str, param: Optional[Tensor]) -> None:
+        if '_tensors' not in self.__dict__:
+            raise AttributeError("cannot assign tensor before Module.__init__() call")
+        elif not isinstance(name, str):
+            raise TypeError(f"tensor name should be a string. Got {name}")
+        elif '.' in name:
+            raise KeyError("tensor name can't contain \".\"")
+        elif name == '':
+            raise KeyError("tensor name can't be empty string \"\"")
+        elif hasattr(self, name) and name not in self._tensors:
+            raise KeyError(f"attribute '{name}' already exists")
+        elif not isinstance(param, Tensor) and param is not None:
+            raise TypeError(f"cannot assign '{param}' object to parameter '{name}' "
+                            "(tensor_array.core.tensor2.Tensor or None required)")
+        else:
+            self._tensors[name] = param
+
+    def register_layer(self, name: str, layer: Optional['Layer']) -> None:
+        if not isinstance(layer, Layer) and layer is not None:
+            raise TypeError(f"{layer} is not a Layer subclass")
+        elif not isinstance(name, str):
+            raise TypeError(f"layer name should be a string. Got {name}")
+        elif hasattr(self, name) and name not in self._layers:
+            raise KeyError(f"attribute '{name}' already exists")
+        elif '.' in name:
+            raise KeyError(f"layer name can't contain \".\", got: {name}")
+        elif name == '':
+            raise KeyError("layer name can't be empty string \"\"")
+        self._layers[name] = layer
+
+    def __setattr__(self, __name: str, __value: Any) -> None:
+        def remove_from(*dicts_or_sets):
+            for d in dicts_or_sets:
+                if __name in d:
+                    if isinstance(d, dict):
+                        del d[__name]
+                    else:
+                        d.discard(__name)
+        
+        params = self.__dict__.get('_parameters')
+        layers = self.__dict__.get('_layers')
+        tensors = self.__dict__.get('_tensors')
+        if (params is not None and __name in params) or (layers is not None and __name in layers) or (tensors is not None and __name in tensors):
+            raise TypeError(f"cannot assign '{__value}' as parameter '{__name}'")
+        elif isinstance(__value, Parameter):
+            if params is None:
+                raise AttributeError("cannot assign parameters before Layer.__init__() call")
+            remove_from(self.__dict__, self._layers, self._tensors)
+            self.register_parameter(__name, __value)
+        elif isinstance(__value, Tensor):
+            if layers is None:
+                raise AttributeError("cannot assign layers before Layer.__init__() call")
+            remove_from(self.__dict__, self._parameters, self._layers)
+            self.register_tensor(__name, __value)
+        elif isinstance(__value, Layer):
+            if tensors is None:
+                raise AttributeError("cannot assign layers before Layer.__init__() call")
+            remove_from(self.__dict__, self._parameters, self._tensors)
+            self.register_layer(__name, __value)
+        else:
+            super().__setattr__(__name, __value)
+    
+    def __getattr__(self, __name: str) -> Any:
+        if '_parameters' in self.__dict__:
+            _parameters = self.__dict__['_parameters']
+            if __name in _parameters:
+                return _parameters[__name]
+        if '_tensors' in self.__dict__:
+            _tensors = self.__dict__['_tensors']
+            if __name in _tensors:
+                return _tensors[__name]
+        if '_layers' in self.__dict__:
+            _layers = self.__dict__['_layers']
+            if __name in _layers:
+                return _layers[__name]
+        return super().__getattr__(__name)
+
+    def __delattr__(self, __name: str) -> None:
+        if __name in self._parameters:
+            del self._parameters[__name]
+        elif __name in self._tensors:
+            del self._tensors[__name]
+        elif __name in self._layers:
+            del self._layers[__name]
+        else:
+            super().__delattr__(__name)

tensor_array/layers/normalization/__init__.py

@@ -0,0 +1 @@
+from tensor_array.layers.normalization import Normalization

tensor_array/layers/normalization/normalization.py

@@ -0,0 +1,4 @@
+from .. import Layer
+
+class Normalization(Layer):
+    pass

tensor_array/layers/parameter.py

@@ -0,0 +1,4 @@
+from tensor_array.core import Tensor
+
+class Parameter(Tensor):
+    pass

tensor_array/layers/util/__init__.py

@@ -0,0 +1,3 @@
+from tensor_array.layers.util.activation import Activation
+from tensor_array.layers.util.linear import Linear
+from tensor_array.layers.util.sequential import Sequential

tensor_array/layers/util/activation.py

@@ -0,0 +1,10 @@
+from .. import Layer
+from typing import Any, Callable
+
+class Activation(Layer):
+    def __init__(self, activation_function: Callable) -> None:
+        super().__init__()
+        self.activation_function = activation_function
+
+    def calculate(self, *args: Any, **kwds: Any) -> Any:
+        return self.activation_function(*args, **kwds)

tensor_array/layers/util/linear.py

@@ -0,0 +1,20 @@
+from .. import Layer
+from .. import Parameter
+from tensor_array.core import Tensor
+from tensor_array.core import zeros
+from tensor_array.core import DataType
+from typing import Any
+
+
+class Linear(Layer):
+    def __init__(self, bias) -> None:
+        super().__init__()
+        self.bias_shape = bias
+        self.b = Parameter(zeros(shape = (bias,), dtype = DataType.FLOAT))
+
+    def layer_init(self, t):
+        self.w = Parameter(zeros(shape = (t[-1], self.bias_shape), dtype = DataType.FLOAT))
+    
+    def calculate(self, t):
+        return t @ self.w + self.b
+        

tensor_array/layers/util/sequential.py

@@ -0,0 +1,17 @@
+from .. import Layer
+from .. import Parameter
+from tensor_array.core import Tensor
+from tensor_array.core import zeros
+from tensor_array.core import DataType
+from typing import Any, List, OrderedDict
+
+
+class Sequential(Layer):
+    def __init__(self, _layers: OrderedDict[str, Layer]) -> None:
+        self._layers = _layers
+    
+    def calculate(self, t):
+        tensorloop = t
+        for _, content in self._layers:
+            tensorloop = content(tensorloop)
+        return tensorloop