How to Efficiently Solve Low Accuracy and High Cost Issues in Japanese Text Generation with T5

# Traditional approach
classification_model = load_bert_classifier()      # For document classification
summarization_model = load_summarization_model()   # For summarization
title_generation_model = load_title_model()        # For title generation

# Problems:
# - Managing 3 separate models
# - 3x memory usage
# - High development and maintenance costs

pip install torch transformers pytorch_lightning sentencepiece

from transformers import T5ForConditionalGeneration, T5Tokenizer

# Load Japanese T5 model
MODEL_NAME = "sonoisa/t5-base-japanese"
tokenizer = T5Tokenizer.from_pretrained(MODEL_NAME, is_fast=True)
model = T5ForConditionalGeneration.from_pretrained(MODEL_NAME)

def generate_text(task_prefix, input_text, max_length=128):
    # Input with task specification
    input_text = f"{task_prefix}: {input_text}"
    
    # Tokenization
    input_ids = tokenizer.encode(input_text, return_tensors="pt", max_length=512, truncation=True)
    
    # Text generation
    output_ids = model.generate(
        input_ids,
        max_length=max_length,
        temperature=1.0,
        repetition_penalty=2.0,
        do_sample=True
    )
    
    # Decoding
    output_text = tokenizer.decode(output_ids[0], skip_special_tokens=True)
    return output_text

# Document summarization
summary = generate_text("要約", "Long document content...")

# Title generation  
title = generate_text("タイトル生成", "Article body text...")

# Document classification
category = generate_text("分類", "Document to classify...")

from torch.utils.data import Dataset

class TsvDataset(Dataset):
    def __init__(self, tokenizer, data_path, input_max_len=512, target_max_len=128):
        self.tokenizer = tokenizer
        self.input_max_len = input_max_len
        self.target_max_len = target_max_len
        self.inputs = []
        self.targets = []
        self._load_data(data_path)
    
    def _load_data(self, data_path):
        with open(data_path, "r", encoding="utf-8") as f:
            for line in f:
                target, input_text = line.strip().split("\t")
                
                # Input format with task specification
                input_text = f"要約: {input_text}"
                
                # Tokenization
                tokenized_input = self.tokenizer.encode_plus(
                    input_text,
                    max_length=self.input_max_len,
                    padding="max_length",
                    truncation=True,
                    return_tensors="pt"
                )
                
                tokenized_target = self.tokenizer.encode_plus(
                    target,
                    max_length=self.target_max_len,
                    padding="max_length", 
                    truncation=True,
                    return_tensors="pt"
                )
                
                self.inputs.append(tokenized_input)
                self.targets.append(tokenized_target)

# Create dataset
train_dataset = TsvDataset(tokenizer, "train.tsv")

import pytorch_lightning as pl

class T5FineTuner(pl.LightningModule):
    def __init__(self, model_name, learning_rate=3e-4):
        super().__init__()
        self.model = T5ForConditionalGeneration.from_pretrained(model_name)
        self.tokenizer = T5Tokenizer.from_pretrained(model_name)
        self.learning_rate = learning_rate
    
    def forward(self, input_ids, attention_mask, labels=None):
        return self.model(
            input_ids=input_ids,
            attention_mask=attention_mask,
            labels=labels
        )
    
    def training_step(self, batch, batch_idx):
        input_ids = batch["input_ids"]
        attention_mask = batch["attention_mask"]
        labels = batch["labels"]
        
        outputs = self(input_ids, attention_mask, labels)
        loss = outputs.loss
        
        self.log("train_loss", loss)
        return loss
    
    def configure_optimizers(self):
        return torch.optim.AdamW(self.parameters(), lr=self.learning_rate)

# Execute training
model = T5FineTuner(MODEL_NAME)
trainer = pl.Trainer(max_epochs=8, gpus=1)
trainer.fit(model, train_dataloader)

def news_summarizer(article_text):
    # Generate multiple summary types
    short_summary = generate_text("短信要約", article_text, max_length=64)
    title = generate_text("タイトル生成", article_text, max_length=32)
    
    return {
        "summary": short_summary,
        "title": title
    }

# Usage example
article = "Long news article content..."
result = news_summarizer(article)
print(f"Title: {result['title']}")
print(f"Summary: {result['summary']}")

def document_processor(document):
    # Document classification
    category = generate_text("分類", document, max_length=16)
    
    # Category-specific summarization
    if "技術" in category:
        summary = generate_text("技術要約", document)
    elif "ビジネス" in category:
        summary = generate_text("ビジネス要約", document)
    else:
        summary = generate_text("一般要約", document)
    
    return {
        "category": category,
        "summary": summary
    }