bygpt-jp-multi-lm-head-6.5B-alpha

Name: bygpt-jp-multi-lm-head-6.5B-alpha
Author: tohoku-nlp

6.5B

1 language

byllama_patch

tohoku-nlp

Code Model

OTHER

6.5B params

New

2 downloads

Early-stage

Try on Hugging Face Add to Compare

Edge AI:

Mobile

Laptop

Server

15GB+ RAM

Mobile

Laptop

Server

Quick Summary

バイト単位のtokenizerを採用した，日本語言語モデルです。一度に4tokens (bytes) ずつ予測するための，複数のlmヘッドを持つアーキテクチャを採用しています。また，multi byte predictionに適した独自のUnicode encodingを採用しています。現在開発段階のモデルであり...

Device Compatibility

Mobile

4-6GB RAM

Laptop

16GB RAM

Server

GPU

Minimum Recommended

7GB+ RAM

Training Data Analysis

🟢 Excellent (8.0/10)

Researched training datasets used by bygpt-jp-multi-lm-head-6.5B-alpha with quality assessment

Specialized For

code

general

science

multilingual

Training Datasets (1)

the pile

🟢 8/10

code

general

science

multilingual

Key Strengths

•Deliberate Diversity: Explicitly curated to include diverse content types (academia, code, Q&A, book...
•Documented Quality: Each component dataset is thoroughly documented with rationale for inclusion, en...
•Epoch Weighting: Component datasets receive different training epochs based on perceived quality, al...

Explore our comprehensive training dataset analysis

View All Datasets

Code Examples

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

利用方法pythontransformers

import argparse

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


SAMPLE_INPUT_TEXTS = [
    "日本三景一覧:\n1. 広島県, 宮島\n2. 京都府, 天橋立\n3. 宮城県, ",
    "原文: I like to play soccer. 訳文: 私はサッカーをするのが好きです。\n原文: She enjoys reading books. 訳文: 彼女は本を読むのが好きです。\n原文: They went to the park. 訳文:",
]

def main(args):
    torch.manual_seed(args.seed)
    device = torch.device("cuda")

    tokenizer = AutoTokenizer.from_pretrained(
        args.model_name_or_path,
        trust_remote_code=True,
    )
    model = AutoModelForCausalLM.from_pretrained(
        args.model_name_or_path,
        dtype=torch.bfloat16,
        trust_remote_code=True,
    )
    model.to(device)
    model.eval()

    input_texts = [f"{tokenizer.bos_token}{text}" for text in SAMPLE_INPUT_TEXTS]
    batch = tokenizer(
        input_texts, return_tensors="pt", padding="longest", add_special_tokens=False
    )
    batch = batch.to(device)
    decoded_ids = model.generate(
        input_ids=batch.input_ids,
        attention_mask=batch.attention_mask,
        eos_token_id=[tokenizer.encode("\n", add_special_tokens=False)],
        pad_token_id=tokenizer.pad_token_id,
        max_new_tokens=args.max_new_tokens,
        do_sample=False,
    )
    
    decoded_texts = tokenizer.batch_decode(decoded_ids, skip_special_tokens=False)
    for text in decoded_texts:
        print("===")
        print(f"Decoded: {text}")
        

if __name__ == "__main__":
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument(
        "--model_name_or_path",
        "-m",
        type=str,
        default="tohoku-nlp/bygpt-jp-multi-lm-head-6.5B-alpha",
        help="Path to the model or model identifier from huggingface.co/models."
    )
    parser.add_argument("--max_new_tokens", "-n", type=int, help="Maximum number of new tokens to generate.", default=160)
    parser.add_argument("--seed", "-s", type=int, help="Random seed", default=42)
    args = parser.parse_args()
    main(args)

Deploy This Model

Production-ready deployment in minutes

Together.ai

Instant API access to this model

Fastest API

Production-ready inference API. Start free, scale to millions.

Try Free API

Replicate

One-click model deployment

Easiest Setup

Run models in the cloud with simple API. No DevOps required.

Deploy Now

Disclosure: We may earn a commission from these partners. This helps keep LLMYourWay free.