Rust实现神经网络时多可变引用问题及可行方案咨询

我正在学习Rust，尝试实现一个小型神经网络来加深理解。神经网络本质是由多个节点互相指向构成的图，我原本计划按如下方式定义结构体：

#[derive(Debug)]
struct Neuron<'a> {
    links: Vec<Link<'a>>,
    value: f32,
}
#[derive(Debug)]
struct Link<'a> {
    weight: f32,
    target: &'a mut Neuron<'a>,
}

但由于Rust的所有权规则，可变引用只能被借用一次，因此如下代码会执行失败：

let mut output = Neuron {
    value: 0.0,
    links: Vec::new(),
};

let a1 = Neuron {
    value: 0.0,
    links: vec![Link {
        weight: -1.49,
        target: &mut output,
    }],
};
let a2 = Neuron {
    value: 0.0,
    links: vec![Link {
        weight: -0.46,
        target: &mut output,
    }],
};

我需要更新所有关联节点的值，因此想咨询如何让如下update_targets函数合法：

fn update_targets(neuron: &Neuron) {
    neuron.links.iter_mut().for_each(|l| {
        l.target.value = 1.0;
    })
}

方案1：用RefCell实现内部可变性 #

把神经元的value字段用RefCell包裹，这样即使持有神经元的不可变引用，也能通过RefCell的内部可变性修改值。同时链接改用不可变引用，避开可变引用的单次借用限制：

use std::cell::RefCell;

#[derive(Debug)]
struct Neuron<'a> {
    links: Vec<Link<'a>>,
    value: RefCell<f32>,
}

#[derive(Debug)]
struct Link<'a> {
    weight: f32,
    target: &'a Neuron<'a>,
}

// 现在可以创建多个指向同一个output的链接
let output = Neuron {
    value: RefCell::new(0.0),
    links: Vec::new(),
};

let a1 = Neuron {
    value: RefCell::new(0.0),
    links: vec![Link {
        weight: -1.49,
        target: &output,
    }],
};
let a2 = Neuron {
    value: RefCell::new(0.0),
    links: vec![Link {
        weight: -0.46,
        target: &output,
    }],
};

// 修改后的update_targets函数
fn update_targets(neuron: &Neuron) {
    neuron.links.iter().for_each(|l| {
        *l.target.value.borrow_mut() = 1.0;
    })
}

这种方式把可变借用检查从编译期推迟到运行时，注意如果出现同时多次可变借用，程序会panic，所以要确保逻辑上不会触发这种情况。

方案2：用ID索引替代直接引用 #

放弃直接存储神经元引用，改为给每个神经元分配唯一ID，用Vec或HashMap管理所有神经元。这种方式完全符合Rust所有权规则，没有额外运行时开销：

#[derive(Debug)]
struct Neuron {
    links: Vec<Link>,
    value: f32,
}

#[derive(Debug)]
struct Link {
    weight: f32,
    target_id: usize,
}

// 用Vec存储所有神经元，索引就是ID
let mut neurons = vec![
    // output神经元，ID=0
    Neuron { value: 0.0, links: Vec::new() },
    // a1神经元，ID=1
    Neuron { value: 0.0, links: vec![Link { weight: -1.49, target_id: 0 }] },
    // a2神经元，ID=2
    Neuron { value: 0.0, links: vec![Link { weight: -0.46, target_id: 0 }] },
];

// 修改后的update_targets函数
fn update_targets(neuron: &Neuron, neurons: &mut [Neuron]) {
    neuron.links.iter().for_each(|l| {
        neurons[l.target_id].value = 1.0;
    })
}

// 调用示例
update_targets(&neurons[1], &mut neurons);

这种方案结构清晰，适合大多数图结构场景，缺点是需要额外管理神经元容器，访问目标节点需要通过索引查找。

方案3：用Rc+RefCell实现共享所有权 #

如果神经网络需要复杂的所有权关系（比如神经元被多个节点引用、动态创建销毁），可以用Rc（引用计数智能指针）共享所有权，搭配RefCell实现内部可变性：

use std::cell::RefCell;
use std::rc::Rc;

#[derive(Debug)]
struct Neuron {
    links: Vec<Link>,
    value: RefCell<f32>,
}

#[derive(Debug)]
struct Link {
    weight: f32,
    target: Rc<Neuron>,
}

// 创建output神经元，用Rc包裹
let output = Rc::new(Neuron {
    value: RefCell::new(0.0),
    links: Vec::new(),
});

// 克隆Rc创建多个链接，不会转移所有权
let a1 = Neuron {
    value: RefCell::new(0.0),
    links: vec![Link {
        weight: -1.49,
        target: Rc::clone(&output),
    }],
};
let a2 = Neuron {
    value: RefCell::new(0.0),
    links: vec![Link {
        weight: -0.46,
        target: Rc::clone(&output),
    }],
};

// update_targets函数实现
fn update_targets(neuron: &Neuron) {
    neuron.links.iter().for_each(|l| {
        *l.target.value.borrow_mut() = 1.0;
    })
}

Rc会自动跟踪引用计数，当所有引用都被销毁时，神经元才会被释放。这种方式适合共享所有权场景，但会带来轻微的运行时开销。

内容的提问来源于stack exchange，提问作者munHunger