[PYTHON] Grenzwerte, die mit MeCab sofort analysiert werden können

Ich habe zufällig [Artikel] gesehen (https://qiita.com/Sak1361/items/2519f29af82ffe965652#mecab%E3%81%AE%E3%83%90%E3%82%B0%E5%AF%BE%E7%AD Das Memo, das ich überprüft habe, weil es in% 96 als Mecab-Fehler geschrieben wurde.

Fazit: ** 2.621.440 Zeichen ** ist das Limit

• Wenn ein Zeichen einfach mit 2 Bytes berechnet wird

Dies kann anhand des in [common.h] definierten Werts ** MAX_INPUT_BUFFER_SIZE ** (https://github.com/taku910/mecab/blob/3a07c4eefaffb4e7a0690a7f4e5e0263d3ddb8a3/mecab/rc).

#define NBEST_MAX 512
#define NODE_FREELIST_SIZE 512
#define PATH_FREELIST_SIZE 2048
#define MIN_INPUT_BUFFER_SIZE 8192
#define MAX_INPUT_BUFFER_SIZE (8192*640)
#define BUF_SIZE 8192

Es ist ersichtlich, dass es wahrscheinlich maximal 8192 x 640 Datenbytes empfängt. Mit anderen Worten, 8192 x 640/2 = ** 2.621.440 Zeichen **. das ist alles.

• Die Quelle ist MeCab, zitiert von dem auf github veröffentlichten Entwickler Taku Kudo ([Referenz](https: // github). .com / taku910 / mecab))

Bonus

• Danach ist es so etwas wie ** Befunde **, die sich die Quelle angesehen haben. Der einzige Prozess, der tatsächlich ** MAX_INPUT_BUFFER_SIZE ** verwendet, ist tagger.cpp. .cpp](https://github.com/taku910/mecab/blob/3a07c4eefaffb4e7a0690a7f4e5e0263d3ddb8a3/mecab/src/tagger.cpp): Auszug aus Zeile 1213-1276).

size_t ibufsize = std::min(MAX_INPUT_BUFFER_SIZE,
                             std::max(param.get<int>
                                            ("input-buffer-size"),
                                            MIN_INPUT_BUFFER_SIZE));

  const bool partial = param.get<bool>("partial");
  if (partial) {
    ibufsize *= 8;
  }

  MeCab::scoped_array<char> ibuf_data(new char[ibufsize]);
  char *ibuf = ibuf_data.get();

  MeCab::scoped_ptr<MeCab::Tagger> tagger(model->createTagger());

  if (!tagger.get()) {
    WHAT_ERROR("cannot create tagger");
  }

  for (size_t i = 0; i < rest.size(); ++i) {
    MeCab::istream_wrapper ifs(rest[i].c_str());
    if (!*ifs) {
      WHAT_ERROR("no such file or directory: " << rest[i]);
    }

    while (true) {
      if (!partial) {
        ifs->getline(ibuf, ibufsize);
      } else {
        std::string sentence;
        MeCab::scoped_fixed_array<char, BUF_SIZE> line;
        for (;;) {
          if (!ifs->getline(line.get(), line.size())) {
            ifs->clear(std::ios::eofbit|std::ios::badbit);
            break;
          }
          sentence += line.get();
          sentence += '\n';
          if (std::strcmp(line.get(), "EOS") == 0 || line[0] == '\0') {
            break;
          }
        }
        std::strncpy(ibuf, sentence.c_str(), ibufsize);
      }
      if (ifs->eof() && !ibuf[0]) {
        return false;
      }
      if (ifs->fail()) {
        std::cerr << "input-buffer overflow. "
                  << "The line is split. use -b #SIZE option." << std::endl;
        ifs->clear();
      }
      const char *r = (nbest >= 2) ? tagger->parseNBest(nbest, ibuf) :
          tagger->parse(ibuf);
      if (!r)  {
        WHAT_ERROR(tagger->what());
      }
      *ofs << r << std::flush;
    }
  }

  return EXIT_SUCCESS;

#undef WHAT_ERROR

Aus diesem Code ist ersichtlich, dass die Verarbeitung von MeCab.Tagger.parse () maximal ** MAX_INPUT_BUFFER_SIZE ** überschreitet. Als Nächstes string_buffer.h und [tagger.cpp]. /blob/3a07c4eefaffb4e7a0690a7f4e5e0263d3ddb8a3/mecab/src/tagger.cpp) Informationen zur Gitteranalyse. (string_buffer.h: Auszug aus den Zeilen 15-37)

bool StringBuffer::reserve(size_t length) {
  if (!is_delete_) {
    error_ = (size_ + length >= alloc_size_);
    return (!error_);
  }

  if (size_ + length >= alloc_size_) {
    if (alloc_size_ == 0) {
      alloc_size_ = DEFAULT_ALLOC_SIZE;
      ptr_ = new char[alloc_size_];
    }
    size_t len = size_ + length;
    do {
      alloc_size_ *= 2;
    } while (len >= alloc_size_);
    char *new_ptr = new char[alloc_size_];
    std::memcpy(new_ptr, ptr_, size_);
    delete [] ptr_;
    ptr_ = new_ptr;
  }

  return true;
}

Diese Reserve, die das Gebiet erwirbt, wird nur in tagger.cpp aufgerufen. (tagger.cpp: Auszug aus den Zeilen 733-741)

LatticeImpl::LatticeImpl(const Writer *writer)
    : sentence_(0), size_(0), theta_(kDefaultTheta), Z_(0.0),
      request_type_(MECAB_ONE_BEST),
      writer_(writer),
      ostrs_(0),
      allocator_(new Allocator<Node, Path>) {
  begin_nodes_.reserve(MIN_INPUT_BUFFER_SIZE);
  end_nodes_.reserve(MIN_INPUT_BUFFER_SIZE);
}

Und LatticeImpl wird (glaube ich) ausgeführt, wenn Lattice materialisiert wird. (tagger.cpp: 227-239 Auszug)

class LatticeImpl : public Lattice {
 public:
  explicit LatticeImpl(const Writer *writer = 0);
  ~LatticeImpl();

  // clear internal lattice
  void clear();

  bool is_available() const {
    return (sentence_ &&
            !begin_nodes_.empty() &&
            !end_nodes_.empty());
  }

Aus diesen Dingen ist ersichtlich, dass es in der Gitteranalyse keine Grenzen zu geben scheint, da es den Anschein hat, dass die Fläche von memcpy verdoppelt und erfasst wird, wenn der Speicher nicht ausreicht (natürlich sollte sie enden, wenn der Speicher verbraucht ist, aber vorher Es scheint bei MAX_INPUT_BUFFER_SIZE anzuhalten.

andere Referenzen

mecab.h: Definition von Strukturen wie Gitter usw. libmecab.cpp: [tagger.cpp](https:// /3a07c4eefaffb4e7a0690a7f4e5e0263d3ddb8a3/mecab/src/tagger.cpp) mutable_lattice () und die Definition von Funktionen, die dem Modell zugeordnet sind, wie mecab_model_new_lattice () usw.

END．