Quantization made by Richard Erkhov.

Github

Discord

Request more models

NuExtract-tiny-v1.5 - GGUF

• Model creator: https://huggingface.co/numind/
• Original model: https://huggingface.co/numind/NuExtract-tiny-v1.5/

Original model description:

• multilingual

• nlp

NuExtract-tiny-v1.5 by NuMind 🔥

NuExtract-tiny-v1.5 is a fine-tuning of Qwen/Qwen2.5-0.5B, trained on a private high-quality dataset for structured information extraction. It supports long documents and several languages (English, French, Spanish, German, Portuguese, and Italian).
To use the model, provide an input text and a JSON template describing the information you need to extract.

Note: This model is trained to prioritize pure extraction, so in most cases all text generated by the model is present as is in the original text.

We also provide a 3.8B version which is based on Phi-3.5-mini-instruct: NuExtract-v1.5

Check out the blog post.

Try the 3.8B model here: Playground

Benchmark

Zero-shot performance (English):

Few-shot fine-tuning:

Usage

To use the model:

import json
from transformers import AutoModelForCausalLM, AutoTokenizer

def predictNuExtract(model, tokenizer, texts, template, batchsize=1, maxlength=10000, maxnewtokens=4_000):
    template = json.dumps(json.loads(template), indent=4)
    prompts = [f"""<|input|>\n### Template:\n{template}\n### Text:\n{text}\n\n<|output|>""" for text in texts]

outputs = []
    with torch.no_grad():
        for i in range(0, len(prompts), batch_size):
            batchprompts = prompts[i:i+batchsize]
            batchencodings = tokenizer(batchprompts, returntensors="pt", truncation=True, padding=True, maxlength=max_length).to(model.device)

predids = model.generate(batchencodings, maxnewtokens=maxnewtokens)
            outputs += tokenizer.batchdecode(predids, skipspecialtokens=True)

return [output.split("<|output|>")[1] for output in outputs]

model_name = "numind/NuExtract-tiny-v1.5"
device = "cuda"
model = AutoModelForCausalLM.frompretrained(modelname, torchdtype=torch.bfloat16, trustremote_code=True).to(device).eval()
tokenizer = AutoTokenizer.frompretrained(modelname, trustremotecode=True)

text = """We introduce Mistral 7B, a 7–billion-parameter language model engineered for
superior performance and efficiency. Mistral 7B outperforms the best open 13B
model (Llama 2) across all evaluated benchmarks, and the best released 34B
model (Llama 1) in reasoning, mathematics, and code generation. Our model
leverages grouped-query attention (GQA) for faster inference, coupled with sliding
window attention (SWA) to effectively handle sequences of arbitrary length with a
reduced inference cost. We also provide a model fine-tuned to follow instructions,
Mistral 7B – Instruct, that surpasses Llama 2 13B – chat model both on human and
automated benchmarks. Our models are released under the Apache 2.0 license.
Code: <https://github.com/mistralai/mistral-src>
Webpage: <https://mistral.ai/news/announcing-mistral-7b/>"""

template = """{
    "Model": {
        "Name": "",
        "Number of parameters": "",
        "Number of max token": "",
        "Architecture": []
    },
    "Usage": {
        "Use case": [],
        "Licence": ""
    }
}"""

prediction = predict_NuExtract(model, tokenizer, [text], template)[0]
print(prediction)

Sliding window prompting:

import json

MAXINPUTSIZE = 20_000
MAXNEWTOKENS = 6000

def cleanjsontext(text):
    text = text.strip()
    text = text.replace("\#", "#").replace("\&", "&")
    return text

def predict_chunk(text, template, current, model, tokenizer):
    current = cleanjsontext(current)

input_llm =  f"<|input|>\n### Template:\n{template}\n### Current:\n{current}\n### Text:\n{text}\n\n<|output|>" + "{"
    inputids = tokenizer(inputllm, returntensors="pt", truncation=True, maxlength=MAXINPUTSIZE).to("cuda")
    output = tokenizer.decode(model.generate(inputids, maxnewtokens=MAXNEWTOKENS)[0], skipspecial_tokens=True)

return cleanjsontext(output.split("<|output|>")[1])

def splitdocument(document, windowsize, overlap):
    tokens = tokenizer.tokenize(document)
    print(f"\tLength of document: {len(tokens)} tokens")

chunks = []
    if len(tokens) > window_size:
        for i in range(0, len(tokens), window_size-overlap):
            print(f"\t{i} to {i + len(tokens[i:i + window_size])}")
            chunk = tokenizer.converttokenstostring(tokens[i:i + windowsize])
            chunks.append(chunk)

if i + len(tokens[i:i + window_size]) >= len(tokens):
                break
    else:
        chunks.append(document)
    print(f"\tSplit into {len(chunks)} chunks")

return chunks

def handlebrokenoutput(pred, prev):
    try:
        if all([(v in ["", []]) for v in json.loads(pred).values()]):
            # if empty json, return previous
            pred = prev
    except:
        # if broken json, return previous
        pred = prev

return pred

def slidingwindowprediction(text, template, model, tokenizer, window_size=4000, overlap=128):
    # split text into chunks of n tokens
    tokens = tokenizer.tokenize(text)
    chunks = splitdocument(text, windowsize, overlap)

# iterate over text chunks
    prev = template
    for i, chunk in enumerate(chunks):
        print(f"Processing chunk {i}...")
        pred = predict_chunk(chunk, template, prev, model, tokenizer)

# handle broken output
        pred = handlebrokenoutput(pred, prev)

# iterate
        prev = pred

return pred