进行了一些测试，迄今为止只发现它在一次处理一批数据时才能正常工作。
脚本中的max_size似乎也缩短了实际的built_batches,因此在测试中max_size的顺序是递减的。这里是：

import ctranslate2
import sentencepiece

pivot_lang = "en"
langs = ["tr"]
base_folder = "C:/Machine_Learning/NLP"
lang_pair = "middle_east"

ct2_model = ctranslate2.Translator(
        f"{base_folder}/models/{lang_pair}/ct2",
        device="cuda",
        compute_type="int8",
    )
source_sentence = sentencepiece.SentencePieceProcessor(
        f"{base_folder}/models/{lang_pair}/general_multi.model"
    )
target_sentence = sentencepiece.SentencePieceProcessor(
        f"{base_folder}/models/{lang_pair}/general_multi.model"
    )

def encode(src_sents, tgt_sents, tgt_lang, src_lang):
    if type(src_sents) == str:
        src_sents = [src_sents]
    if type(tgt_sents) == str:
        tgt_sents = [tgt_sents]

    src_sents = source_sentence.Encode(src_sents, out_type=str)

    tgt_sents = target_sentence.Encode(tgt_sents, out_type=str)

    return src_sents, tgt_sents

class Test():
    def __init__(self, src_lang, tgt_lang, batch_size, batch, batch_type = "tokens", max_size = 2048):

        self.src_lang = src_lang
        self.tgt_lang = tgt_lang
        self.batch_size = batch_size
        self.batch_type = batch_type
        self.batch = batch
        for x in range(len(self.batch)):
            new_x = [self.batch[x][y] for y in range(min(max_size, len(self.batch[x])))]
            self.batch[x] = new_x

    def run_test(self):
        src_token, tgt_token = encode(self.batch[0], self.batch[1], self.tgt_lang, self.src_lang)
        assert len(src_token) == len(tgt_token), "Source and target example count must be equal"
        src_token_amount = sum(len(x) for x in src_token)
        tgt_token_amount = sum(len(x) for x in tgt_token)
        try:
            results = ct2_model.score_batch(source=src_token, target=tgt_token, max_batch_size=self.batch_size, batch_type=self.batch_type)
        except Exception as e:

            print(f"----\nTest with {self.src_lang}-{self.tgt_lang} failed\nBatch size: {self.batch_size} of {self.batch_type}\nTotal tokens: src - {src_token_amount} tgt - {tgt_token_amount} \
\nExample count: {len(src_token)}\nERROR OUTPUT:", e)

            return
        simplified_perps = [x.log_probs for x in results]
        simplified_perps = [
            sum(abs(x) ** 2 for x in y) / len(y)
            for y in simplified_perps
        ]
        simplified_perps = sum(simplified_perps) / len(simplified_perps)


        print(f"----\nTEST WITH {self.src_lang}-{self.tgt_lang} PASSED\nBatch size: {self.batch_size} of {self.batch_type}\nTotal tokens: src - {src_token_amount}, tgt - {tgt_token_amount} \
\nExample count: {len(src_token)}\nPerplexity: {simplified_perps}\n----")

src, tgt = pivot_lang, langs[0]
source_file = "C:/TranslationData/flores200_dataset/dev/eng_Latn.dev"
target_file = "C:/TranslationData/flores200_dataset/dev/tur_Latn.dev"

built_batches = []
with (open(source_file, encoding="utf8") as src_file, open(target_file, encoding="utf8") as tgt_file):
    original = [line.replace("\n", "") for line in src_file.readlines()]
    references = [line.replace("\n", "") for line in tgt_file.readlines()]
    built_batches = [original, references]

Test(src, tgt, 2048, built_batches).run_test()
Test(src, tgt, 1000, built_batches, "examples").run_test()
Test(src, tgt, 4096, built_batches).run_test()
Test(src, tgt, 100, built_batches, "examples").run_test()
Test(src, tgt, 1, built_batches, "examples", ).run_test()
Test(src, tgt, 100, built_batches, "examples", 100).run_test()
Test(src, tgt, 2048, built_batches, "tokens", 10).run_test()
Test(src, tgt, 2048, built_batches, "examples", 2).run_test()
Test(src, tgt, 2, built_batches, "examples", 2).run_test()
Test(src, tgt, 2, built_batches, "examples", 1).run_test()