Struct SerializableModel 

pub struct SerializableModel {

    pub feature_weights: Vec<f64>,
    pub labels: Vec<String>,
    pub pos_info: Vec<String>,
    pub metadata: ModelMetadata,
    pub connection_matrix: BTreeMap<usize, BTreeMap<usize, f64>>,
    pub max_left_id: usize,
    pub max_right_id: usize,
    pub feature_sets: Vec<FeatureSetInfo>,
    pub unk_category_names: Vec<String>,
    pub unk_categories: BTreeMap<String, String>,
    pub char_def_content: String,
    pub feature_def_content: String,
    pub rewrite_def_content: String,
    pub cost_factor: i32,
    pub left_id_map: Vec<(u32, String)>,
    pub right_id_map: Vec<(u32, String)>,
}

Trained model with weights and configuration.

Fields

feature_weights: Vec<f64>

Feature weights from CRF training

labels: Vec<String>

Label information

pos_info: Vec<String>

Part-of-speech information for each label

metadata: ModelMetadata

Model metadata

connection_matrix: BTreeMap<usize, BTreeMap<usize, f64>>

Connection cost matrix: (right_id, left_id) -> cost.

Ordered maps rather than hashed ones, at both levels. rkyv archives a HashMap as a SwissTable whose slot assignment resolves collisions in source iteration order, and HashMap iteration order is seeded per instance – so serializing the same trained model twice produced files of identical length with scattered byte differences (#974). A BTreeMap serializes from its key-ordered iterator into a tree whose shape depends only on the entry count, which makes model.dat byte-reproducible. No stored value changes: both levels are only ever filled key-by-key from Vec-ordered sources.

max_left_id: usize

Maximum left connection ID

max_right_id: usize

Maximum right connection ID

feature_sets: Vec<FeatureSetInfo>

Feature set information (left_id, right_id, weight) for each label

unk_category_names: Vec<String>

Unknown word category names (from char.def)

unk_categories: BTreeMap<String, String>

Unknown word category features (from unk.def).

Ordered for the same reason as SerializableModel::connection_matrix: rkyv’s archived HashMap layout follows source iteration order (#974).

char_def_content: String

Raw content of the character definition file (char.def)

feature_def_content: String

Raw content of the feature definition file (feature.def)

rewrite_def_content: String

Raw content of the rewrite rule definition file (rewrite.def)

cost_factor: i32

Cost factor for weight-to-cost conversion (MeCab default: 700)

left_id_map: Vec<(u32, String)>

Left context ID to feature string mapping (for left-id.def)

right_id_map: Vec<(u32, String)>

Right context ID to feature string mapping (for right-id.def)

Implementations

impl SerializableModel

pub fn write_lexicon<W: Write>(&self, writer: &mut W) -> Result<()>

Write lexicon file with proper cost calculation

pub fn write_connection_costs<W: Write>(&self, writer: &mut W) -> Result<()>

Write dense connection cost matrix (MeCab-compatible)

pub fn update_metadata_json<W: Write>( &self, base_metadata_path: &Path, writer: &mut W, ) -> Result<()>

Update metadata.json with trained model values.

The emitted model_info section deliberately carries no timestamp, so exporting the same model twice produces byte-identical output (#981); serde_json’s map is ordered, so key order is stable too.

引数

• base_metadata_path - Path of the base metadata.json to update.
• writer - Write sink for the updated JSON.

pub fn write_unknown_dictionary<W: Write>(&self, writer: &mut W) -> Result<()>

Write unknown word definitions

pub fn write_char_def<W: Write>(&self, writer: &mut W) -> Result<()>

Writes the character definition file (char.def) content preserved from training.

pub fn write_feature_def<W: Write>(&self, writer: &mut W) -> Result<()>

Writes the feature definition file (feature.def) content preserved from training.

pub fn write_rewrite_def<W: Write>(&self, writer: &mut W) -> Result<()>

Writes the rewrite rule definition file (rewrite.def) content preserved from training.

pub fn write_left_id_def<W: Write>(&self, writer: &mut W) -> Result<()>

Writes left-id.def: maps left context IDs to their feature strings.

pub fn write_right_id_def<W: Write>(&self, writer: &mut W) -> Result<()>

Writes right-id.def: maps right context IDs to their feature strings.

Trait Implementations

impl Archive for SerializableModel

where Vec<f64>: Archive, Vec<String>: Archive, ModelMetadata: Archive, BTreeMap<usize, BTreeMap<usize, f64>>: Archive, usize: Archive, Vec<FeatureSetInfo>: Archive, BTreeMap<String, String>: Archive, String: Archive, i32: Archive, Vec<(u32, String)>: Archive,

const COPY_OPTIMIZATION: CopyOptimization<Self>

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

type Archived = ArchivedSerializableModel

The archived representation of this type.

type Resolver = SerializableModelResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>)

Creates the archived version of this value at the given position and writes it to the given output.

impl<'de> Deserialize<'de> for SerializableModel

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<__D: Fallible + ?Sized> Deserialize<SerializableModel, __D> for Archived<SerializableModel>

where Vec<f64>: Archive, <Vec<f64> as Archive>::Archived: Deserialize<Vec<f64>, __D>, Vec<String>: Archive, <Vec<String> as Archive>::Archived: Deserialize<Vec<String>, __D>, ModelMetadata: Archive, <ModelMetadata as Archive>::Archived: Deserialize<ModelMetadata, __D>, BTreeMap<usize, BTreeMap<usize, f64>>: Archive, <BTreeMap<usize, BTreeMap<usize, f64>> as Archive>::Archived: Deserialize<BTreeMap<usize, BTreeMap<usize, f64>>, __D>, usize: Archive, <usize as Archive>::Archived: Deserialize<usize, __D>, Vec<FeatureSetInfo>: Archive, <Vec<FeatureSetInfo> as Archive>::Archived: Deserialize<Vec<FeatureSetInfo>, __D>, BTreeMap<String, String>: Archive, <BTreeMap<String, String> as Archive>::Archived: Deserialize<BTreeMap<String, String>, __D>, String: Archive, <String as Archive>::Archived: Deserialize<String, __D>, i32: Archive, <i32 as Archive>::Archived: Deserialize<i32, __D>, Vec<(u32, String)>: Archive, <Vec<(u32, String)> as Archive>::Archived: Deserialize<Vec<(u32, String)>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<SerializableModel, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl Serialize for SerializableModel

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<__S: Fallible + ?Sized> Serialize<__S> for SerializableModel

where Vec<f64>: Serialize<__S>, Vec<String>: Serialize<__S>, ModelMetadata: Serialize<__S>, BTreeMap<usize, BTreeMap<usize, f64>>: Serialize<__S>, usize: Serialize<__S>, Vec<FeatureSetInfo>: Serialize<__S>, BTreeMap<String, String>: Serialize<__S>, String: Serialize<__S>, i32: Serialize<__S>, Vec<(u32, String)>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Self as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.