pub struct Model { /* private fields */ }
Implementations§
source§impl Model
impl Model
sourcepub fn new(args: &str) -> Model
pub fn new(args: &str) -> Model
Examples found in repository?
examples/multithreaded.rs (line 10)
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117
fn main() {
let input = "太郎は次郎が持っている本を花子に渡した。";
// create model object
let model = Arc::new(Model::new(""));
let handle = std::thread::spawn(move || {
// create tagger based on the model
let tagger = model.create_tagger();
// create lattice object per thread
let mut lattice = model.create_lattice();
// get tagged result as string
lattice.set_sentence(input);
// parse lattice
tagger.parse(&lattice);
println!("{}", lattice.to_string());
// iterate over node objects
for node in lattice.bos_node().iter_next() {
match node.stat as i32 {
mecab::MECAB_BOS_NODE => {
print!("{} BOS ", node.id);
}
mecab::MECAB_EOS_NODE => {
print!("{} EOS ", node.id);
}
_ => {
print!("{} {} ", node.id, &(node.surface)[..(node.length as usize)]);
}
}
println!("{} {} {} {} {} {} {} {} {} {} {} {} {}",
node.feature,
input.len() as isize - node.surface.len() as isize,
input.len() as isize - node.surface.len() as isize + node.length as isize,
node.rcattr,
node.lcattr,
node.posid,
node.char_type,
node.stat,
node.isbest,
node.alpha,
node.beta,
node.prob,
node.cost);
}
// iterate over begin and end nodes
let len = lattice.size();
for i in 0..len + 1 {
let b = lattice.begin_nodes(i);
let e = lattice.end_nodes(i);
if let Some(nodes) = b {
for node in nodes.iter_bnext() {
println!("B[{}] {}\t{}", i, node.surface, node.feature);
}
}
if let Some(nodes) = e {
for node in nodes.iter_enext() {
println!("E[{}] {}\t{}", i, node.surface, node.feature);
}
}
}
// get N best results
lattice.set_request_type(mecab::MECAB_NBEST);
lattice.set_sentence(input);
tagger.parse(&lattice);
for i in 0..10 {
println!("NBEST: {}", i);
println!("{}", lattice.to_string());
if !lattice.next() {
break;
}
}
// marginal probabilities
lattice.remove_request_type(mecab::MECAB_NBEST);
lattice.set_request_type(mecab::MECAB_MARGINAL_PROB);
lattice.set_sentence(input);
tagger.parse(&lattice);
println!("{}", lattice.theta());
for node in lattice.bos_node().iter_next() {
println!("{}\t{}\t{}",
&(node.surface)[..(node.length as usize)],
node.feature,
node.prob);
}
// dictionary info
for dict in model.dictionary_info().iter() {
println!("\nfilename: {}", dict.filename);
println!("charset: {}", dict.charset);
println!("size: {}", dict.size);
println!("type: {}", dict.dict_type);
println!("lsize: {}", dict.lsize);
println!("rsize: {}", dict.rsize);
println!("version: {}", dict.version);
}
});
handle.join().unwrap();
}
sourcepub fn create_tagger(&self) -> Tagger
pub fn create_tagger(&self) -> Tagger
Examples found in repository?
examples/multithreaded.rs (line 14)
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117
fn main() {
let input = "太郎は次郎が持っている本を花子に渡した。";
// create model object
let model = Arc::new(Model::new(""));
let handle = std::thread::spawn(move || {
// create tagger based on the model
let tagger = model.create_tagger();
// create lattice object per thread
let mut lattice = model.create_lattice();
// get tagged result as string
lattice.set_sentence(input);
// parse lattice
tagger.parse(&lattice);
println!("{}", lattice.to_string());
// iterate over node objects
for node in lattice.bos_node().iter_next() {
match node.stat as i32 {
mecab::MECAB_BOS_NODE => {
print!("{} BOS ", node.id);
}
mecab::MECAB_EOS_NODE => {
print!("{} EOS ", node.id);
}
_ => {
print!("{} {} ", node.id, &(node.surface)[..(node.length as usize)]);
}
}
println!("{} {} {} {} {} {} {} {} {} {} {} {} {}",
node.feature,
input.len() as isize - node.surface.len() as isize,
input.len() as isize - node.surface.len() as isize + node.length as isize,
node.rcattr,
node.lcattr,
node.posid,
node.char_type,
node.stat,
node.isbest,
node.alpha,
node.beta,
node.prob,
node.cost);
}
// iterate over begin and end nodes
let len = lattice.size();
for i in 0..len + 1 {
let b = lattice.begin_nodes(i);
let e = lattice.end_nodes(i);
if let Some(nodes) = b {
for node in nodes.iter_bnext() {
println!("B[{}] {}\t{}", i, node.surface, node.feature);
}
}
if let Some(nodes) = e {
for node in nodes.iter_enext() {
println!("E[{}] {}\t{}", i, node.surface, node.feature);
}
}
}
// get N best results
lattice.set_request_type(mecab::MECAB_NBEST);
lattice.set_sentence(input);
tagger.parse(&lattice);
for i in 0..10 {
println!("NBEST: {}", i);
println!("{}", lattice.to_string());
if !lattice.next() {
break;
}
}
// marginal probabilities
lattice.remove_request_type(mecab::MECAB_NBEST);
lattice.set_request_type(mecab::MECAB_MARGINAL_PROB);
lattice.set_sentence(input);
tagger.parse(&lattice);
println!("{}", lattice.theta());
for node in lattice.bos_node().iter_next() {
println!("{}\t{}\t{}",
&(node.surface)[..(node.length as usize)],
node.feature,
node.prob);
}
// dictionary info
for dict in model.dictionary_info().iter() {
println!("\nfilename: {}", dict.filename);
println!("charset: {}", dict.charset);
println!("size: {}", dict.size);
println!("type: {}", dict.dict_type);
println!("lsize: {}", dict.lsize);
println!("rsize: {}", dict.rsize);
println!("version: {}", dict.version);
}
});
handle.join().unwrap();
}
sourcepub fn create_lattice(&self) -> Lattice
pub fn create_lattice(&self) -> Lattice
Examples found in repository?
examples/multithreaded.rs (line 17)
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117
fn main() {
let input = "太郎は次郎が持っている本を花子に渡した。";
// create model object
let model = Arc::new(Model::new(""));
let handle = std::thread::spawn(move || {
// create tagger based on the model
let tagger = model.create_tagger();
// create lattice object per thread
let mut lattice = model.create_lattice();
// get tagged result as string
lattice.set_sentence(input);
// parse lattice
tagger.parse(&lattice);
println!("{}", lattice.to_string());
// iterate over node objects
for node in lattice.bos_node().iter_next() {
match node.stat as i32 {
mecab::MECAB_BOS_NODE => {
print!("{} BOS ", node.id);
}
mecab::MECAB_EOS_NODE => {
print!("{} EOS ", node.id);
}
_ => {
print!("{} {} ", node.id, &(node.surface)[..(node.length as usize)]);
}
}
println!("{} {} {} {} {} {} {} {} {} {} {} {} {}",
node.feature,
input.len() as isize - node.surface.len() as isize,
input.len() as isize - node.surface.len() as isize + node.length as isize,
node.rcattr,
node.lcattr,
node.posid,
node.char_type,
node.stat,
node.isbest,
node.alpha,
node.beta,
node.prob,
node.cost);
}
// iterate over begin and end nodes
let len = lattice.size();
for i in 0..len + 1 {
let b = lattice.begin_nodes(i);
let e = lattice.end_nodes(i);
if let Some(nodes) = b {
for node in nodes.iter_bnext() {
println!("B[{}] {}\t{}", i, node.surface, node.feature);
}
}
if let Some(nodes) = e {
for node in nodes.iter_enext() {
println!("E[{}] {}\t{}", i, node.surface, node.feature);
}
}
}
// get N best results
lattice.set_request_type(mecab::MECAB_NBEST);
lattice.set_sentence(input);
tagger.parse(&lattice);
for i in 0..10 {
println!("NBEST: {}", i);
println!("{}", lattice.to_string());
if !lattice.next() {
break;
}
}
// marginal probabilities
lattice.remove_request_type(mecab::MECAB_NBEST);
lattice.set_request_type(mecab::MECAB_MARGINAL_PROB);
lattice.set_sentence(input);
tagger.parse(&lattice);
println!("{}", lattice.theta());
for node in lattice.bos_node().iter_next() {
println!("{}\t{}\t{}",
&(node.surface)[..(node.length as usize)],
node.feature,
node.prob);
}
// dictionary info
for dict in model.dictionary_info().iter() {
println!("\nfilename: {}", dict.filename);
println!("charset: {}", dict.charset);
println!("size: {}", dict.size);
println!("type: {}", dict.dict_type);
println!("lsize: {}", dict.lsize);
println!("rsize: {}", dict.rsize);
println!("version: {}", dict.version);
}
});
handle.join().unwrap();
}
pub fn swap(&self, model: &Model) -> bool
sourcepub fn dictionary_info(&self) -> DictionaryInfo
pub fn dictionary_info(&self) -> DictionaryInfo
Examples found in repository?
examples/multithreaded.rs (line 105)
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117
fn main() {
let input = "太郎は次郎が持っている本を花子に渡した。";
// create model object
let model = Arc::new(Model::new(""));
let handle = std::thread::spawn(move || {
// create tagger based on the model
let tagger = model.create_tagger();
// create lattice object per thread
let mut lattice = model.create_lattice();
// get tagged result as string
lattice.set_sentence(input);
// parse lattice
tagger.parse(&lattice);
println!("{}", lattice.to_string());
// iterate over node objects
for node in lattice.bos_node().iter_next() {
match node.stat as i32 {
mecab::MECAB_BOS_NODE => {
print!("{} BOS ", node.id);
}
mecab::MECAB_EOS_NODE => {
print!("{} EOS ", node.id);
}
_ => {
print!("{} {} ", node.id, &(node.surface)[..(node.length as usize)]);
}
}
println!("{} {} {} {} {} {} {} {} {} {} {} {} {}",
node.feature,
input.len() as isize - node.surface.len() as isize,
input.len() as isize - node.surface.len() as isize + node.length as isize,
node.rcattr,
node.lcattr,
node.posid,
node.char_type,
node.stat,
node.isbest,
node.alpha,
node.beta,
node.prob,
node.cost);
}
// iterate over begin and end nodes
let len = lattice.size();
for i in 0..len + 1 {
let b = lattice.begin_nodes(i);
let e = lattice.end_nodes(i);
if let Some(nodes) = b {
for node in nodes.iter_bnext() {
println!("B[{}] {}\t{}", i, node.surface, node.feature);
}
}
if let Some(nodes) = e {
for node in nodes.iter_enext() {
println!("E[{}] {}\t{}", i, node.surface, node.feature);
}
}
}
// get N best results
lattice.set_request_type(mecab::MECAB_NBEST);
lattice.set_sentence(input);
tagger.parse(&lattice);
for i in 0..10 {
println!("NBEST: {}", i);
println!("{}", lattice.to_string());
if !lattice.next() {
break;
}
}
// marginal probabilities
lattice.remove_request_type(mecab::MECAB_NBEST);
lattice.set_request_type(mecab::MECAB_MARGINAL_PROB);
lattice.set_sentence(input);
tagger.parse(&lattice);
println!("{}", lattice.theta());
for node in lattice.bos_node().iter_next() {
println!("{}\t{}\t{}",
&(node.surface)[..(node.length as usize)],
node.feature,
node.prob);
}
// dictionary info
for dict in model.dictionary_info().iter() {
println!("\nfilename: {}", dict.filename);
println!("charset: {}", dict.charset);
println!("size: {}", dict.size);
println!("type: {}", dict.dict_type);
println!("lsize: {}", dict.lsize);
println!("rsize: {}", dict.rsize);
println!("version: {}", dict.version);
}
});
handle.join().unwrap();
}
pub fn transition_cost(&self, rc_attr: u16, lc_attr: u16) -> i32
pub fn lookup(&self, begin: &str, len: u64, lattice: &Lattice) -> Option<Node>
Trait Implementations§
Auto Trait Implementations§
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more