deepxpy:初步支持eager模式IR输出

Author: miaobyte

front/py/deepx/autograd/__init__.py

@@ -8,4 +8,5 @@
     'Node',
     'NodeType',
     'DataNode',
+
    ]

front/py/deepx/autograd/_datanode.py

@@ -2,10 +2,10 @@
 from .nodetype import NodeType 
 
 class DataNode(Node):
-    def __init__(self, name=None, data=None):
+    def __init__(self, name=None, type=None, data=None):
         super().__init__(name=name, ntype=NodeType.DATA)
         self._data = data
-    
+        self._type=type
     def data(self):
         return self._data
 

front/py/deepx/autograd/_opnode.py

@@ -24,7 +24,6 @@ def register_op(cls, name: str) -> None:
 class OpNode(Node, metaclass=OpNodeMeta):
     def __init__(self, name: str):
         super().__init__(name=name, ntype=NodeType.OP)
-
     @classmethod
     def register(cls, name: str) -> None:
         cls.__class__.register_op(name)

front/py/deepx/autograd/graph.py

@@ -1,9 +1,7 @@
 from ._datanode import DataNode
 from ._opnode import OpNode
 from ._controlflownode import ControlFlowNode
-
-eager_mode=False
-
+ 
 class Graph:
     # 类属性存储默认实例
     _default_graph = None
@@ -22,29 +20,58 @@ def set_default(cls, graph):
             raise TypeError("Must be a Graph instance")
         cls._default_graph = graph
 
-    def __init__(self,eager=False):
+    def __init__(self,eager=True):
         self.nodes = []
         self.inputs = []
-        self.data_counter = 0
+        self.var_counter = 0
+        self.vector_counter = 0
+        self.tensor_counter = 0
         self.control_flow_counter = 0
-        self.eager=eager or eager_mode
+        self.eager=eager
+    
+    @property
+    def eager(self):
+        return self._eager
+    @eager.setter
+    def eager(self,value):
+        self._eager=value
 
-    def add_data(self, name, data,inputs=[]):
-        self.data_counter += 1
+    def add_var(self, name,data,inputs=[]):
+        self.var_counter += 1
+        if name == "":
+            name = f"var_{self.var_counter}"
+        node=DataNode(name, "var", data)
+        for input in inputs:
+            node.add_input(input)
+        self.nodes.append(node)
+        return node
+    
+    def add_vector(self, name,data,inputs=[]):
+        self.vector_counter += 1
         if name == "":
-            name = f"data_{self.data_counter}"
-        node=DataNode(name, data)
+            name = f"vector_{self.vector_counter}"
+        node=DataNode(name, "vector", data)
         for input in inputs:
             node.add_input(input)
         self.nodes.append(node)
         return node
+    
+    def add_tensor(self, name,data,inputs=[]):
+        self.tensor_counter += 1
+        if name == "":
+            name = f"tensor_{self.tensor_counter}"
+        node=DataNode(name, "tensor", data)
+        for input in inputs:
+            node.add_input(input)
+        self.nodes.append(node)
+        return node
+
+
     def add_op(self,name,inputs=[]):
         node=OpNode(name)
         for input in inputs:
             node.add_input(input)
         self.nodes.append(node)
-        if self.eager:
-            return node.outputs[0]
         return node
     def add_control_flow(self,name,inputs=[]):
         self.control_flow_counter += 1

front/py/deepx/tensor/deepxir.py

@@ -1,7 +1,7 @@
 from typing import Any, Tuple, List, Optional
 from ..autograd.graph import Graph  
 
-class Op:
+class DeepxIR:
     def __init__(self, 
                 name:str,
                 dtype:str,
@@ -45,21 +45,7 @@ def forward(self, *input) -> Tuple:
     def backward(self, *grad_outputs) -> Tuple:
         raise NotImplementedError
 
-    def get_grad_mapping(self, is_backward: bool) -> List[Tuple[str, str]]:
-        """
-        获取参数与梯度的映射关系
-        Returns:
-            返回（参数名，梯度名）元组列表，梯度名为空表示无梯度
-        """
-        if not self._grad or not is_backward:
-            return [(arg, "") for arg in self._args]
-            
-        return [
-            (arg, grad) 
-            for arg, grad in zip(self._args, self._args_grad)
-        ]
-
-    def ir(self) -> str:
+    def __str__(self):
         """生成IR指令的优化实现"""
         parts = [f"{self._name}@{self._dtype}"]
 

front/py/deepx/tensor/dtype.py

@@ -1,35 +1,49 @@
-from enum import Enum, auto
+import numpy as np
+from typing import Any
 
-class DType(Enum):
-    COMPLEX64 = auto()
-    COMPLEX128 = auto()
-    BFLOAT16 = auto()
-    FLOAT16 = auto()
-    FLOAT32 = auto()
-    FLOAT64 = auto()
-    UINT8 = auto()
-    INT8 = auto()
-    UINT16 = auto()
-    UINT32 = auto()
-    INT32 = auto()
-    UINT64 = auto()
-    INT64 = auto()
-    BOOL = auto()
+DTYPE_MAP = {
+    'float16': np.float16,
+    'float32': np.float32,
+    'float64': np.float64,
+    'int8': np.int8,
+    'int16': np.int16,
+    'int32': np.int32,
+    'int64': np.int64,
+}
 
-def _dtype_to_typestr(dtype):
-    return {
-        DType.COMPLEX64: "<c8",
-        DType.COMPLEX128: "<c16", 
-        DType.BFLOAT16: "<V2",
-        DType.FLOAT16: "<f2",
-        DType.FLOAT32: "<f4",
-        DType.FLOAT64: "<f8",
-        DType.UINT8: "|u1",
-        DType.INT8: "|i1",
-        DType.UINT16: "<u2",
-        DType.INT32: "<i4",
-        DType.UINT32: "<u4",
-        DType.UINT64: "<u8",
-        DType.INT64: "<i8",
-        DType.BOOL: "|b1",
-    }[dtype] 
+def infer_dtype(data: Any) -> str:
+    """
+    推断数组元素的深度学习数据类型
+    
+    支持类型优先级（从高到低）：
+    float32 > float64 > int32 > int64 > bool
+    
+    Args:
+        data: 输入数据，支持Python原生类型、Numpy数组、列表等
+        
+    Returns:
+        str: 数据类型名称（'float32', 'int32'等）
+        
+    Raises:
+        TypeError: 当包含不支持的数据类型时
+    """
+    # 转换为numpy数组进行类型推断
+    arr = np.asarray(data)
+
+    # 根据数值范围自动选择精度
+    if np.issubdtype(arr.dtype, np.integer):
+        if arr.itemsize <= 4:
+            return 'int32' if arr.min() >= np.iinfo(np.int32).min else 'int64'
+        return 'int64'
+    
+    if np.issubdtype(arr.dtype, np.floating):
+        return 'float32' if arr.itemsize <= 4 else 'float64'
+    
+    # 处理特殊类型（如对象数组）
+    if arr.dtype == np.object_:
+        unique_types = {type(x) for x in arr.flat}
+        if {int, float} == unique_types:
+            return 'float32'
+        raise TypeError(f"混合类型或不支持的类型: {unique_types}")
+    
+    raise TypeError(f"不支持的数据类型: {arr.dtype}")

front/py/deepx/tensor/elementwise.py

@@ -1,17 +1,19 @@
 from .tensor import Tensor,tensor_method
 from deepx.autograd.graph import Graph,DataNode,OpNode
-
+from .deepxir import DeepxIR
 OpNode.register("add")
 
 @tensor_method
 def add(self, other):
-    result = self.graph.add_data("", self)
-    op = self.graph.add_op("add")
-    op.add_input(self.node)
-    op.add_input(other.node)
-    result.add_input(op)
-    
-    return result
+    resultnode = self.graph.add_tensor("", self)
+    opnode = self.graph.add_op("add")
+    opnode.add_input(self.node)
+    opnode.add_input(other.node)
+    resultnode.add_input(opnode)
+    if self.graph.eager:
+        ir=DeepxIR("add", self._dtype, [self.node.name, other.node.name], [resultnode.name])
+        print(ir)
+    return resultnode
 
 OpNode.register("mul")
 

front/py/deepx/tensor/tensor.py

@@ -3,17 +3,32 @@
 from .shape import Shape
 from .devicetype import Device
 from deepx.autograd import Graph,DataNode
-
+from .deepxir import DeepxIR
+from .dtype import infer_dtype,DTYPE_MAP
 class Tensor:
     def __init__(self, data=None, shape=None, device=None, dtype=None, graph=None):
+        # 计算图相关
+        if graph is None:
+            self._graph = Graph.get_default()
+        else:
+            self._graph = graph 
+        self._node= self._graph.add_tensor("",data=self)
+
         # data
         if data is not None:
             import numpy as np
             if not isinstance(data, np.ndarray):
                 data = np.array(data)
-            self.data = data
+            self.data = data           
             self._shape = Shape(data.shape)
 
+        # dtype
+        if dtype is None:
+            self._dtype = infer_dtype(data)
+        else:
+            self._dtype = dtype
+            self._data = data.astype(DTYPE_MAP[dtype], casting='safe')
+        self._node.dtype = dtype
         # shape
         if shape is not None:
             if isinstance(shape, (tuple, list)) and all(isinstance(i, int) for i in shape):
@@ -22,7 +37,13 @@ def __init__(self, data=None, shape=None, device=None, dtype=None, graph=None):
                 self._shape = shape
             else:
                 raise ValueError("Invalid shape")
-        
+        shapeNode=self._graph.add_vector("",data=self._shape.shape)
+        self._node.add_input(shapeNode)
+        if self._graph.eager:
+            ir1=DeepxIR("argset", 'int32',  self._shape.shape, [shapeNode.name])
+            print(ir1)
+            ir2=DeepxIR("newtensor", self._dtype, [shapeNode.name], [self._node.name])
+            print(ir2)
         # device
         if isinstance(device, str):
             self._device = Device.from_string(device)
@@ -32,17 +53,7 @@ def __init__(self, data=None, shape=None, device=None, dtype=None, graph=None):
             self._device = Device.CPU  # 默认设备
 
         self._dtype = dtype
-
-        # 计算图相关
-        if graph is None:
-            self._graph = Graph.get_default()
-        else:
-            self._graph = graph 
-        self._node= self._graph.add_data(name="",data=self.data)
-
-
-        self._requires_grad = False
-
+ 
         self.data = data
     # shape
     @property

front/py/examples/2_ir/1_ir.py

@@ -1,6 +1,6 @@
-from deepx.tensor.op import Op
+from deepx.tensor.deepxir import DeepxIR
 # 正向传播示例
-op = Op(
+op = DeepxIR(
     name="add",
     args=["t1", "t2"], 
     returns=["t3"],
@@ -16,7 +16,7 @@
 # 输出: add@float32 t1(t1_grad) t2(t2_grad) <- t3(t3_grad)
 
 # 标量操作示例
-scalar_op = Op(
+scalar_op = DeepxIR(
     name="scalar",
     args=["t1", "a1"],  # a1为参数
     returns=["t3"],

front/py/examples/2_ir/2_add.py

@@ -1,8 +1,7 @@
 from deepx.tensor import Tensor
+print()
 
 t1 = Tensor([1,2,3])
 t2 = Tensor([4,5,6])
-print(hasattr(Tensor, 'add')) 
 t3 = t1.add(t2)
-g=t3.graph
-print(g)
+