ct2rs 0.8.2

Rust bindings for OpenNMT/CTranslate2
Documentation 
1
2
3
4
5
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

#include "ctranslate2/generator.h"

#include <spdlog/spdlog.h>

namespace ctranslate2 {

  std::vector<std::future<GenerationResult>>
  Generator::generate_batch_async(const std::vector<std::vector<std::string>>& start_tokens,
                                  const GenerationOptions& options,
                                  const size_t max_batch_size,
                                  const BatchType batch_type) {
    return post_examples<GenerationResult>(
      load_examples({start_tokens}),
      max_batch_size,
      batch_type,
      [options](models::SequenceGeneratorReplica& generator, const Batch& batch) {
        spdlog::debug("Running batch generation on {} examples", batch.num_examples());
        auto results = generator.generate(
          batch.get_stream(0),
          restore_batch_ids_in_callback(options, batch.example_index));
        spdlog::debug("Finished batch generation");
        return results;
      });
  }

  std::vector<std::future<ScoringResult>>
  Generator::score_batch_async(const std::vector<std::vector<std::string>>& tokens,
                               const ScoringOptions& options,
                               const size_t max_batch_size,
                               const BatchType batch_type) {
    return post_examples<ScoringResult>(
      load_examples({tokens}),
      max_batch_size,
      batch_type,
      [options](models::SequenceGeneratorReplica& generator, const Batch& batch) {
        spdlog::debug("Running batch scoring on {} examples", batch.num_examples());
        auto results = generator.score(batch.get_stream(0), options);
        spdlog::debug("Finished batch scoring");
        return results;
      });
  }

  std::future<StorageView>
  Generator::forward_batch_async(std::vector<std::vector<std::string>> tokens,
                                 const bool return_log_probs) {
    return post<StorageView>(
      [tokens = std::move(tokens), return_log_probs]
      (models::SequenceGeneratorReplica& generator) {
        return generator.forward(tokens, return_log_probs);
      });
  }

  std::future<StorageView>
  Generator::forward_batch_async(std::vector<std::vector<size_t>> ids,
                                 const bool return_log_probs) {
    return post<StorageView>(
      [ids = std::move(ids), return_log_probs]
      (models::SequenceGeneratorReplica& generator) {
        return generator.forward(ids, return_log_probs);
      });
  }

  std::future<StorageView>
  Generator::forward_batch_async(StorageView ids,
                                 StorageView lengths,
                                 const bool return_log_probs) {
    return post<StorageView>(
      [ids = std::move(ids), lengths = std::move(lengths), return_log_probs]
      (models::SequenceGeneratorReplica& generator) {
        return generator.forward(ids, lengths, return_log_probs);
      });
  }

}