deep-core

开放问题

• 设计和 API；操作符实现作为常量值，在它的模块中全局
• 自引用；在 playground 中的示例中描述问题： https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=08ef7319c1c1b65800d655c2d6176ca4
  • 不能按最初期望的那样实现。使用索引（副本）实现

运行示例

查看 ~/examples 目录中（文件名）存在的 {some-example} 并运行
cargorun --example {some-example}

下一个计划 - TODO：移动到路线图

按预期实现顺序

• 图遍历和访问模式

  • 无需深入研究图论，只需迭代节点等即可 - 不要过度

• 前向计算引擎

  • 张量算术
  • 设计
  • 在简单的图（dot -> add -> leaky）上使用 CPU 后端实现第一个草案

• 后向计算引擎

  • 如何计算梯度（每个操作，每个后端等）？
  • 设计
    • 类似于前向，但请注意，此引擎可以更改参数节点
  • 在正向计算引擎可以解决的 图 上使用 CPU 后端实现第一个草案

• 使用正向和后向引擎都可以解决的图进行简单训练

  • 前向传播
  • 反向传播
  • 2 种不同的梯度下降优化器
    • 实际上哪个不重要，但至少实现两种，以强制我们解耦实现
    • sgd 和批处理可能？

• LeNet 实现

  • 操作符实现（卷积池等所需操作）
  • 训练
  • 检查我们在 mnist 数据集上得到的结果是否合理

希望得到

• 单元测试
• 文档
• 图序列化
  • 字符串到/从
  • 二进制到/从

示例图

以下序列化由默认的 Debug Rust 格式化程序生成，格式在此不是很重要，并且可能会在未来更改。这里重要的是哪个，以及哪些数据。

Graph {
    id: 0,
    nodes: [
        InputNode {
            id: 0,
            tensor_descriptor: TensorDescriptor {
                tensor_id: 0,
                shape: Some(
                    Shape {
                        dimensions: [
                            3
                        ]
                    }
                )
            }
        },
        ParameterNode {
            id: 1,
            tensor_descriptor: TensorDescriptor {
                tensor_id: 1,
                shape: Some(
                    Shape {
                        dimensions: [
                            3,
                            3
                        ]
                    }
                )
            }
        },
        ParameterNode {
            id: 2,
            tensor_descriptor: TensorDescriptor {
                tensor_id: 2,
                shape: Some(
                    Shape {
                        dimensions: [
                            3
                        ]
                    }
                )
            }
        },
        OperationNode {
            id: 1,
            operation: Dot
        },
        OperationNode {
            id: 2,
            operation: Add
        },
        OperationNode {
            id: 3,
            operation: LeakyRelu(
                0.57
            )
        }
    ],
    edges: [
        OperandEdge {
            id: 0,
            connection: (
                0,
                1
            ),
            operand: 0
        },
        OperandEdge {
            id: 1,
            connection: (
                1,
                1
            ),
            operand: 1
        },
        OperandEdge {
            id: 2,
            connection: (
                1,
                2
            ),
            operand: 0
        },
        OperandEdge {
            id: 3,
            connection: (
                2,
                2
            ),
            operand: 0
        },
        OperandEdge {
            id: 4,
            connection: (
                2,
                3
            ),
            operand: 0
        }
    ]
}