Jellyfish 7B

🚀 Jellyfish-7B

Jellyfish-7B is a large language model with 7 billion parameters, fine - tuned from Mistral-7B-Instruct-v0.2, offering strong performance in data preprocessing tasks.

Jellyfish models with other sizes are available here:
Jellyfish-8B
Jellyfish-13B

🚀 Quick Start

To accelerate the inference, we strongly recommend running Jellyfish using vLLM.

Python Script

We provide two simple Python code examples for inference using the Jellyfish model.

Using Transformers and Torch Modules

from transformers import AutoModelForCausalLM, AutoTokenizer, GenerationConfig
import torch

if torch.cuda.is_available():
    device = "cuda"
else:
    device = "cpu"

# Model will be automatically downloaded from HuggingFace model hub if not cached.
# Model files will be cached in "~/.cache/huggingface/hub/models--NECOUDBFM--Jellyfish/" by default.
# You can also download the model manually and replace the model name with the path to the model files.
model = AutoModelForCausalLM.from_pretrained(
    "NECOUDBFM/Jellyfish",
    torch_dtype=torch.float16,
    device_map="auto",
)
tokenizer = AutoTokenizer.from_pretrained("NECOUDBFM/Jellyfish")

system_message = "You are an AI assistant that follows instruction extremely well. Help as much as you can."

# You need to define the user_message variable based on the task and the data you want to test on.
user_message = "Hello, world."

prompt = f"{system_message}\n\n[INST]:\n\n{user_message}\n\n[\INST]]"
inputs = tokenizer(prompt, return_tensors="pt")
input_ids = inputs["input_ids"].to(device)

# You can modify the sampling parameters according to your needs.
generation_config = GenerationConfig(
    do_samples=True,
    temperature=0.35,
    top_p=0.9,
)

with torch.no_grad():
    generation_output = model.generate(
        input_ids=input_ids,
        generation_config=generation_config,
        return_dict_in_generate=True,
        output_scores=True,
        max_new_tokens=1024,
        pad_token_id=tokenizer.eos_token_id,
        repetition_penalty=1.15,
    )

output = generation_output[0]
response = tokenizer.decode(
    output[:, input_ids.shape[-1] :][0], skip_special_tokens=True
).strip()

print(response)

Using vLLM

from vllm import LLM, SamplingParams

# To use vllm for inference, you need to download the model files either using HuggingFace model hub or manually.
# You should modify the path to the model according to your local environment.
path_to_model = (
    "/workspace/models/Jellyfish"
)

model = LLM(model=path_to_model)

# You can modify the sampling parameters according to your needs.
# Caution: The stop parameter should not be changed.
sampling_params = SamplingParams(
    temperature=0.35,
    top_p=0.9,
    max_tokens=1024,
    stop=["[INST]"],
)

system_message = "You are an AI assistant that follows instruction extremely well. Help as much as you can."

# You need to define the user_message variable based on the task and the data you want to test on.
user_message = "Hello, world."

prompt = f"{system_message}\n\n[INST]:\n\n{user_message}\n\n[\INST]]"
outputs = model.generate(prompt, sampling_params)
response = outputs[0].outputs[0].text.strip()
print(response)

✨ Features

• Fine - tuned Model: Jellyfish-7B is fine - tuned from mistralai/Mistral-7B-Instruct-v0.2 using a subset of the Jellyfish-Instruct dataset.
• Interpretability: The winning rate of Jellyfish-7B against GPT-3.5-turbo (evaluated by GPT-4) is 56.36%.
• Multiple Task Performance: It shows good performance in various data preprocessing tasks such as error detection, data imputation, schema matching, entity matching, column type annotation, and attribute value extraction.

📚 Documentation

Model Details

• Developed by: Haochen Zhang, Yuyang Dong, Chuan Xiao, Masafumi Oyamada
• Contact: dongyuyang@nec.com
• Funded by: NEC Corporation, Osaka University
• Language(s) (NLP): English
• License: Non - Commercial Creative Commons license (CC BY - NC - 4.0)
• Finetuned from model: mistralai/Mistral-7B-Instruct-v0.2

More details about the model can be found in the Jellyfish paper.

Performance on seen tasks

For GPT-3.5 and GPT-4, we used the few-shot approach on all datasets. For Jellyfish models, the few-shot approach is disabled on seen datasets and enabled on unseen datasets.
Accuracy as the metric for data imputation and the F1 score for other tasks.

HoloDetect for Error Detection seen datasets
RAHA for Error Detection unseen datasets
IPM for Data Imputation SMAT for Schema Matching
Ditto for Entity Matching
2.
Large Language Models as Data Preprocessors

Performance on unseen tasks

Column Type Annotation

Few-shot is disabled for Jellyfish models.

1. Results from Column Type Annotation using ChatGPT

Attribute Value Extraction

Few-shot is disabled for Jellyfish models.

1. Results from Product Attribute Value Extraction using Large Language Models

Prompt Template

{system message}

[INST]:

{prompt} (without the {})

[\INST]]

Prompts

We provide the prompts used for both fine-tuning and inference. You can structure your data according to these prompts.

System Message

You are an AI assistant that follows instruction extremely well.
User will give you a question. Your task is to answer as faithfully as you can.

For Error Detection

There are two forms of the error detection task. In the first form, a complete record row is provided, and the task is to determine if a specific value is erroneous. In the second form, only the value of a specific attribute is given, and the decision about its correctness is based solely on the attribute's name and value. The subsequent prompt examples pertain to these two forms, respectively.

Your task is to determine if there is an error in the value of a specific attribute within the whole record provided.
The attributes may include {attribute 1}, {attribute 2}, ...
Errors may include, but are not limited to, spelling errors, inconsistencies, or values that don't make sense given the context of the whole record.
Record [{attribute 1}: {attribute 1 value}, {attribute 2}: {attribute 2 value}, ...]
Attribute for Verification: [{attribute X}: {attribute X value}]
Question: Is there an error in the value of {attribute X}? Choose your answer from: [Yes, No].

Your task is to determine if there is an error in the value of a specific attribute.
The attributes may belong to a {keyword} record and could be one of the following: {attribute 1}, {attribute 2}, ...
Errors can include, but are not limited to, spelling errors, inconsistencies, or values that don't make sense for that attribute.  
Note: Missing values (N/A or \"nan\") are not considered errors.
Attribute for Verification: [{attribute X}: {attribute X value}]
Question: Is there an error in the value of {attribute X}? Choose your answer from: [Yes, No].

For Data Imputation

You are presented with a {keyword} record that is missing a specific attribute: {attribute X}.
Your task is to deduce or infer the value of {attribute X} using the available information in the record.  
You may be provided with fields like {attribute 1}, {attribute 2}, ... to help you in the inference.  
Record: [{attribute 1}: {attribute 1 value}, {attribute 2}: {attribute 2 value}, ...]  
Based on the provided record, what would you infer is the value fo the {attribute X}?

Training Details

Training Method

We used LoRA to speed up the training process, targeting the q_proj, k_proj, v_proj, and o_proj modules.

📄 License

The model is released under a Non - Commercial Creative Commons license (CC BY - NC - 4.0).

Citation

If you find our work useful, please give us credit by citing:

@article{zhang2023jellyfish,
  title={Jellyfish: A Large Language Model for Data Preprocessing},
  author={Zhang, Haochen and Dong, Yuyang and Xiao, Chuan and Oyamada, Masafumi},
  journal={arXiv preprint arXiv:2312.01678},
  year={2023}
}