nodev 1.0.0__py3-none-any.whl

nodev/__init__.py

@@ -0,0 +1,18 @@
+from nodev.core import Datafield
+from nodev.core import Operation
+from nodev.core import using_config
+from nodev.core import no_grad
+from nodev.core import as_array
+from nodev.core import as_datafield
+from nodev.core import setup_datafield
+from nodev import operations,operations_conv
+from nodev.core import Formpara
+from nodev.layers import Layer
+from nodev.layers import Linear
+from nodev.model import Model
+from nodev.dataloaders import Dataloader
+from nodev.core import test_mode
+from nodev.core import Config
+from nodev import cuda
+from nodev import dataset
+setup_datafield()

nodev/core.py

@@ -0,0 +1,297 @@
+
+
+import numpy as np
+import weakref
+from contextlib import contextmanager
+
+import nodev
+
+try:
+    import cupy
+    array_types=(np.ndarray,cupy.ndarray)
+except ImportError:
+    array_types=(np.ndarray)
+class Config:
+    enable_backprop=True
+    train=True
+
+class Datafield:
+    __array_priority__=200
+    def __init__(self,data,name=None):
+        if data is not None:
+            if not isinstance(data, np.ndarray): #是判断 “x 是否属于类型 T”
+                raise  TypeError('{} is not supported'.format(type(data)))
+        self.data=data
+        self.grad=None
+        self.name=name
+        self.creator=None
+        self.generation=0
+    def __sub__(self,other):
+        return sub(self,other)
+    def __neg__(self):
+        return neg(self)
+    def __mul__(self,other):
+        return mul(self,other)
+    def __repr__(self):
+        if self.data is None:
+            return 'Datafield(None)'
+        p=str(self.data).replace('\n','\n'+' '*9)
+        return 'Datafield(' + p +')'
+    def __truediv__(self, other):
+        return div(self,other)
+    def __rtruediv__(self, other):
+        return rdiv(self,other)
+    def __len__(self):  return len(self.data)
+    def __add__(self,other):
+        return add(self,other)
+    def __rmul__(self,other):
+        return mul(other,self)
+
+    def __radd__(self,other):
+        return add(other, self)
+    def __pow__(self, power, modulo=None):
+        return pow(self,power)
+    def __getitem__(self, slices):
+        return nodev.operations.get_item(self, slices)
+
+    def max(self, axis=None, keepdims=False):
+        """返回最大值"""
+        return nodev.operations.max(self, axis, keepdims)
+
+    def min(self, axis=None, keepdims=False):
+        """返回最小值"""
+        return nodev.operations.min(self, axis, keepdims)
+    def reshape(self,*shape):
+        if len(shape)==1 and isinstance(shape[0],(tuple,list)):
+            shape=shape[0]
+        return nodev.operations.reshape(self,shape)
+    def transpose(self):
+        return  nodev.operations.transpose(self)
+    @property
+    def T(self):
+        return nodev.operations.transpose(self)
+    @property
+    def size(self):
+        return self.data.size
+    def unchain(self):
+        self.creator=None
+    @property
+    def ndim(self):
+        return self.data.ndim
+    @property
+    def shape(self):  #取出shape
+        return self.data.shape
+    @property
+    def dtype(self):
+        return self.data.dtype
+    def clear_grad(self):
+        self.grad=None
+    def to_cpu(self):
+        if self.data is not None:
+            self.data=nodev.cuda.as_numpy(self.data)
+    def to_gpu(self):
+        if self.data is not None:
+            self.data=nodev.cuda.as_cupy(self.data)
+    def set_creator(self,func):
+        self.creator=func  #储存当前节点的上一个节点？？
+        self.generation=func.generation+1
+
+    def sum(self, axis=None, keepdims=False):
+        return nodev.operations.sum(self, axis, keepdims)
+    def backward(self, retain_grad=False, create_graph=False):
+        if self.grad is None:
+            xp=nodev.cuda.get_array_module(self.data)
+            self.grad=Datafield(xp.ones_like(self.data)) #创建一个全 1 张量，形状和 data 一样
+            #self.grad=Datafield(np.ones_like(self.data))
+        funcs=[]
+        seen_set=set()
+        def add_func(f):   #寻找层数最大的因子进行求导
+            if f not in seen_set:
+                funcs.append(f)
+                seen_set.add(f)
+                funcs.sort(key=lambda  x:x.generation)
+        if self.creator is not None:
+            add_func(self.creator)
+        while funcs:
+            f=funcs.pop()  #压出最后一个元素
+            gys=[output().grad for output in f.outputs] #汇总导数
+            #gys = [output.grad for output in f.outputs]  # 汇总导数
+            with using_config('enable_backprop',create_graph):
+                gxs=f.backward(*gys)
+                if not isinstance(gxs,tuple):
+                    gxs=(gxs,)
+                for x,gx in zip(f.inputs,gxs):
+                    if x.grad is None:
+                        x.grad=gx
+                    else:
+                        x.grad=x.grad+gx
+                    if x.creator is not None:
+                        #funcs.append(x.creator)
+                        add_func(x.creator)
+    def unchain_backward(self):
+        if self.creator is not None:
+            funcs=[self.creator]
+            while funcs:
+                f=funcs.pop()
+                for x in f.inputs:
+                    if x.creator is not None:
+                        x.unchain()
+class Operation:
+    def __call__(self,*inputs):
+        inputs=[as_datafield(x) for x in inputs]
+        xs=[i.data for i in inputs]
+        ys=self.forward(*xs)
+        if not isinstance(ys,tuple):
+            ys=(ys,)
+        outputs=[Datafield(as_array(y)) for y in ys]
+        if Config.enable_backprop:
+            self.generation=max([x.generation for x in inputs])
+            for output in outputs:
+                output.set_creator(self)
+        self.inputs = inputs
+        self.outputs=[weakref.ref(output) for output in outputs]
+        return outputs if len(outputs)>1 else outputs[0]
+    def forward(self,*xs):
+        raise NotImplementedError()
+    def backward(self,*xs):
+        raise NotImplementedError()
+
+
+class Pow(Operation):
+    def __init__(self,c):
+        self.c=c
+    def forward(self,x):
+        y=x**self.c
+        return y
+    def backward(self,gy):
+        x, = self.inputs
+        c=self.c
+        gx=c*x**(c-1)*gy
+        return gx
+class Div(Operation):
+    def forward(self,x0,x1):
+        self.x0_shape, self.x1_shape = x0.shape, x1.shape
+        y=x0/x1
+        return y
+    def backward(self,gy):
+        x0,x1=self.inputs
+
+        gx0=gy/x1
+        gx1=gy*(-x0/x1**2)
+        if self.x0_shape!=self.x1_shape:
+            gx0=nodev.operations.sum_to(gx0,self.x0_shape)
+            gx1 = nodev.operations.sum_to(gx1, self.x1_shape)
+        return gx0,gx1
+
+
+class Add(Operation):
+    def forward(self,x0,x1):
+        self.x0_shape,self.x1_shape=x0.shape,x1.shape
+        y=x0+x1
+        return y
+    def backward(self,gy):
+        gx0,gx1=gy,gy
+        if self.x0_shape!=self.x1_shape:
+            gx0=nodev.operations.sum_to(gx0,self.x0_shape)
+            gx1 = nodev.operations.sum_to(gx1, self.x1_shape)
+        return gx0,gx1
+
+class Neg(Operation):
+    def forward(self,x):
+        return -x
+    def backward(self,gy):
+        return -gy
+class Mul(Operation):
+    def forward(self,x0,x1):
+        self.x0_shape, self.x1_shape = x0.shape, x1.shape
+        y=x0*x1
+        return  y
+    def backward(self,gy):
+        x0,x1=self.inputs
+        gx0,gx1=x1*gy,x0*gy
+        if  self.x0_shape!=self.x1_shape:
+            gx0=nodev.operations.sum_to(gx0,self.x0_shape)
+            gx1 = nodev.operations.sum_to(gx1, self.x1_shape)
+        return  gx0,gx1
+class Sub(Operation):
+    def forward(self,x0,x1):
+        self.x0_shape, self.x1_shape = x0.shape, x1.shape
+        y=x0-x1
+        return y
+    def backward(self,gy):
+        gx0,gx1=gy,-gy
+        if  self.x0_shape!=self.x1_shape:
+            gx0=nodev.operations.sum_to(gx0,self.x0_shape)
+            gx1 = nodev.operations.sum_to(gx1, self.x1_shape)
+        return gx0,gx1
+
+class Formpara(Datafield):
+    pass
+
+
+
+
+@contextmanager
+def test_mode():
+    old_value = Config.train
+    Config.train = False
+    try:
+        yield
+    finally:
+        Config.train = old_value
+
+@contextmanager
+def using_config(name,value):
+    old_value=getattr(Config,name)
+    setattr(Config,name,value)
+    try:
+        yield
+    finally:
+        setattr(Config,name,old_value)
+def as_datafield(obj): #转换普通数据为variable
+    if isinstance(obj, Datafield):
+        return obj
+    return Datafield(as_array(obj))
+def div(x0,x1):
+    x1 = as_array(x1, nodev.cuda.get_array_module(x0.data))
+    return Div()(x0,x1)
+def rdiv(x0,x1):
+    x1 = as_array(x1, nodev.cuda.get_array_module(x0.data))
+    return Div()(x1,x0)
+def sub(x1,x2):
+    return Sub()(x1,x2)
+
+def as_array(x,array_module=np):
+    """    if x is None:   # ⭐必须加
+        return None"""
+    if np.isscalar(x):
+        return  array_module.array(x)
+    return x
+def pow(x,c):
+    return Pow(c)(x)
+
+def add(x0,x1):
+    x1=as_array(x1,nodev.cuda.get_array_module(x0.data))
+    return  Add()(x0,x1)
+def mul(x0,x1):
+    x1 = as_array(x1, nodev.cuda.get_array_module(x0.data))
+    return Mul()(x0,x1)
+def neg(x):
+    return Neg()(x)
+def rsub(x0,x1):
+    x1=as_array(x1)
+    return Sub()(x1,x0)
+def no_grad():
+    return using_config('enable_backprop',False)
+
+def setup_datafield():
+    Datafield.__mul__ = mul
+    Datafield.__add__ = add
+    Datafield.__rmul__ = mul
+    Datafield.__radd__ = add
+    Datafield.__neg__ = neg
+    Datafield.__pow__ = pow
+    Datafield.__truediv__ = div
+    Datafield.__rtruediv__ = rdiv
+    Datafield.__sub__ = sub
+    Datafield.__rsub__ = rsub

nodev/cuda.py

@@ -0,0 +1,27 @@
+import numpy as np
+gpu_enable=True
+try:
+    import cupy as cp
+    cupy=cp
+except ImportError:
+    gpu_enable=False
+from nodev import Datafield
+def get_array_module(x):
+    if isinstance(x, Datafield):
+        x=x.data
+    if not gpu_enable:
+        return np
+    xp=cp.get_array_module(x)
+    return xp
+def as_numpy(x):
+    if isinstance(x, Datafield):
+        x=x.data
+    if np.isscalar(x):
+        return np.array(x)
+def as_cupy(x):
+    if isinstance(x, Datafield):
+        x = x.data
+    if not gpu_enable:
+
+        raise Exception('CuPy无法使用，请检查是否安装')
+    return cp.asarray(x)

nodev/dataloaders.py

@@ -0,0 +1,65 @@
+import math
+
+import numpy as np
+from nodev import cuda
+
+
+class Dataloader:
+    def __init__(self,dataset,batch_size,shuffle=True,gpu=False):
+        self.dataset=dataset
+        self.batch_size=batch_size
+        self.shuffle=shuffle
+        self.data_size=len(dataset)
+        self.gpu=gpu
+        self.max_iter=math.ceil(self.data_size/batch_size)
+        self.reset()
+
+
+    def reset(self):
+        self.iteration=0
+        if self.shuffle:
+            self.index=np.random.permutation(len(self.dataset))
+        else:
+            self.index=np.arange(len(self.dataset))
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        if self.iteration>=self.max_iter:
+            self.reset()
+            raise StopIteration
+        i,batch_size=self.iteration,self.batch_size
+        batch_index=self.index[i*batch_size:(i+1)*batch_size]
+        batch=[self.dataset[i] for i in batch_index]
+        xp=cuda.cupy if self.gpu else np
+        x=xp.array([example[0] for example in batch])
+        t = xp.array([example[1] for example in batch])
+        self.iteration+=1
+
+
+        return x,t
+    def next(self):
+        return self.__next__()
+    def to_cpu(self):
+        self.gpu=False
+
+    def to_gpu(self):
+        self.gpu = True
+
+
+
+class SeqDataLoader(Dataloader):
+    def __init__(self,dataset,batch_size,gpu=False):
+        super().__init__(dataset=dataset,batch_size=batch_size,shuffle=False,gpu=gpu)
+    def __next__(self):
+        if self.iteration>=self.max_iter:
+            self.reset()
+            raise StopIteration
+        jump=self.data_size//self.batch_size
+        batch_index=[(i*jump+self.iteration)%self.data_size for i in range(self.batch_size)]
+        batch=[self.dataset[i] for i in batch_index]
+        xp=cuda.cupy if self.gpu else np
+        x=xp.array([example[0] for example in batch])
+        t = xp.array([example[1] for example in batch])
+        self.iteration+=1
+        return x,t

nodev/dataset.py

@@ -0,0 +1,186 @@
+
+import numpy as np
+
+from nodev.transforms import Compose, Flatten, ToFloat, Normalize
+
+class Dataset():
+    def __init__(self,train=True,transform=None,target_transform=None):
+        self.train=train
+        self.transform=transform
+        self.target_transform=target_transform
+        if self.transform is None:
+            self.transform=lambda x:x
+        if self.target_transform is None:
+            self.target_transform = lambda x: x
+
+        self.data=None
+        self.label=None
+        self.prepare()
+    def __getitem__(self, index):
+        assert np.isscalar(index)
+        if self.label is None:
+            return self.transform(self.data[index]),None
+        else:
+            return self.transform(self.data[index]),\
+                   self.target_transform(self.label[index])
+    def prepare(self):
+        pass
+    def __len__(self):
+        return len(self.data)
+
+class Spiral(Dataset):
+   """ def __init__(self,train=True):
+        super().__init__()"""
+   def prepare(self):
+        self.data,self.label=get_spiral(self.train)
+
+class Bigdata(Dataset):
+    def __getitem__(self,index):
+        x=np.load('data/{}.npy'.format(index))
+        t = np.load('label/{}.npy'.format(index))
+        return x,t
+    def __len__(self):
+        return 1000000
+def get_spiral(train=True):
+    seed = 1984 if train else 2020
+    np.random.seed(seed)
+
+    num_data = 100
+    num_class = 3
+    input_dim = 2
+
+    data_size = num_class * num_data
+    x = np.zeros((data_size, input_dim), dtype=np.float32)
+    t = np.zeros(data_size, dtype=np.int32)
+
+    for j in range(num_class):
+        for i in range(num_data):
+            rate = i / num_data
+            r = rate
+            theta = j * 4.0 + 4.0 * rate + np.random.randn() * 0.2
+            ix = num_data * j + i
+
+            x[ix] = [r*np.sin(theta), r*np.cos(theta)]
+            t[ix] = j
+
+    return x, t
+
+
+class ImageNet(Dataset):
+    def __init__(self):
+        super().__init__()
+    @staticmethod
+    def labels():
+        path = 'models/labels'
+        with open(path, 'r') as f:
+            labels = eval(f.read())
+        return labels
+"""class MNIST(Dataset):
+
+    def __init__(self, train=True,
+                 transform=Compose([Flatten(), ToFloat(),
+                                     Normalize(0., 255.)]),
+                 target_transform=None):
+        super().__init__(train, transform, target_transform)
+
+    def prepare(self):
+
+        if self.train:
+            data_path = "./data/train-images.idx3-ubyte"
+            label_path = "./data/train-labels.idx1-ubyte"
+        else:
+            data_path = "./data/t10k-images.idx3-ubyte"
+            label_path = "./data/t10k-labels.idx1-ubyte"
+        self.data = self._load_data(data_path)
+        self.label = self._load_label(label_path)
+
+    def _load_label(self, filepath):
+        with gzip.open(filepath, 'rb') as f:
+            labels = np.frombuffer(f.read(), np.uint8, offset=8)
+        return labels
+
+    def _load_data(self, filepath):
+        with gzip.open(filepath, 'rb') as f:
+            data = np.frombuffer(f.read(), np.uint8, offset=16)
+        data = data.reshape(-1, 1, 28, 28)
+        return data
+
+    def show(self, row=10, col=10):
+        H, W = 28, 28
+        img = np.zeros((H * row, W * col))
+        for r in range(row):
+            for c in range(col):
+                img[r * H:(r + 1) * H, c * W:(c + 1) * W] = self.data[
+                    np.random.randint(0, len(self.data) - 1)].reshape(H, W)
+        plt.imshow(img, cmap='gray', interpolation='nearest')
+        plt.axis('off')
+        plt.show()
+
+    @staticmethod
+    def labels():
+        return {0: '0', 1: '1', 2: '2', 3: '3', 4: '4', 5: '5', 6: '6', 7: '7', 8: '8', 9: '9'}
+"""
+
+
+class MNIST(Dataset):
+
+    def __init__(self, train=True,
+                 transform=Compose([Flatten(), ToFloat(),
+                                    Normalize(0., 255.)]),
+                 target_transform=None):
+        super().__init__(train, transform, target_transform)
+
+    def prepare(self):
+
+        if self.train:
+            data_path = "data/train-images.idx3-ubyte"
+            label_path = "data/train-labels.idx1-ubyte"
+        else:
+            data_path = "data/t10k-images.idx3-ubyte"
+            label_path = "data/t10k-labels.idx1-ubyte"
+
+        self.data = self._load_images(data_path)
+        self.label = self._load_labels(label_path)
+
+    def _load_images(self, path):
+
+        with open(path, 'rb') as f:
+            data = np.frombuffer(f.read(), np.uint8, offset=16)
+
+        #data = data.reshape(-1, 784)
+        data = data.reshape(-1, 28, 28)
+        return data
+
+    def _load_labels(self, path):
+
+        with open(path, 'rb') as f:
+            labels = np.frombuffer(f.read(), np.uint8, offset=8)
+
+        return labels
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self, idx):
+        image = self.data[idx]
+        label = self.label[idx]
+
+        if self.transform:
+            image = self.transform(image)
+
+        return image, label
+class SinCurve(Dataset):
+
+    def prepare(self):
+        num_data = 1000
+        dtype = np.float64
+
+        x = np.linspace(0, 2 * np.pi, num_data)
+        noise_range = (-0.05, 0.05)
+        noise = np.random.uniform(noise_range[0], noise_range[1], size=x.shape) #生成均匀分布随机数
+        if self.train:
+            y = np.sin(x) + noise
+        else:
+            y = np.cos(x)
+        y = y.astype(dtype)
+        self.data = y[:-1][:, np.newaxis]
+        self.label = y[1:][:, np.newaxis]