|
|
--- |
|
|
library_name: transformers |
|
|
base_model: |
|
|
- Qwen/Qwen3-0.6B |
|
|
--- |
|
|
|
|
|
# Model Overview |
|
|
This model is a multilingual Named Entity Recognition (NER) transformer designed for name |
|
|
and address entity extraction with Malaysian context. |
|
|
|
|
|
It supports the following languages: |
|
|
- English |
|
|
- Malay |
|
|
- Chinese |
|
|
- Tamil |
|
|
|
|
|
The model is built on top of Qwen3(Qwen3-0.6B) and uses a custom non-causal attention |
|
|
mechanism. |
|
|
|
|
|
## Predicted Classes |
|
|
- 0 : Non-entity token |
|
|
- 1 : Name entity |
|
|
- 2 : Address entity |
|
|
|
|
|
## Transformer Inference Example |
|
|
```python |
|
|
from transformers import AutoTokenizer, Qwen3ForTokenClassification, AttentionInterface |
|
|
from typing import Optional |
|
|
|
|
|
def register_fa_attention(): |
|
|
from flash_attn import flash_attn_func, flash_attn_varlen_func |
|
|
|
|
|
def custom_attention_forward( |
|
|
module: AttentionInterface, |
|
|
query: torch.Tensor, |
|
|
key: torch.Tensor, |
|
|
value: torch.Tensor, |
|
|
attention_mask: Optional[torch.Tensor] = None, |
|
|
**kwargs, |
|
|
): |
|
|
cu_seqlens_q = kwargs.get("cu_seqlens_q", None) |
|
|
cu_seqlens_k = kwargs.get("cu_seqlens_k", None) |
|
|
max_seqlen_q = kwargs.get("max_seqlen_q", None) |
|
|
max_seqlen_k = kwargs.get("max_seqlen_k", None) |
|
|
# permute query, key, value to (batch, seq_len, n_heads, head_dim) |
|
|
query_permute = query.permute(0, 2, 1, 3) |
|
|
key_permute = key.permute(0, 2, 1, 3) |
|
|
value_permute = value.permute(0, 2, 1, 3) |
|
|
|
|
|
if cu_seqlens_q is not None and cu_seqlens_k is not None: |
|
|
attn_output = flash_attn_varlen_func( |
|
|
q=query_permute.squeeze(0), |
|
|
k=key_permute.squeeze(0), |
|
|
v=value_permute.squeeze(0), |
|
|
cu_seqlens_q=cu_seqlens_q, |
|
|
cu_seqlens_k=cu_seqlens_k, |
|
|
max_seqlen_q=max_seqlen_q, |
|
|
max_seqlen_k=max_seqlen_k, |
|
|
causal=False, |
|
|
) |
|
|
else: |
|
|
attn_output = flash_attn_func( |
|
|
query_permute, key_permute, value_permute, |
|
|
causal=False, |
|
|
) |
|
|
return attn_output , None |
|
|
|
|
|
AttentionInterface.register("fa_noncausal", custom_attention_forward) |
|
|
|
|
|
# Register custom non-causal FA (Feel free to use FA2/FA3), required GPU |
|
|
register_fa_attention() |
|
|
|
|
|
def tokenize_sentence_to_word(sentence:str ): |
|
|
tokens = [] |
|
|
chinese_char_pattern = re.compile(r'[\u4e00-\u9fff]') |
|
|
# Split text by spaces first |
|
|
parts = sentence.split() |
|
|
for part in parts: |
|
|
if chinese_char_pattern.search(part): |
|
|
# Character-level tokenization for Chinese |
|
|
tokens.extend(list(part)) |
|
|
else: |
|
|
# Word-level tokenization for other languages |
|
|
tokens.append(part) |
|
|
return tokens |
|
|
|
|
|
tokenizer = AutoTokenizer.from_pretrained("Scicom-intl/multilingual-dynamic-entity-decoder") |
|
|
model = Qwen3ForTokenClassification.from_pretrained( |
|
|
"Scicom-intl/multilingual-dynamic-entity-decoder", |
|
|
attn_implementation="fa_noncausal", |
|
|
dtype=torch.bfloat16, |
|
|
device_map={"":"cuda:0"} |
|
|
) |
|
|
|
|
|
word_token = tokenize_sentence_to_word("Hi, my name is Alex and I'm from Perlis") |
|
|
token = tokenizer( |
|
|
word_token, |
|
|
is_split_into_words=True, |
|
|
return_tensors="pt" |
|
|
).to(model.device) |
|
|
|
|
|
with toch.no_grad(): |
|
|
output = model(**inputs) |
|
|
prediction = output.logits.argmax(dim=-1) |
|
|
print(prediction) |
|
|
``` |
|
|
|
|
|
## Evaluation Result |
|
|
- F1 macro: 0.81 |
