nodev 1.0.0__py3-none-any.whl

nodev/layers.py

@@ -0,0 +1,179 @@
+import os.path
+
+import numpy as np
+from nodev.utils import pair
+from nodev import cuda
+from nodev import operations as F
+
+from nodev.core import Formpara
+import weakref
+
+
+class Layer:
+    def __init__(self):
+        self._params=set()
+    def __call__(self, *inputs):
+
+        outputs = self.forward(*inputs)
+        if not isinstance(outputs,tuple):
+            outputs=(outputs,)
+        self.inputs=[weakref.ref(x) for x in inputs]
+        self.output=[weakref.ref(y) for y in outputs]
+        return outputs if len(outputs)>1 else outputs[0]
+
+    def _flatten_params(self,param_dict,parent_key=''):
+        for name in self._params:
+            obj=self.__dict__[name]
+            key=parent_key+'/'+name if parent_key else name
+            if isinstance(obj,Layer):
+                obj._flatten_params(param_dict,key)
+            else:
+                param_dict[key]=obj
+    def save_weights(self,path):
+        self.to_cpu()
+        params_dict={}
+        self._flatten_params(params_dict)
+        array_dict={key:param.data for key,param in params_dict.items() if param is not None}
+        try:
+            np.savez_compressed(path,**array_dict)
+        except(Exception,KeyboardInterrupt) as e:
+            if os.path.exists(path):
+                raise
+    def load_weights(self,path):
+        npz=np.load(path,allow_pickle=True)
+        params_dict={}
+        self._flatten_params(params_dict)
+        for key,param in params_dict.items():
+            param.data=npz[key]
+    def __setattr__(self, name, value):  #_params 保存示例的参数
+        if isinstance(value, (Formpara, Layer)):
+            self._params.add(name)
+        super().__setattr__(name,value)
+    def forward(self,inputs):
+        raise NotImplementedError()
+    def params(self):
+        for name in self._params:
+            obj=self.__dict__[name]
+            if isinstance(obj,Layer):
+                yield from obj.params()
+            else:
+                yield obj
+    def cleargrads(self):
+            for param in self.params():
+                param.clear_grad()
+    def to_cpu(self):
+        for param in self.params():
+            param.to_cpu()
+    def to_gpu(self):
+        for param in self.params():
+            param.to_gpu()
+class Linear(Layer):
+    def __init__(self,out_size,nobias=False,dtype=np.float32,in_size=None):
+        super().__init__()
+        self.in_size=in_size
+        self.out_size=out_size
+        self.dtype=dtype
+
+        self.W=Formpara(None, name='W')
+        if self.in_size is not None:  #延后处理
+            self._init_W()
+        if nobias:
+            self.b=None
+        else:
+            self.b=Formpara(np.zeros(out_size, dtype=dtype), name='b')
+
+    def _init_W(self):  #生成一个张量，长宽和输入输出相同
+
+        I,O=self.in_size,self.out_size
+
+        W_data=np.random.randn(I,O).astype(self.dtype)*np.sqrt(1/I)
+
+        self.W.data=W_data
+
+    def forward(self,x):
+    #在传播时初始化权重
+        #print("W.data:", self.W.data)
+        #print("type:", type(self.W.data))
+
+       #print(f"repr(self.W.data): {repr(self.W.data)}")
+        #print(f"W.data is None: {self.W.data is None}")
+        #print(f"W.data == None: {self.W.data == None}")
+        if self.W.data is None:
+            #print("x type:", type(x))
+            #print("W.data before:", self.W.data)
+            self.in_size=x.shape[1]
+
+            self._init_W()
+
+        y=F.linear(x, self.W, self.b)
+        return y
+
+"""class Linear(Layer):
+    def __init__(self, out_size, nobias=False, dtype=np.float32,in_size=None):
+        super().__init__()
+        self.in_size = in_size
+        self.out_size = out_size
+        self.dtype = dtype
+
+        I, O = self.in_size, self.out_size
+        W_data = np.random.randn(I, O).astype(self.dtype) * np.sqrt(1 / I)
+        self.W = Formpara(W_data, name="W")
+
+        if nobias:
+            self.b = None
+        else:
+            self.b = Formpara(np.zeros(out_size, dtype=dtype), name="b")
+
+    def forward(self, x: Datafield) -> Datafield:
+        y = F.linear(x, self.W, self.b)
+        return y
+"""
+
+class Conv2d(Layer):
+    def __init__(self, out_channels, kernel_size, stride=1, pad=0, nobias=False, dtype=np.float32, in_channels=None):
+        super().__init__()
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.kernel_size = kernel_size
+        self.stride = stride
+        self.pad = pad
+        self.dtype = dtype
+        self.W = Formpara(None, name='W')
+        if in_channels is not None:
+            self._init_W()
+        if nobias:
+            self.b = None
+        else:
+            self.b = Formpara(np.zeros(out_channels, dtype=dtype), name='b')
+
+    def _init_W(self, xp=np):
+        C, OC = self.in_channels, self.out_channels
+        KH, KW = pair(self.kernel_size)
+        scale = np.sqrt(1 / (C * KH * KW))
+        W_data = xp.random.randn(OC, C, KH, KW).astype(self.dtype) * scale
+        self.W.data = W_data
+
+    def forward(self, x):
+        if self.W.data is None:
+            self.in_channels = x.shape[1]
+            xp = cuda.get_array_module(x)
+            self._init_W(xp)
+        y = F.conv2d(x, self.W, self.b, self.stride, self.pad)
+        return y
+
+class RNN(Layer):
+    def __init__(self,hidden_size,in_size=None):
+        super().__init__()
+        self.x2h=Linear(hidden_size,in_size=in_size)
+        self.h2h=Linear(hidden_size,in_size=in_size,nobias=True)
+        self.h=None
+    def reset_state(self):
+        self.h=None
+    def forward(self,x):
+        if self.h is None:
+            h_new=F.tanh(self.x2h(x))
+        else:
+            h_new = F.tanh(self.x2h(x)+self.h2h(self.h))
+        self.h=h_new
+        return h_new
+    

nodev/model.py

@@ -0,0 +1,119 @@
+
+import numpy as np
+from nodev import Layer
+from nodev import utils
+import nodev.operations as F
+import nodev.layers as L
+from nodev.operations import dropout
+
+
+class Model(Layer):
+    def plot(self,*inputs,to_file='model.png'):
+        y=self.forward(*inputs)
+        return utils.plot_dot_graph(y,verbose=True,to_file=to_file)
+
+class MLP(Model):
+    def __init__(self,fc_output_sizes,activation=F.sigmoid):
+        super().__init__()   #调用父类初始构造函数
+        self.activation=activation
+        self.layers=[]
+        for i,out_size in enumerate(fc_output_sizes):
+            layer=L.Linear(out_size)
+            setattr(self,'l'+str(i),layer)
+            self.layers.append(layer)
+
+    def forward(self,x):
+        for l in self.layers[:-1]:
+            x=self.activation(l(x))
+        return self.layers[-1](x)
+    
+class VGG16(Model):
+    WEIGHTS_PATH = 'models/vgg16.npz'
+    def __init__(self,pretrained=False):
+        super().__init__()
+        self.conv1_1=L.Conv2d(64,kernel_size=3,stride=1,pad=1)
+        self.conv1_2 = L.Conv2d(64, kernel_size=3, stride=1, pad=1)
+        self.conv2_1 = L.Conv2d(128, kernel_size=3, stride=1, pad=1)
+        self.conv2_2 = L.Conv2d(128, kernel_size=3, stride=1, pad=1)
+        self.conv3_1 = L.Conv2d(256, kernel_size=3, stride=1, pad=1)
+        self.conv3_2 = L.Conv2d(256, kernel_size=3, stride=1, pad=1)
+        self.conv3_3 = L.Conv2d(256, kernel_size=3, stride=1, pad=1)
+        self.conv4_1 = L.Conv2d(512, kernel_size=3, stride=1, pad=1)
+        self.conv4_2 = L.Conv2d(512, kernel_size=3, stride=1, pad=1)
+        self.conv4_3 = L.Conv2d(512, kernel_size=3, stride=1, pad=1)
+        self.conv5_1 = L.Conv2d(512, kernel_size=3, stride=1, pad=1)
+        self.conv5_2 = L.Conv2d(512, kernel_size=3, stride=1, pad=1)
+        self.conv5_3 = L.Conv2d(512, kernel_size=3, stride=1, pad=1)
+        self.fc6=L.Linear(4096)
+        self.fc7 = L.Linear(4096)
+        self.fc8 = L.Linear(4096)
+        if pretrained:
+            self.load_weights(VGG16.WEIGHTS_PATH)
+    def forward(self,x):
+        x=F.relu(self.conv1_1(x))
+        x=F.relu(self.conv1_2(x))
+        x=F.pooling(x,2,2)
+        x=F.relu(self.conv2_1(x))
+        x = F.relu(self.conv2_2(x))
+        x = F.pooling(x, 2, 2)
+        x = F.relu(self.conv3_1(x))
+        x = F.relu(self.conv3_2(x))
+        x = F.relu(self.conv3_3(x))
+        x = F.pooling(x, 2, 2)
+        x = F.relu(self.conv4_1(x))
+        x = F.relu(self.conv4_2(x))
+        x = F.relu(self.conv4_3(x))
+        x = F.pooling(x, 2, 2)
+        x = F.relu(self.conv5_1(x))
+        x = F.relu(self.conv5_2(x))
+        x = F.relu(self.conv5_3(x))
+        x = F.pooling(x, 2, 2)
+        x=F.reshape(x,(x.shape[0],-1))
+        x=dropout(F.relu(self.fc6(x)))
+        x = dropout(F.relu(self.fc7(x)))
+        x = self.fc8(x)
+        return x
+
+    @staticmethod
+    def preprocess(image, size=(224, 224), dtype=np.float32):
+        image = image.convert('RGB')
+        if size:
+            image = image.resize(size)
+        image = np.asarray(image, dtype=dtype)
+        image = image[:, :, ::-1]
+        image -= np.array([103.939, 116.779, 123.68], dtype=dtype)
+        image = image.transpose((2, 0, 1))
+        return image
+
+
+class ImprovedLeNet5(Model):
+    def __init__(self):
+        super().__init__()
+        # 针对MNIST优化
+        self.conv1 = L.Conv2d(32, 5, stride=1, pad=2)  # 28->28
+        self.conv2 = L.Conv2d(64, 5, stride=1, pad=2)  # 14->14
+        self.fc1 = L.Linear(64 * 8 * 8, 512)
+        self.fc2 = L.Linear(512, 10)
+        self.dropout = 0.5
+
+    def forward(self, x):
+        x = F.relu(self.conv1(x))
+        x = F.pooling(x, 2, 2)  # 28->14
+        x = F.relu(self.conv2(x))
+        x = F.pooling(x, 2, 2)  # 14->7
+        x = x.reshape(x.shape[0], -1)
+        x = F.relu(self.fc1(x))
+        x = F.dropout(x, self.dropout)
+        x = self.fc2(x)
+        return x
+class SimpleRNN(Model):
+    def __init__(self,hidden_size,out_size):
+        super().__init__()
+        self.rnn=L.RNN(hidden_size)
+        self.fc=L.Linear(out_size)
+    def  reset_state(self):
+        self.rnn.reset_state()
+    def forward(self,x):
+        h=self.rnn(x)
+        y=self.fc(h)
+        return y

nodev/operations.py

@@ -0,0 +1,389 @@
+import numpy as np
+from typing import Tuple
+from nodev import Datafield
+import nodev
+from nodev import as_array
+from nodev import cuda
+from nodev.core import Operation
+from nodev import utils
+from nodev import as_datafield
+
+
+class Reshape(Operation):#矩阵变形
+    def __init__(self,shape):
+        self.shape=shape
+    def forward(self,x):
+        self.x_shape=x.shape
+        y=x.reshape(self.shape)
+        return y
+    def backward(self,gy):
+        return reshape(gy,self.x_shape)
+class Sin(Operation):
+    def forward(self,x):
+        xp=cuda.get_array_module(x)
+        y=xp.sin(x)
+        return y
+    def backward(self,gy):
+        x,=self.inputs
+        gx=gy*cos(x)
+        return gx
+class Cos(Operation):
+    def forward(self,x):
+        xp = cuda.get_array_module(x)
+        y=xp.cos(x)
+        return y
+    def backward(self,gy):
+        x,=self.inputs
+        gx=-gy*sin(x)
+        return gx
+class Tanh(Operation):
+    def forward(self,x):
+        xp = cuda.get_array_module(x)
+        y=xp.tanh(x)
+        return y
+    def backward(self,gy):
+        y=self.outputs[0]()
+        gx=gy*(1-y**2)
+        return gx
+class Transpose(Operation):
+    def forward(self,x):
+        xp = cuda.get_array_module(x)
+        y=xp.transpose(x)
+        return y
+    def backward(self,gy):
+        gx=transpose(gy)
+        return gx
+class Sum(Operation):
+    def __init__(self,axis,keepdims):  #axis轴 keepdims=true 保留轴的数量
+        self.axis=axis
+        self.keepdims=keepdims
+    def forward(self,x):
+        self.x_shape=x.shape
+        y=x.sum(axis=self.axis,keepdims=self.keepdims)
+        return y
+    def backward(self,gy):
+        gy=utils.reshape_sum_backward(gy,self.x_shape,self.axis,self.keepdims)
+        gx=broadcast_to(gy,self.x_shape)
+        return gx
+class BroadcastTo(Operation):
+    def __init__(self,shape):
+        self.shape=shape
+
+    def forward(self,x):
+        xp = cuda.get_array_module(x)
+        self.x_shape=x.shape
+        y=xp.broadcast_to(x,self.shape)
+        return y
+    def backward(self,gy):
+        gx=sum_to(gy,self.x_shape)
+        return gx
+class MeanSquaredError(Operation):   #均方误差
+    def forward(self,x0,x1):
+        diff=x0-x1
+        y=(diff**2).sum()/len(diff)
+        return y
+
+    def backward(self,gy):
+        x0,x1=self.inputs
+        diff=x0-x1
+        gx0=gy*diff*(2./len(diff))
+        gx1=-gx0
+        return gx0,gx1
+class Log(Operation):
+    def forward(self, x):
+        xp = cuda.get_array_module(x)
+        y = xp.log(x)
+        return y
+    def backward(self,gy):
+        x,=self.inputs
+        gx = gy / x
+        return gx
+class Exp(Operation):
+    def __init__(self):
+        pass
+    def forward(self,x):
+        xp = cuda.get_array_module(x)
+        y=xp.exp(x)
+        return y
+    def backward(self,gy):
+
+        x,=self.inputs
+        xp = cuda.get_array_module(x)
+        y = xp.exp(x.data)
+        gx = gy * y
+        return gx
+class Clip(Operation):
+    def __init__(self,x_min,x_max):
+        self.x_min = x_min
+        self.x_max = x_max
+    def forward(self,x):
+        y=np.clip(x,self.x_min,self.x_max)
+        return y
+    def backward(self, gy):
+        x, = self.inputs
+        mask = (x.data >= self.x_min) * (x.data <= self.x_max)
+        gx = gy * mask
+        return gx
+class ReLU(Operation):
+    def forward(self,x):
+        xp = cuda.get_array_module(x)
+        y=xp.maximum(x,0.0)
+        return y
+    def backward(self,gy):
+        x,=self.inputs
+        mask=x.data>0
+        gx=gy*mask
+        return gx
+
+class SumTo(Operation):
+    def __init__(self,shape):
+        self.shape=shape
+
+    def forward(self,x):
+        self.x_shape=x.shape
+        y=utils.sum_to(x,self.shape)
+        return y
+    def backward(self,gy):
+        gx=broadcast_to(gy,self.x_shape)
+        return gx
+class MatMul(Operation):
+    def forward(self,x,w):
+        y=x.dot(w)
+        return y
+    def backward(self,gy):
+        x,w=self.inputs
+        gx=matmul(gy,w.T)
+        gW=matmul(x.T,gy)
+        return gx,gW
+class Min(Operation):
+    def __init__(self, axis, keepdims):
+        self.keepdims = keepdims
+        self.axis = axis
+
+    def forward(self, x):
+        y = x.min(axis=self.axis, keepdims=self.keepdims)
+        return y
+
+    def backward(self, gy):
+        x = self.inputs[0]
+        y = self.outputs[0]()
+class Max(Operation):
+    def __init__(self,axis,keepdims):
+        self.keepdims=keepdims
+        self.axis=axis
+    def forward(self,x):
+        y = x.max(axis=self.axis, keepdims=self.keepdims)
+        return y
+
+    def backward(self, gy):
+        x = self.inputs[0]
+        y = self.outputs[0]()
+
+        shape = utils.max_backward_shape(x.shape, self.axis)
+
+        gy = reshape(gy, shape)
+        y = reshape(y, shape)
+
+        cond = (x.data == y.data)
+
+        gy = broadcast_to(gy, cond.shape)
+
+        gx = gy * cond
+
+        return gx
+class GetItem(Operation):
+    def __init__(self, slices):
+        self.slices = slices
+
+    def forward(self, x):
+        y = x[self.slices]
+        return y
+
+    def backward(self, gy):
+        x, = self.inputs
+        f = GetItemGrad(self.slices, x.shape)
+        return f(gy)
+class Linear(Operation):
+    def forward(
+        self, x: np.ndarray, W: np.ndarray, b= None
+    ) -> Datafield:
+        if W is None or W.data is None:
+            print("ERROR: W is None in forward!")
+            raise ValueError("W cannot be None")
+        y = x.dot(W)
+        if b is not None:
+            y += b
+        return y
+
+    def backward(self, gy: Datafield) -> Tuple[Datafield, Datafield, Datafield]:
+        x, W, b = self.inputs
+        gb = None if b.data is None else sum_to(gy, b.shape)
+        gx = matmul(gy, W.T)
+        gW = matmul(x.T, gy)
+        return gx, gW, gb
+class GetItemGrad(Operation):
+    def __init__(self, slices, in_shape):
+        self.slices = slices
+        self.in_shape = in_shape
+
+    def forward(self, gy):
+        gx = np.zeros(self.in_shape)
+        np.add.at(gx, self.slices, gy)
+        return gx
+
+    def backward(self, ggx):
+        return get_item(ggx, self.slices)
+
+def sum(x,axis=None,keepdims=False):
+    return Sum(axis,keepdims)(x)
+def sin(x):
+    return Sin()(x)
+
+def cos(x):
+    return Cos()(x)
+def tanh(x):
+    return Tanh()(x)
+
+def reshape(x,shape):
+    if x.shape==shape:
+        return as_datafield(x)
+    return Reshape(shape)(x)
+def transpose(x):
+    return Transpose()(x)
+def broadcast_to(x,shape):
+    if x.shape==shape:
+        return as_datafield(x)
+    else:
+        return BroadcastTo(shape)(x)
+
+def sum_to(x,shape):
+    if x.shape==shape:
+        return as_datafield(x)
+    else:
+        return SumTo(shape)(x)
+
+def softmax_simple(x,axis=1):
+    x=as_datafield(x)
+    x = x - max(x,axis=axis, keepdims=True)
+    y=exp(x)
+    sum_y=sum(y,axis=axis,keepdims=True)
+    return y/sum_y
+"""def softmax_cross_entropy_simple(x,t):
+    x,t=as_variable(x),as_variable(t)
+    N=x.shape[0]
+    p=softmax_simple(x)
+    p=clip(p,1e-15,1.0)
+    log_p=log(p)
+    tlog_p = get_item(log_p, (np.arange(N), t.data))
+    #tlog_p=log_p[np.arange(N),t.data]
+    y=-1*sum(tlog_p)/N
+    return y"""
+
+
+def softmax_cross_entropy(x, t):
+    x = as_datafield(x)
+    t = as_datafield(t)
+
+    if t.ndim == 1:
+        N = x.shape[0]
+
+        # 数值稳定的 softmax
+        # 1. 减去最大值防止 exp 溢出
+        max_x = x.max(axis=1, keepdims=True)
+        x = x - max_x
+
+        # 2. 计算 exp
+        exp_x = exp(x)
+
+        # 3. 计算 softmax
+        sum_exp_x = sum(exp_x, axis=1, keepdims=True)
+        log_sum_exp_x = log(sum_exp_x)
+
+        # 4. 直接计算 log(softmax) = x - log(sum(exp(x)))
+        # 这样可以避免中间结果太大
+        log_p = x - log_sum_exp_x
+
+        # 5. 获取目标类别的 log 概率
+        batch_indices = np.arange(N)
+        class_indices = t.data.flatten()
+
+        # 确保索引正确
+        if class_indices.ndim > 1:
+            class_indices = class_indices.flatten()
+
+        # 6. 计算交叉熵
+        tlog_p = get_item(log_p, (batch_indices, class_indices))
+        loss = -sum(tlog_p) / N
+
+        return loss
+def relu(x):
+    return ReLU()(x)
+
+def clip(x, x_min, x_max):
+    x = as_datafield(x)
+    return Clip(x_min, x_max)(x)
+def exp(x):
+    return Exp()(x)
+def matmul(x,W):
+    return MatMul()(x,W)
+def log(x):
+    x=as_datafield(x)
+    return Log()(x)
+def mean_squared_error(x0,x1):
+    return MeanSquaredError()(x0,x1)
+def linear(x: Datafield, W: Datafield, b= None) -> Datafield:
+    return Linear()(x, W, b)
+def get_item(x,slices):
+    return GetItem(slices)(x)
+def sigmoid(x):  #激活函数
+    x=as_datafield(x)
+    y=1/(1+exp(-x))
+    return y
+def max(x, axis=None, keepdims=False):
+    return Max(axis, keepdims)(x)
+def min(x, axis=None, keepdims=False):
+    return Min(axis, keepdims)(x)
+
+def accuracy(y,t):
+    y,t=as_datafield(y),as_datafield(t)
+    pred=y.data.argmax(axis=1).reshape(t.shape)
+    result=(pred==t.data)
+    acc=result.mean()
+    return Datafield(as_array(acc))
+def dropout(x,dropout_ratio=0.5):
+    x=as_datafield(x)
+    if nodev.Config.train is True:
+        xp=cuda.get_array_module(x)
+        mask=xp.random.rand(*x.shape)>dropout_ratio
+        scale=xp.array(1.0-dropout_ratio).astype(x.dtype)
+        y=x*mask/scale
+        return y
+    else:
+        return x
+
+
+class Argmax(Operation):
+    """获取最大值的索引"""
+
+    def __init__(self, axis=None):
+        self.axis = axis
+
+    def forward(self, x):
+        # 前向传播：直接使用numpy的argmax
+        self.x_shape = x.shape
+        y = np.argmax(x, axis=self.axis)
+        return y
+
+    def backward(self, gy):
+        # argmax没有梯度（不可导）
+        return None
+
+
+def argmax(x, axis=None):
+    """DeZero风格的argmax函数"""
+    return Argmax(axis)(x)
+
+from nodev.operations_conv import conv2d
+#from nodev.functions_conv import conv2d
+from nodev.operations_conv import pooling
+#from nodev.functions_conv import average_pooling