chai/objectives/
default.rs

1use rustc_hash::FxHashMap;
2
3use super::cache::缓存;
4use super::metric::默认指标;
5use super::目标函数;
6use crate::config::部分权重;
7use crate::contexts::default::{默认上下文, 默认决策, 默认决策变化, 默认决策空间};
8use crate::encoders::编码器;
9use crate::错误;
10use crate::{指法向量, 编码信息, 键位分布损失函数};
11
12#[derive(Clone)]
13pub struct 默认目标函数<E: 编码器> {
14    pub 决策空间: 默认决策空间,
15    pub 参数: 默认目标函数参数,
16    pub 编码器: E,
17    pub 编码结果: Vec<编码信息>,
18    pub 计数桶列表: Vec<[Option<缓存>; 2]>,
19}
20
21#[derive(Clone)]
22pub struct 默认目标函数参数 {
23    pub 键位分布信息: Vec<键位分布损失函数>,
24    pub 当量信息: Vec<f64>,
25    pub 指法计数: Vec<指法向量>,
26    pub 数字转键: FxHashMap<u64, char>,
27    pub 正则化强度: f64,
28}
29
30pub type Frequencies = Vec<f64>;
31
32pub enum PartialType {
33    CharactersFull,
34    CharactersShort,
35    WordsFull,
36    WordsShort,
37}
38
39impl PartialType {
40    pub fn is_characters(&self) -> bool {
41        matches!(self, Self::CharactersFull | Self::CharactersShort)
42    }
43}
44
45/// 目标函数
46impl<E: 编码器<决策 = 默认决策>> 默认目标函数<E> {
47    /// 通过传入配置表示、编码器和共用资源来构造一个目标函数
48    pub fn 新建(上下文: &默认上下文, 编码器: E) -> Result<Self, 错误> {
49        let 键位分布信息 = 上下文.棱镜.预处理键位分布信息(&上下文.键位分布信息);
50        let 线性表长度 = 上下文.线性表长度();
51        let 当量信息 = 上下文.棱镜.预处理当量信息(&上下文.当量信息, 线性表长度);
52        let 指法计数 = 上下文.棱镜.预处理指法标记(线性表长度);
53        let config = 上下文
54            .配置
55            .optimization
56            .as_ref()
57            .ok_or("优化配置不存在")?
58            .objective
59            .clone();
60        let 最大编码 = 当量信息.len() as u64;
61        let 构造缓存 =
62            |x: &部分权重| 缓存::new(x, 上下文.棱镜.进制, 上下文.词列表.len(), 最大编码);
63        let 一字全码 = config.characters_full.as_ref().map(构造缓存);
64        let 一字简码 = config.characters_short.as_ref().map(构造缓存);
65        let 多字全码 = config.words_full.as_ref().map(构造缓存);
66        let 多字简码 = config.words_short.as_ref().map(构造缓存);
67        let 计数桶列表 = vec![[一字全码, 一字简码], [多字全码, 多字简码]];
68        let 参数 = 默认目标函数参数 {
69            键位分布信息,
70            当量信息,
71            指法计数,
72            数字转键: 上下文.棱镜.数字转键.clone(),
73            正则化强度: config.regularization_strength.unwrap_or(1.0),
74        };
75        let 编码结果: Vec<_> = 上下文.词列表.iter().map(编码信息::new).collect();
76        Ok(Self {
77            参数,
78            编码器,
79            编码结果: 编码结果.clone(),
80            计数桶列表: 计数桶列表.clone(),
81            决策空间: 上下文.决策空间.clone(),
82        })
83    }
84
85    pub fn 计算复杂度(&self, 决策: &默认决策) -> f64 {
86        let mut 复杂度 = 0.0;
87        for (序号, 安排列表) in self.决策空间.元素.iter().enumerate() {
88            let 安排 = &决策.元素[序号];
89            let mut 分值 = 0.0;
90            for 条件安排 in 安排列表 {
91                if &条件安排.安排 == 安排 {
92                    分值 = 条件安排.分数;
93                    break;
94                }
95            }
96            复杂度 += 分值;
97        }
98        复杂度
99    }
100}
101
102impl<E: 编码器<决策 = 默认决策>> 目标函数 for 默认目标函数<E> {
103    type 目标值 = 默认指标;
104    type 决策 = 默认决策;
105
106    /// 计算各个部分编码的指标，然后将它们合并成一个指标输出
107    fn 计算(
108        &mut self, 决策: &默认决策, 决策变化: &Option<默认决策变化>
109    ) -> (默认指标, f64) {
110        let 参数 = &self.参数;
111        self.编码器.编码(决策, 决策变化, &mut self.编码结果);
112        let mut 桶序号列表: Vec<_> = self.计数桶列表.iter().map(|_| 0).collect();
113        // 开始计算指标
114        for 编码信息 in self.编码结果.iter_mut() {
115            let 频率 = 编码信息.频率;
116            let 桶索引 = if 编码信息.词长 == 1 { 0 } else { 1 };
117            let 桶 = &mut self.计数桶列表[桶索引];
118            let 桶序号 = 桶序号列表[桶索引];
119            if let Some(缓存) = &mut 桶[0] {
120                缓存.处理(桶序号, 频率, &mut 编码信息.全码, 参数);
121            }
122            if let Some(缓存) = &mut 桶[1] {
123                缓存.处理(桶序号, 频率, &mut 编码信息.简码, 参数);
124            }
125            桶序号列表[桶索引] += 1;
126        }
127
128        let mut 目标函数 = 0.0;
129        let mut 指标 = 默认指标 {
130            characters_full: None,
131            words_full: None,
132            characters_short: None,
133            words_short: None,
134            complexity: None,
135        };
136        for (桶索引, 桶) in self.计数桶列表.iter().enumerate() {
137            let _ = &桶[0].as_ref().map(|x| {
138                let (分组指标, 分组目标函数) = x.汇总(参数);
139                目标函数 += 分组目标函数;
140                if 桶索引 == 0 {
141                    指标.characters_full = Some(分组指标);
142                } else {
143                    指标.words_full = Some(分组指标);
144                }
145            });
146            let _ = &桶[1].as_ref().map(|x| {
147                let (分组指标, 分组目标函数) = x.汇总(参数);
148                目标函数 += 分组目标函数;
149                if 桶索引 == 0 {
150                    指标.characters_short = Some(分组指标);
151                } else {
152                    指标.words_short = Some(分组指标);
153                }
154            });
155        }
156        let 复杂度 = self.计算复杂度(决策);
157        指标.complexity = Some(复杂度);
158        目标函数 += 参数.正则化强度 * 复杂度;
159        (指标, 目标函数)
160    }
161}
chai/objectives/default.rs

chai/objectives/
default.rs
