norbert4-xlarge

import torch
from transformers import AutoTokenizer, AutoModelForMaskedLM

# Import model
tokenizer = AutoTokenizer.from_pretrained(
    "ltg/norbert4-xlarge"
)
model = AutoModelForMaskedLM.from_pretrained(
    "ltg/norbert4-xlarge",
    trust_remote_code=True
)

# Tokenize text (with a mask token inside)
input_text = tokenizer(
    f"Nå ønsker de seg en{tokenizer.mask_token} bolig.",
    return_tensors="pt"
)

# Inference
with torch.inference_mode:
    output_p = model(**input_text)

# Unmask the text
output_text = torch.where(
    input_text.input_ids == tokenizer.mask_token_id,
    output_p.logits.argmax(-1),
    input_text.input_ids
)

# Decoding; should output: '<s>Nå ønsker de seg en ny bolig.'
print(tokenizer.decode(output_text[0].tolist()))

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

# Import model
tokenizer = AutoTokenizer.from_pretrained(
    "ltg/norbert4-xlarge"
)
model = AutoModelForCausalLM.from_pretrained(
    "ltg/norbert4-xlarge",
    trust_remote_code=True
)

# Define zero-shot translation prompt template
prompt = """Engelsk: {0}
Bokmål:"""

# Define tokens that should end the generation (any token with a newline)
eos_token_ids = [
    token_id
    for token_id in range(tokenizer.vocab_size)
    if '\n' in tokenizer.decode([token_id])
]

# Generation function
@torch.inference_mode()
def generate(text):
    text = prompt.format(text)
    input_ids = tokenizer(text, return_tensors='pt').input_ids
    prediction = model.generate(
        input_ids,
        max_new_tokens=64,
        do_sample=False,
        eos_token_id=eos_token_ids
    )
    return tokenizer.decode(prediction[0, input_ids.size(1):]).strip()

# Example usage
generate("I'm a model that can generate text!")