vector listlengths 1.02k 1.02k | text stringlengths 2 11.8k |
|---|---|
[
0.022115655,
0.0034565064,
-0.027382713,
-0.015726356,
-0.032350507,
-0.016220143,
-0.023492273,
0.009651285,
-0.014484408,
0.03543293,
0.017237643,
0.06176822,
-0.0031983908,
-0.03258992,
-0.009269722,
0.024180582,
-0.0024502291,
-0.024345178,
-0.03486433,
0.00025273833,
-0.... |
Evaluation
Evaluation for document question answering requires a significant amount of postprocessing. To avoid taking up too much
of your time, this guide skips the evaluation step. The [Trainer] still calculates the evaluation loss during training so
you're not completely in the dark about your model's performance.... |
[
0.03396829,
0.0028455113,
0.012041551,
-0.0045461487,
-0.011930399,
-0.05954825,
-0.017265731,
0.023623671,
-0.0058132904,
0.0784294,
0.0011041176,
0.00016626604,
0.027091637,
-0.017917829,
-0.036547035,
-0.012330549,
-0.034027573,
-0.055309623,
-0.040548533,
-0.0009827758,
-... |
# encode the batch of examples and initialize the start_positions and end_positions
encoding = tokenizer(questions, words, boxes, max_length=max_length, padding="max_length", truncation=True)
start_positions = []
end_positions = []
# loop through the examples in the batch
for i in range(... |
[
0.033119984,
-0.014419344,
0.042162985,
0.00900061,
0.0008742743,
-0.02927671,
0.00042057893,
0.00076388614,
-0.008612043,
0.029587563,
0.013133544,
0.012766171,
0.016998012,
-0.028612614,
-0.030463602,
0.014454668,
-0.03374169,
-0.030604899,
-0.075791635,
-0.007509928,
-0.01... | Now that we have this preprocessing function, we can encode the entire dataset:
encoded_train_dataset = dataset_with_ocr["train"].map(
encode_dataset, batched=True, batch_size=2, remove_columns=dataset_with_ocr["train"].column_names
)
encoded_test_dataset = dataset_with_ocr["test"].map(
encode_dataset, batc... |
[
0.023004482,
-0.010440711,
-0.02363302,
0.020769682,
-0.04849518,
-0.00054036785,
-0.025630374,
0.0188701,
-0.0066240896,
0.045841355,
0.012102844,
-0.027250603,
0.009057928,
-0.038047485,
-0.015950892,
0.03891347,
-0.024163784,
-0.012689479,
-0.036818344,
-0.03500257,
0.0074... | from transformers import AutoModelForDocumentQuestionAnswering
model = AutoModelForDocumentQuestionAnswering.from_pretrained(model_checkpoint) |
[
0.039388735,
0.02781774,
-0.0050752577,
0.019753555,
-0.050989326,
-0.03240471,
0.012273838,
-0.0049309903,
-0.0009812042,
0.043235872,
0.010734985,
0.030984227,
0.016868204,
-0.039832637,
-0.020596964,
0.03163528,
-0.0018680796,
-0.044537976,
-0.059068307,
0.00693224,
-0.033... | from transformers import TrainingArguments
REPLACE THIS WITH YOUR REPO ID
repo_id = "MariaK/layoutlmv2-base-uncased_finetuned_docvqa"
training_args = TrainingArguments(
output_dir=repo_id,
per_device_train_batch_size=4,
num_train_epochs=20,
save_steps=200,
logging_steps=50,
evaluation_stra... |
[
0.017387616,
0.00681804,
-0.017473692,
0.011025068,
-0.037300166,
-0.026913503,
0.0068825977,
-0.007373956,
0.0009809226,
0.039279945,
-0.005254302,
0.011010722,
0.030672213,
-0.024417263,
-0.004490366,
0.036984548,
0.022164905,
-0.009490023,
-0.062147815,
0.020845054,
0.0338... | In the [TrainingArguments] use output_dir to specify where to save your model, and configure hyperparameters as you see fit.
If you wish to share your model with the community, set push_to_hub to True (you must be signed in to Hugging Face to upload your model).
In this case the output_dir will also be the name of the ... |
[
0.0039768293,
0.004467173,
0.0077878074,
-0.008126722,
-0.021762595,
-0.034727853,
0.030199386,
0.010088095,
-0.0059165703,
0.054601185,
-0.007852706,
0.02450275,
0.009453533,
-0.008054612,
-0.019931018,
0.001964979,
-0.052928247,
-0.066052146,
-0.08399294,
0.00095634995,
-0.... | Define a simple data collator to batch examples together.
from transformers import DefaultDataCollator
data_collator = DefaultDataCollator()
Finally, bring everything together, and call [~Trainer.train]:
from transformers import Trainer
trainer = Trainer(
model=model,
args=training_args,
data_collator... |
[
0.028132664,
0.005234485,
-0.02076561,
-0.02273303,
-0.039463278,
-0.0072378065,
-0.015322896,
0.010576676,
0.01502132,
0.062497884,
0.025231797,
0.008537452,
-0.019789081,
-0.03182337,
-0.008020466,
0.05057848,
0.026351934,
-0.041962042,
-0.053450625,
-0.0104043465,
0.012974... | To add the final model to 🤗 Hub, create a model card and call push_to_hub:
trainer.create_model_card()
trainer.push_to_hub()
Inference
Now that you have finetuned a LayoutLMv2 model, and uploaded it to the 🤗 Hub, you can use it for inference. The simplest
way to try out your finetuned model for inference is to use ... |
[
0.046006575,
-0.012089374,
0.01889662,
-0.0063497107,
-0.008302609,
-0.0053714016,
-0.03011556,
0.012059615,
-0.014031113,
0.05073817,
0.02565179,
-0.002332319,
0.026499907,
0.0039020777,
-0.019030534,
0.012654784,
0.00636459,
-0.027615849,
0.010958552,
-0.02160464,
-0.019581... | example = dataset["test"][2]
question = example["query"]["en"]
image = example["image"]
print(question)
print(example["answers"])
'Who is ‘presiding’ TRRF GENERAL SESSION (PART 1)?'
['TRRF Vice President', 'lee a. waller']
Next, instantiate a pipeline for
document question answering with your model, and pass the image... |
[
0.059193455,
0.0029398869,
-0.016679892,
0.0038041202,
-0.0002050921,
-0.02398201,
-0.0010098278,
0.015485271,
-0.019233393,
0.042409036,
0.006066433,
-0.0024153737,
0.019890435,
-0.023683356,
-0.013865067,
0.04043791,
0.0071154595,
-0.0303583,
-0.027670402,
-0.0061709625,
-0... | Next, instantiate a pipeline for
document question answering with your model, and pass the image + question combination to it.
from transformers import pipeline
qa_pipeline = pipeline("document-question-answering", model="MariaK/layoutlmv2-base-uncased_finetuned_docvqa")
qa_pipeline(image, question)
[{'score': 0.99498... |
[
0.034458306,
-0.024320014,
-0.019131942,
0.005206653,
-0.02476598,
0.007455065,
-0.018344069,
-0.0011780935,
-0.025107887,
0.05767827,
0.009179467,
0.0024751113,
0.01114915,
-0.05295103,
-0.0093132565,
0.036063783,
0.0031645005,
-0.038026035,
-0.053159148,
-0.0007855505,
-0.0... |
import torch
from transformers import AutoProcessor
from transformers import AutoModelForDocumentQuestionAnswering
processor = AutoProcessor.from_pretrained("MariaK/layoutlmv2-base-uncased_finetuned_docvqa")
model = AutoModelForDocumentQuestionAnswering.from_pretrained("MariaK/layoutlmv2-base-uncased_finetuned_docvqa... |
[
0.048665594,
-0.025715675,
-0.010496644,
0.027569324,
-0.022067228,
-0.03080585,
0.030864695,
-0.015697155,
-0.018963104,
0.03221815,
-0.0052520004,
-0.022449726,
0.015535329,
-0.014086247,
0.0063185827,
0.0673786,
-0.029702488,
-0.052961346,
-0.030026142,
-0.011747121,
0.019... | pip install -q bitsandbytes sentencepiece accelerate transformers
To run the following examples with a non-quantized version of the model checkpoint you will need at least 20GB of GPU memory.
Loading the model
Let's start by loading the model's 9 billion parameters checkpoint:
checkpoint = "HuggingFaceM4/idefics-9b... |
[
0.023912698,
-0.035025775,
-0.017031021,
0.020524563,
0.01740748,
-0.028460326,
-0.0050257323,
-0.0126038585,
0.013017964,
0.059510693,
-0.027767641,
-0.016790086,
0.03547753,
-0.025313126,
-0.0016846556,
0.0025279245,
-0.01721172,
-0.033851225,
-0.05770369,
-0.02111184,
-0.0... |
Image tasks with IDEFICS
[[open-in-colab]]
While individual tasks can be tackled by fine-tuning specialized models, an alternative approach
that has recently emerged and gained popularity is to use large models for a diverse set of tasks without fine-tuning.
For instance, large language models can handle such NLP ta... |
[
0.046583116,
-0.013738557,
-0.009959512,
0.02868159,
0.024194917,
0.0014566634,
0.018548934,
-0.030187186,
0.0107800625,
0.018518822,
-0.01666694,
-0.008589421,
0.03351455,
-0.041855548,
-0.000477556,
0.07323215,
0.00016302774,
-0.03351455,
-0.03760977,
-0.021785963,
-0.01060... | Loading the model
Let's start by loading the model's 9 billion parameters checkpoint:
checkpoint = "HuggingFaceM4/idefics-9b"
Just like for other Transformers models, you need to load a processor and the model itself from the checkpoint.
The IDEFICS processor wraps a [LlamaTokenizer] and IDEFICS image processor int... |
[
0.011376391,
-0.04512562,
0.0045154844,
-0.008110336,
-0.024374848,
0.02342499,
-0.0057247286,
-0.030249363,
0.009118648,
0.060264915,
-0.0055311034,
-0.021393752,
0.03887116,
-0.034078028,
0.014898176,
0.052782945,
-0.027765116,
-0.033902667,
-0.073416814,
-0.031330742,
-0.0... | import torch
from transformers import IdeficsForVisionText2Text, AutoProcessor
processor = AutoProcessor.from_pretrained(checkpoint)
model = IdeficsForVisionText2Text.from_pretrained(checkpoint, torch_dtype=torch.bfloat16, device_map="auto") |
[
0.027514357,
-0.015489783,
-0.0026007583,
0.008203958,
-0.026492564,
0.029024834,
0.032815833,
0.0009135048,
-0.020613555,
0.03314162,
0.032549277,
-0.014490204,
0.02076164,
-0.04407036,
0.010721418,
0.059708226,
0.00026285244,
-0.02498209,
-0.0681195,
0.004250065,
0.00958856... | Setting device_map to "auto" will automatically determine how to load and store the model weights in the most optimized
manner given existing devices.
Quantized model
If high-memory GPU availability is an issue, you can load the quantized version of the model. To load the model and the
processor in 4bit precision, pa... |
[
0.046490505,
-0.013860664,
-0.014232406,
0.010294977,
0.029769702,
-0.029071739,
-0.0220314,
0.03247052,
-0.006956885,
0.079871416,
0.014300685,
0.018071212,
-0.0033475743,
-0.034139566,
-0.034594763,
0.013708933,
-0.005504057,
-0.042697217,
-0.044275224,
-0.010765344,
0.0047... |
You can also manually replicate the results of the pipeline if you'd like:
1. Take an image and a question, prepare them for the model using the processor from your model.
2. Forward the result or preprocessing through the model.
3. The model returns start_logits and end_logits, which indicate which token is at the s... |
[
0.015585501,
-0.051661436,
-0.0041503287,
-0.0069075404,
-0.017210804,
0.016296571,
0.00522419,
-0.017747736,
-0.01482364,
0.05813363,
-0.0054454925,
-0.03526328,
0.044579756,
-0.03799147,
0.004988376,
0.047743294,
-0.027920393,
-0.042170823,
-0.06837884,
-0.008170052,
-0.002... | import torch
from transformers import IdeficsForVisionText2Text, AutoProcessor, BitsAndBytesConfig
quantization_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_compute_dtype=torch.float16,
)
processor = AutoProcessor.from_pretrained(checkpoint)
model = IdeficsForVisionText2Text.from_pretrained(
... |
[
-0.005125449,
-0.03712878,
-0.029089995,
-0.009130384,
0.019533094,
-0.03449738,
-0.019749967,
0.0035223907,
0.012202761,
0.06847426,
-0.0022735596,
-0.022352451,
0.008805073,
-0.002541037,
-0.0095641315,
-0.008327951,
-0.029552659,
-0.016540237,
-0.05791974,
-0.007088156,
0.... | Now that you have the model loaded in one of the suggested ways, let's move on to exploring tasks that you can use IDEFICS for.
Image captioning
Image captioning is the task of predicting a caption for a given image. A common application is to aid visually impaired
people navigate through different situations, for ins... |
[
0.0036538695,
-0.06073058,
0.021755975,
-0.02646783,
0.008514788,
-0.04572245,
-0.012005052,
0.010463519,
0.010332634,
0.065442435,
-0.02351565,
-0.01668055,
0.0092055695,
0.0007116865,
-0.015124475,
-0.0056025996,
0.0057116705,
-0.011881438,
-0.056687694,
-0.02946364,
0.0032... | Photo by Hendo Wang.
IDEFICS accepts text and image prompts. However, to caption an image, you do not have to provide a text prompt to the
model, only the preprocessed input image. Without a text prompt, the model will start generating text from the
BOS (beginning-of-sequence) token thus creating a caption.
As image... |
[
-0.0057082274,
-0.012995008,
0.013765581,
0.003086034,
-0.019600991,
-0.048718188,
0.02236907,
-0.00213965,
0.0035162084,
0.058533646,
-0.009231917,
0.011019946,
0.010870321,
-0.021920193,
-0.023715703,
-0.01514214,
-0.0020068572,
-0.08540645,
-0.060778033,
-0.00751496,
-0.00... |
prompt = [
"https://images.unsplash.com/photo-1583160247711-2191776b4b91?ixlib=rb-4.0.3&ixid=M3wxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8fA%3D%3D&auto=format&fit=crop&w=3542&q=80",
]
inputs = processor(prompt, return_tensors="pt").to("cuda")
bad_words_ids = processor.tokenizer(["", ""], add_special_tokens=False... |
[
0.024703825,
-0.025999628,
-0.015006215,
-0.027434763,
0.041131243,
-0.025567694,
-0.00030675138,
0.007865375,
0.0026891362,
0.07195181,
-0.003493787,
-0.013055547,
-0.01196178,
-0.007928075,
-0.0062804567,
-0.016037283,
-0.0052563553,
-0.03887404,
-0.048683118,
-0.01906082,
... | Prompted image captioning
You can extend image captioning by providing a text prompt, which the model will continue given the image. Let's take
another image to illustrate:
Photo by Denys Nevozhai.
Textual and image prompts can be passed to the model's processor as a single list to create appropriate inputs. |
[
0.012313747,
-0.02674614,
0.012036474,
0.035604645,
0.015157568,
-0.09128667,
0.034637745,
0.011183328,
-0.010244867,
0.038334712,
0.02677458,
-0.0062173046,
0.02597831,
-0.03199299,
-0.030059192,
-0.0068856026,
-0.00032059645,
-0.030457329,
-0.042884827,
0.0064910227,
-0.006... | It is a good idea to include the bad_words_ids in the call to generate to avoid errors arising when increasing
the max_new_tokens: the model will want to generate a new <image> or <fake_token_around_image> token when there
is no image being generated by the model.
You can set it on-the-fly as in this guide, or store ... |
[
-0.004204906,
-0.0278501,
0.0061074784,
0.020965308,
0.0070920778,
-0.047231164,
0.003383173,
0.0026743351,
-0.0010095846,
0.0465797,
-0.024933318,
0.012459256,
0.005940911,
-0.056322053,
-0.030174645,
-0.014095319,
-0.012503674,
-0.048504483,
-0.028235057,
-0.032425158,
-0.0... |
prompt = [
"https://images.unsplash.com/photo-1543349689-9a4d426bee8e?ixlib=rb-4.0.3&ixid=M3wxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8fA%3D%3D&auto=format&fit=crop&w=3501&q=80",
"This is an image of ",
]
inputs = processor(prompt, return_tensors="pt").to("cuda")
bad_words_ids = processor.tokenizer(["", ""]... |
[
0.022260016,
-0.023766564,
0.008954737,
0.007659567,
-0.031699,
-0.008531981,
-0.052790675,
0.022137033,
-0.00792475,
0.06518126,
-0.00072829303,
0.0036606812,
-0.01236753,
0.004073829,
-0.0024481406,
0.02133764,
-0.00082197186,
-0.0032725146,
-0.051007412,
-0.024596704,
-0.0... |
Few-shot prompting
While IDEFICS demonstrates great zero-shot results, your task may require a certain format of the caption, or come with
other restrictions or requirements that increase task's complexity. Few-shot prompting can be used to enable in-context learning.
By providing examples in the prompt, you can ste... |
[
0.036940757,
0.00019755877,
-0.031725936,
0.014785043,
-0.011675085,
-0.025768217,
-0.02579735,
0.015673602,
-0.009788718,
0.054595407,
0.042592578,
0.0199416,
0.015644468,
-0.0086816605,
-0.021427387,
0.0011407426,
-0.00536413,
-0.013874633,
-0.03688249,
0.010699127,
-0.0213... |
Notice that just from a single example (i.e., 1-shot) the model has learned how to perform the task. For more complex tasks,
feel free to experiment with a larger number of examples (e.g., 3-shot, 5-shot, etc.).
Visual question answering
Visual Question Answering (VQA) is the task of answering open-ended questions b... |
[
-0.004706098,
0.034295913,
-0.0025182064,
0.005018654,
0.010641109,
0.0048552724,
-0.029834885,
0.018824393,
0.06307948,
0.0006091289,
0.029579159,
-0.011088633,
-0.010598488,
0.022830792,
-0.038387552,
0.015045307,
0.02903929,
-0.031056695,
-0.02591373,
0.01859708,
-0.052054... | Photo by Juan Mayobre. |
[
0.024790423,
-0.025188716,
0.017785925,
-0.0065375296,
0.008377926,
-0.016948134,
-0.008934166,
0.0413952,
0.018678656,
0.046586767,
0.020409178,
-0.0041546277,
-0.013995258,
-0.036478315,
-0.01946151,
0.0071349717,
-0.008268052,
-0.03892302,
-0.010905039,
-0.04098317,
-0.017... |
prompt = ["User:",
"https://images.unsplash.com/photo-1543349689-9a4d426bee8e?ixlib=rb-4.0.3&ixid=M3wxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8fA%3D%3D&auto=format&fit=crop&w=3501&q=80",
"Describe this image.\nAssistant: An image of the Eiffel Tower at night. Fun fact: the Eiffel Tower is the s... |
[
0.0045802593,
-0.0147311045,
0.0067830076,
-0.0052829543,
0.0044346233,
-0.04677836,
0.013296588,
0.010864463,
-0.014301478,
0.058837038,
-0.00086608046,
-0.022340598,
0.020651218,
-0.029433083,
-0.026840758,
-0.024102796,
-0.021393962,
-0.051992133,
-0.05542915,
-0.037603274,
... |
categories = ['animals','vegetables', 'city landscape', 'cars', 'office']
prompt = [f"Instruction: Classify the following image into a single category from the following list: {categories}.\n",
"https://images.unsplash.com/photo-1471193945509-9ad0617afabf?ixlib=rb-4.0.3&ixid=M3wxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVuf... |
[
0.021228645,
-0.00024483513,
-0.026787844,
-0.014042014,
0.010995978,
-0.016879221,
-0.032721493,
0.039144814,
0.007820322,
0.048477355,
0.00815877,
-0.0060740714,
-0.0066465535,
-0.012536999,
-0.010715137,
0.018463448,
-0.0056492104,
-0.019413985,
-0.02412346,
-0.0018704684,
... | Photo by Jarritos Mexican Soda.
You can steer the model from image captioning to visual question answering by prompting it with appropriate instructions: |
[
-0.018767409,
-0.022825612,
-0.003358697,
-0.044996217,
0.04080986,
-0.018810127,
-0.018738931,
0.0038090153,
0.0045672585,
0.06476038,
0.009262671,
-0.008358475,
0.03232323,
-0.014652249,
-0.030415164,
0.0061335824,
-0.012544831,
0.021358963,
-0.051631734,
-0.027738174,
0.01... | Image classification
IDEFICS is capable of classifying images into different categories without being explicitly trained on data containing
labeled examples from those specific categories. Given a list of categories and using its image and text understanding
capabilities, the model can infer which category the image ... |
[
0.020780303,
-0.0007009519,
0.008842216,
0.011981896,
-0.003258331,
-0.055550437,
-0.0075060264,
0.014318403,
0.0028403155,
0.04664251,
-0.0083749145,
-0.0020225383,
0.0075060264,
-0.029366963,
-0.010974278,
-0.039866637,
-0.028315535,
-0.046846952,
-0.019670462,
-0.020575859,
... |
prompt = [
"Instruction: Provide an answer to the question. Use the image to answer.\n",
"https://images.unsplash.com/photo-1623944889288-cd147dbb517c?ixlib=rb-4.0.3&ixid=M3wxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8fA%3D%3D&auto=format&fit=crop&w=3540&q=80",
"Question: Where are these people and what's... |
[
0.001258361,
-0.01108641,
0.014672561,
0.013759981,
0.0049906666,
-0.07277818,
-0.0227717,
0.023997977,
-0.0126620345,
0.0416079,
-0.011728067,
-0.006416572,
0.0018786296,
-0.028660687,
-0.005168905,
-0.023841128,
-0.0072400314,
-0.057435445,
-0.047054857,
-0.017609924,
-0.00... |
prompt = ["Instruction: Use the image to write a story. \n",
"https://images.unsplash.com/photo-1517086822157-2b0358e7684a?ixlib=rb-4.0.3&ixid=M3wxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8fA%3D%3D&auto=format&fit=crop&w=2203&q=80",
"Story: \n"]
inputs = processor(prompt, return_tensors="pt").to("cuda")
bad_w... |
[
0.018440664,
-0.017731408,
0.006900775,
-0.017702458,
0.014489094,
-0.047245156,
-0.01667476,
0.0049539385,
-0.008684771,
0.051008556,
-0.00013728271,
-0.027053064,
0.026908318,
0.0026434273,
-0.0050082183,
-0.024896344,
0.020076297,
-0.0048996587,
-0.039921,
-0.027472828,
-0... | In the example above we instruct the model to classify the image into a single category, however, you can also prompt the model to do rank classification.
Image-guided text generation
For more creative applications, you can use image-guided text generation to generate text based on an image. This can be
useful to crea... |
[
-0.013322213,
0.038506385,
-0.000045281464,
0.007591931,
-0.029066645,
-0.02109408,
-0.003328823,
0.061842747,
0.0069794552,
-0.02712887,
0.059074495,
-0.00054024166,
0.00042042826,
-0.015460687,
-0.07119944,
0.0028391883,
-0.027599473,
-0.025467917,
-0.01493472,
-0.0110868495,... |
One day, the little girl was playing in her yard when she noticed a man standing on her doorstep. He was wearing a long black coat and a top hat.
The little girl ran inside and told her mother about the man.
Her mother said, “Don’t worry, honey. He’s just a friendly ghost.”
The little girl wasn’t sure if she believ... |
[
0.018847013,
-0.0127172265,
-0.009187746,
-0.014069386,
-0.02904021,
-0.021371042,
-0.04107789,
0.029151157,
0.021537462,
0.085872486,
-0.003077028,
-0.019540427,
0.018569648,
-0.012231836,
-0.058191366,
0.041771304,
-0.021690015,
-0.046597473,
-0.019027302,
-0.0073848674,
0.... | Running inference in batch mode
All of the earlier sections illustrated IDEFICS for a single example. In a very similar fashion, you can run inference
for a batch of examples by passing a list of prompts: |
[
-0.031927425,
-0.015963713,
-0.0078917835,
0.01194507,
-0.0021028589,
-0.048861157,
0.001784139,
0.015437132,
0.01417611,
0.028366076,
0.007330559,
-0.0066030463,
0.007940284,
-0.01268644,
-0.040685296,
-0.012838871,
-0.0061353594,
-0.029211378,
-0.02638447,
-0.0016906016,
0.... | Looks like IDEFICS noticed the pumpkin on the doorstep and went with a spooky Halloween story about a ghost.
For longer outputs like this, you will greatly benefit from tweaking the text generation strategy. This can help
you significantly improve the quality of the generated output. Check out Text generation strateg... |
[
-0.0017891224,
-0.031723093,
0.015696166,
0.018357297,
0.003204258,
-0.051899582,
-0.007953325,
0.0048486716,
-0.0076939776,
0.05162896,
-0.024205772,
0.018793302,
0.01943979,
-0.050666742,
-0.026656419,
-0.008652437,
-0.0044690473,
-0.045103922,
-0.03942083,
-0.04408157,
-0.... |
prompts = [
[ "https://images.unsplash.com/photo-1543349689-9a4d426bee8e?ixlib=rb-4.0.3&ixid=M3wxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8fA%3D%3D&auto=format&fit=crop&w=3501&q=80",
"This is an image of ",
],
[ "https://images.unsplash.com/photo-1623944889288-cd147dbb517c?ixlib=rb-4.0.3&ixi... |
[
0.010862118,
-0.042033594,
0.0011882744,
0.013043384,
-0.013986634,
0.0019546654,
-0.0009718058,
-0.02366969,
0.009859914,
0.053234693,
-0.012026442,
-0.017332226,
0.034811836,
-0.024745584,
-0.0044878083,
0.03784792,
-0.027840624,
-0.024907704,
-0.060898602,
-0.038850125,
0.... | import torch
from transformers import IdeficsForVisionText2Text, AutoProcessor
device = "cuda" if torch.cuda.is_available() else "cpu"
checkpoint = "HuggingFaceM4/idefics-9b-instruct"
model = IdeficsForVisionText2Text.from_pretrained(checkpoint, torch_dtype=torch.bfloat16).to(device)
processor = AutoProcessor.from_pret... |
[
0.0023175771,
0.017174773,
-0.00644054,
0.024512557,
-0.0005748536,
-0.058586027,
0.006647596,
-0.00043636202,
-0.0022758027,
0.058556966,
-0.014290515,
0.022754395,
0.019310722,
-0.06939654,
-0.03789493,
0.004424466,
-0.019543206,
-0.07980021,
-0.056929577,
-0.013440494,
-0.... |
--batched mode
inputs = processor(prompts, add_end_of_utterance_token=False, return_tensors="pt").to(device)
--single sample mode
inputs = processor(prompts[0], return_tensors="pt").to(device)
Generation args
exit_condition = processor.tokenizer("", add_special_tokens=False).input_ids
bad_words_ids = processor.tokeni... |
[
0.010448043,
-0.010259381,
0.005526534,
-0.0082036005,
-0.0114954505,
-0.056520924,
0.00247214,
0.021637728,
0.042755008,
0.010064212,
0.035208475,
-0.0044010594,
0.047126792,
0.00994711,
-0.028312506,
0.0012970602,
-0.041896265,
-0.009101378,
-0.038929697,
-0.0023404008,
0.0... | 1:
This is an image of a couple on a picnic blanket.
2:
This is an image of a vegetable stand. |
[
0.0100192465,
-0.021966944,
-0.028781772,
0.005136495,
-0.04155595,
-0.032189187,
-0.015137617,
0.00046444137,
-0.021604452,
0.01066448,
-0.0036901566,
0.021024467,
0.008366289,
-0.018385535,
-0.022981917,
0.0016357398,
-0.057331547,
-0.022793423,
-0.08270591,
-0.018356536,
0... |
IDEFICS instruct for conversational use
For conversational use cases, you can find fine-tuned instructed versions of the model on the 🤗 Hub:
HuggingFaceM4/idefics-80b-instruct and HuggingFaceM4/idefics-9b-instruct.
These checkpoints are the result of fine-tuning the respective base models on a mixture of supervised... |
[
0.04660224,
0.012188045,
0.014216863,
0.004837367,
-0.000025209407,
-0.01480734,
0.040273543,
0.00028790472,
0.007335538,
0.02081809,
0.0038437764,
0.008796589,
0.03772995,
-0.05783644,
-0.012634688,
0.038910903,
-0.009659594,
-0.036518715,
-0.03409625,
0.024996849,
-0.000772... | Before you begin, make sure you have all the necessary libraries installed:
pip install transformers datasets evaluate rouge_score
We encourage you to login to your Hugging Face account so you can upload and share your model with the community. When prompted, enter your token to login:
from huggingface_hub import not... |
[
0.037565455,
-0.052761108,
0.001215405,
-0.014263575,
0.03945785,
-0.0059243264,
0.00020521543,
0.009984503,
0.024728239,
0.035475347,
0.045502216,
0.03423258,
-0.0039613196,
0.0062667937,
-0.033413485,
0.014560144,
-0.01134731,
-0.029600449,
-0.04736637,
-0.01765294,
-0.0070... | "\nAssistant: This picture depicts Idefix, the dog of Obelix in Asterix and Obelix. Idefix is running on the ground.",
"\nUser:",
"https://static.wikia.nocookie.net/asterix/images/2/25/R22b.gif/revision/latest?cb=20110815073052",
"And who is that?",
"\nAssistant:",
],
] |
[
0.0335303,
0.0025285815,
0.045353983,
0.022811351,
-0.01960164,
-0.0035120226,
0.042099483,
-0.0036501149,
0.01290603,
0.05944686,
0.023707086,
0.026185282,
0.04621986,
-0.036605652,
-0.030514661,
0.022199268,
-0.004217413,
-0.01958671,
-0.046846874,
0.030231014,
-0.028335044... | from huggingface_hub import notebook_login
notebook_login()
Load BillSum dataset
Start by loading the smaller California state bill subset of the BillSum dataset from the 🤗 Datasets library:
from datasets import load_dataset
billsum = load_dataset("billsum", split="ca_test")
Split the dataset into a train and test ... |
[
0.032558903,
-0.013663634,
0.0048188055,
0.04682169,
-0.024141522,
-0.024784517,
0.00932342,
0.0051658764,
-0.013510192,
0.028174851,
0.011142802,
-0.021438021,
-0.023571594,
-0.011164723,
-0.016250225,
0.038053583,
-0.046003334,
-0.041268557,
-0.045389567,
0.0028679017,
0.00... | from transformers import AutoTokenizer
checkpoint = "google-t5/t5-small"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)
The preprocessing function you want to create needs to:
Prefix the input with a prompt so T5 knows this is a summarization task. Some models capable of multiple NLP tasks require prompting fo... |
[
0.035621837,
-0.020202057,
-0.005724938,
0.014867978,
-0.017473707,
-0.006924339,
0.027911946,
-0.0060008387,
0.024340566,
0.057142086,
0.030916197,
-0.00068831455,
-0.013250894,
0.0011955694,
0.0022704322,
0.047270972,
-0.026532443,
-0.051409483,
-0.04098657,
0.020431975,
-0... | There are two fields that you'll want to use:
text: the text of the bill which'll be the input to the model.
summary: a condensed version of text which'll be the model target.
Preprocess
The next step is to load a T5 tokenizer to process text and summary:
from transformers import AutoTokenizer
checkpoint = "google-t... |
[
0.01699749,
-0.020610688,
0.018023808,
-0.015043271,
-0.02574227,
-0.030086542,
-0.0043583307,
-0.0044286265,
-0.013349146,
0.07046437,
0.0265577,
0.0075216354,
-0.029721005,
-0.006041912,
-0.021299586,
0.056433357,
-0.026051572,
-0.06309739,
-0.06849609,
-0.005556872,
0.0101... | prefix = "summarize: "
def preprocess_function(examples):
inputs = [prefix + doc for doc in examples["text"]]
model_inputs = tokenizer(inputs, max_length=1024, truncation=True)
labels = tokenizer(text_target=examples["summary"], max_length=128, truncation=True)
model_inputs["labels"] = labels["inpu... |
[
0.0066490793,
-0.010710215,
0.009541698,
0.0010753229,
-0.006609651,
-0.024359645,
0.011477279,
-0.005523575,
-0.009749593,
0.051242717,
0.034983836,
0.0020072693,
-0.008846322,
-0.010624189,
-0.013828651,
0.053249985,
-0.038195465,
-0.03463973,
-0.06801775,
-0.023800477,
-0.... | labels = tokenizer(text_target=examples["summary"], max_length=128, truncation=True)
model_inputs["labels"] = labels["input_ids"]
return model_inputs
To apply the preprocessing function over the entire dataset, use 🤗 Datasets [~datasets.Dataset.map] method. You can speed up the map function by setting batch... |
[
0.036701847,
-0.018866144,
0.021578625,
0.043793697,
-0.010228632,
-0.01316084,
0.0018525189,
-0.0096376445,
0.0040762993,
0.05170384,
0.016441578,
0.007732088,
0.0034019672,
-0.029367538,
-0.046400104,
0.025988301,
-0.0510977,
-0.08007125,
-0.054401167,
0.01592636,
-0.024245... | tokenized_billsum = billsum.map(preprocess_function, batched=True)
Now create a batch of examples using [DataCollatorForSeq2Seq]. It's more efficient to dynamically pad the sentences to the longest length in a batch during collation, instead of padding the whole dataset to the maximum length.
from transformers import... |
[
0.012982962,
0.0080515025,
0.020249289,
0.012135798,
0.0018630723,
-0.0037364757,
-0.010827171,
-0.00045758914,
0.00095219864,
0.07873805,
-0.017535608,
-0.010648095,
0.01841721,
-0.06397122,
0.0066981064,
0.0137750255,
-0.03171011,
-0.07515654,
-0.06033461,
-0.025580224,
-0.... | from transformers import DataCollatorForSeq2Seq
data_collator = DataCollatorForSeq2Seq(tokenizer=tokenizer, model=checkpoint)
from transformers import DataCollatorForSeq2Seq
data_collator = DataCollatorForSeq2Seq(tokenizer=tokenizer, model=checkpoint, return_tensors="tf") |
[
0.015020793,
-0.00023180236,
-0.022905782,
0.0064496687,
-0.036168586,
0.0026462558,
-0.0022086129,
0.001137686,
-0.01436062,
0.05198307,
0.00963556,
0.027044846,
0.020057395,
-0.058391944,
0.007273031,
-0.004076013,
-0.04355659,
-0.07103166,
-0.066462375,
0.0000638036,
0.005... | from transformers import DataCollatorForSeq2Seq
data_collator = DataCollatorForSeq2Seq(tokenizer=tokenizer, model=checkpoint, return_tensors="tf")
Evaluate
Including a metric during training is often helpful for evaluating your model's performance. You can quickly load a evaluation method with the 🤗 Evaluate library.... |
[
0.027760437,
-0.022531955,
-0.046267394,
0.039848797,
-0.003058863,
-0.033804618,
0.004740402,
0.008919177,
0.011426442,
0.0842441,
0.04474298,
0.0035970893,
0.079269685,
-0.02957904,
-0.03677322,
-0.011520047,
-0.000013150082,
0.0094206305,
-0.039046474,
0.03589066,
-0.01129... |
billsum["train"][0]
{'summary': 'Existing law authorizes state agencies to enter into contracts for the acquisition of goods or services upon approval by the Department of General Services. Existing law sets forth various requirements and prohibitions for those contracts, including, but not limited to, a prohibition ... |
[
-0.008047127,
0.0039472547,
-0.04295501,
-0.012556293,
-0.03041259,
-0.016690852,
0.009642678,
0.007908383,
-0.03404767,
0.055081196,
0.032521494,
0.011043988,
0.02333667,
-0.029274894,
0.011862575,
0.018300276,
-0.0366838,
-0.050252922,
-0.073645085,
-0.006500136,
0.03524086... | import evaluate
rouge = evaluate.load("rouge")
Then create a function that passes your predictions and labels to [~evaluate.EvaluationModule.compute] to calculate the ROUGE metric:
import numpy as np
def compute_metrics(eval_pred):
predictions, labels = eval_pred
decoded_preds = tokenizer.batch_decode(predi... |
[
0.0028610919,
0.002210444,
-0.040712968,
0.009411532,
-0.04417371,
-0.032694172,
-0.009875778,
0.009889847,
-0.025209963,
0.052108094,
0.03328503,
0.023085687,
0.011718694,
-0.02349366,
-0.020933274,
0.01291448,
-0.015981317,
-0.030105649,
-0.06521953,
-0.0056975647,
0.022705... | result = rouge.compute(predictions=decoded_preds, references=decoded_labels, use_stemmer=True)
prediction_lens = [np.count_nonzero(pred != tokenizer.pad_token_id) for pred in predictions]
result["gen_len"] = np.mean(prediction_lens)
return {k: round(v, 4) for k, v in result.items()}
Your compute_metrics... |
[
0.03392283,
0.0065493863,
-0.012863593,
0.02812174,
-0.036801994,
-0.0010235644,
-0.0035704488,
-0.0070482516,
-0.0032764748,
0.029960414,
0.018315477,
-0.011908623,
0.023033315,
-0.05008606,
0.014253289,
0.043358505,
-0.008352428,
-0.04065038,
-0.0723497,
-0.011374124,
0.031... | Your compute_metrics function is ready to go now, and you'll return to it when you setup your training.
Train
If you aren't familiar with finetuning a model with the [Trainer], take a look at the basic tutorial here!
You're ready to start training your model now! Load T5 with [AutoModelForSeq2SeqLM]:
from transforme... |
[
0.024683893,
0.032738637,
-0.04027372,
-0.0053229155,
-0.032218978,
-0.03484615,
0.0002438166,
0.0012747932,
-0.021421578,
0.02547782,
0.011425323,
0.01987703,
0.017076634,
-0.053034283,
0.0066328943,
0.042121403,
0.0033074252,
-0.036809314,
-0.07350315,
0.009476594,
0.014225... | Once training is completed, share your model to the Hub with the [~transformers.Trainer.push_to_hub] method so everyone can use your model:
trainer.push_to_hub()
If you aren't familiar with finetuning a model with Keras, take a look at the basic tutorial here!
To finetune a model in TensorFlow, start by setting up a... |
[
0.050447773,
0.022772532,
-0.011421086,
0.011602152,
0.000611533,
-0.014262429,
-0.0040705027,
-0.014972765,
-0.035126805,
0.034458254,
0.03303758,
-0.02075295,
0.023872856,
-0.049751364,
0.015975593,
0.022535753,
-0.030001244,
-0.05211915,
-0.05710543,
-0.010223265,
0.028413... | To finetune a model in TensorFlow, start by setting up an optimizer function, learning rate schedule, and some training hyperparameters:
from transformers import create_optimizer, AdamWeightDecay
optimizer = AdamWeightDecay(learning_rate=2e-5, weight_decay_rate=0.01)
Then you can load T5 with [TFAutoModelForSeq2SeqLM... |
[
0.031843673,
0.0035498643,
0.0024598152,
0.05348869,
-0.0051400135,
-0.021550084,
0.0010485153,
-0.018335879,
0.0008607658,
0.0288329,
0.008666145,
-0.021021163,
0.047223028,
-0.044971727,
-0.012178713,
0.03195217,
-0.01023256,
-0.040821742,
-0.021265281,
-0.03553255,
0.01655... | Then you can load T5 with [TFAutoModelForSeq2SeqLM]:
from transformers import TFAutoModelForSeq2SeqLM
model = TFAutoModelForSeq2SeqLM.from_pretrained(checkpoint)
Convert your datasets to the tf.data.Dataset format with [~transformers.TFPreTrainedModel.prepare_tf_dataset]: |
[
0.011095705,
0.0036963322,
-0.021909658,
0.026806794,
-0.023533091,
-0.016355095,
0.011149372,
0.012269677,
0.008848389,
0.029194986,
0.018971374,
0.02033989,
0.047898024,
-0.05052772,
-0.037808582,
0.018890874,
-0.02177549,
-0.05184257,
-0.04497316,
-0.040438276,
-0.01318202... | Convert your datasets to the tf.data.Dataset format with [~transformers.TFPreTrainedModel.prepare_tf_dataset]:
tf_train_set = model.prepare_tf_dataset(
tokenized_billsum["train"],
shuffle=True,
batch_size=16,
collate_fn=data_collator,
)
tf_test_set = model.prepare_tf_dataset(
tokenized_billsu... |
[
0.04120538,
0.024262287,
0.021999484,
0.034724265,
-0.038467668,
-0.025449561,
0.0038935593,
0.009218832,
0.010175634,
0.03508743,
0.0090582,
0.015462494,
0.012249871,
-0.040227626,
0.0030589758,
0.031539578,
-0.0154485265,
-0.031427834,
-0.06721366,
-0.024248319,
-0.00594335... |
training_args = Seq2SeqTrainingArguments(
output_dir="my_awesome_billsum_model",
evaluation_strategy="epoch",
learning_rate=2e-5,
per_device_train_batch_size=16,
per_device_eval_batch_size=16,
weight_decay=0.01,
save_total_limit=3,
num_train_epochs=4,
predict_with_generate... |
[
0.04137843,
0.018816298,
-0.0035516487,
0.014533266,
-0.024260828,
-0.025596552,
-0.011977967,
-0.019106671,
-0.005034376,
0.041029982,
-0.0065769926,
0.010765651,
0.009880008,
-0.04637288,
0.00054036966,
0.017770948,
-0.006968999,
-0.040768642,
-0.08316339,
-0.0047004446,
0.... |
Define your training hyperparameters in [Seq2SeqTrainingArguments]. The only required parameter is output_dir which specifies where to save your model. You'll push this model to the Hub by setting push_to_hub=True (you need to be signed in to Hugging Face to upload your model). At the end of each epoch, the [Trainer]... |
[
0.012537222,
0.044365704,
-0.047019824,
-0.009834211,
-0.030648096,
-0.014059849,
0.0036354454,
0.0070962775,
-0.044896528,
0.03469912,
0.00489266,
0.017181931,
0.03355366,
-0.06984525,
-0.016092345,
0.03073191,
-0.02043672,
-0.03659891,
-0.08208214,
0.014220493,
0.02292321,
... | import tensorflow as tf
model.compile(optimizer=optimizer) # No loss argument!
The last two things to setup before you start training is to compute the ROUGE score from the predictions, and provide a way to push your model to the Hub. Both are done by using Keras callbacks.
Pass your compute_metrics function to [~tra... |
[
0.011927631,
0.05342137,
-0.049373876,
0.017160265,
-0.019128567,
0.012447429,
-0.00026401406,
-0.0043593724,
0.019544404,
0.028013647,
0.004646994,
0.038562078,
0.001362737,
-0.052561972,
-0.016675118,
0.04787686,
0.0131058395,
-0.03140966,
-0.070359856,
0.01213555,
-0.00207... | Then bundle your callbacks together:
callbacks = [metric_callback, push_to_hub_callback]
Finally, you're ready to start training your model! Call fit with your training and validation datasets, the number of epochs, and your callbacks to finetune the model:
model.fit(x=tf_train_set, validation_data=tf_test_set, epoc... |
[
0.03887087,
0.031751763,
-0.03789639,
-0.029965218,
-0.02403714,
-0.023739383,
0.016065363,
0.014075803,
-0.05229702,
0.029180221,
0.017215788,
-0.03107504,
0.033754855,
-0.051999263,
-0.0025749244,
0.03670536,
-0.008195095,
-0.03107504,
-0.09170926,
0.020409914,
0.0037964063... | Configure the model for training with compile. Note that Transformers models all have a default task-relevant loss function, so you don't need to specify one unless you want to:
import tensorflow as tf
model.compile(optimizer=optimizer) # No loss argument! |
[
0.0450818,
-0.031784087,
-0.008874594,
-0.010604148,
-0.021747008,
-0.0059506563,
-0.0010924895,
-0.0010721105,
-0.023972746,
0.08608073,
0.019336974,
-0.020726288,
-0.0165867,
-0.020159222,
-0.020258458,
0.0076057822,
-0.012369143,
-0.055629246,
-0.053502742,
0.02608507,
0.0... | For a more in-depth example of how to finetune a model for summarization, take a look at the corresponding
PyTorch notebook
or TensorFlow notebook.
Inference
Great, now that you've finetuned a model, you can use it for inference!
Come up with some text you'd like to summarize. For T5, you need to prefix your input dep... |
[
0.0054793274,
-0.015404585,
0.002997182,
0.07698305,
-0.0026615774,
-0.008765594,
0.011875752,
0.02663571,
0.008094385,
0.045057416,
0.029506626,
-0.0047981497,
0.01921918,
-0.015378003,
-0.020721095,
0.0058747428,
-0.005153691,
-0.01806284,
0.0038312094,
0.047370095,
-0.0366... | text = "summarize: The Inflation Reduction Act lowers prescription drug costs, health care costs, and energy costs. It's the most aggressive action on tackling the climate crisis in American history, which will lift up American workers and create good-paying, union jobs across the country. It'll lower the deficit and a... |
[
0.010041883,
0.029734408,
-0.038921356,
0.01628727,
-0.021837112,
0.012280659,
0.026720395,
-0.0044413237,
-0.00027101673,
0.03712454,
-0.026213229,
0.026053833,
0.011657569,
-0.062077098,
-0.0102954665,
0.052020725,
-0.012244432,
-0.062077098,
-0.072568186,
0.0049376218,
0.0... | from transformers.keras_callbacks import KerasMetricCallback
metric_callback = KerasMetricCallback(metric_fn=compute_metrics, eval_dataset=tf_validation_set)
Specify where to push your model and tokenizer in the [~transformers.PushToHubCallback]:
from transformers.keras_callbacks import PushToHubCallback
push_to_hub_... |
[
0.01865858,
-0.024752319,
-0.016072934,
-0.014297923,
-0.02834427,
-0.006195068,
-0.012460018,
0.015318205,
0.014815052,
0.077541426,
0.02447279,
-0.039609298,
-0.0038470218,
-0.029350575,
-0.0049721273,
0.029713962,
-0.021747379,
-0.056856256,
-0.05193654,
0.0124111,
0.00948... | The simplest way to try out your finetuned model for inference is to use it in a [pipeline]. Instantiate a pipeline for summarization with your model, and pass your text to it: |
[
0.01938609,
-0.0057478575,
-0.009870357,
0.044268847,
-0.0024454251,
-0.0028296008,
0.0017583419,
-0.002561786,
0.022134423,
0.05759678,
0.033718795,
-0.024912307,
0.013468308,
-0.030704493,
-0.010527887,
0.0076613473,
-0.0060766228,
-0.05068162,
-0.02887227,
0.03847666,
-0.0... | from transformers import pipeline
summarizer = pipeline("summarization", model="stevhliu/my_awesome_billsum_model")
summarizer(text)
[{"summary_text": "The Inflation Reduction Act lowers prescription drug costs, health care costs, and energy costs. It's the most aggressive action on tackling the climate crisis in Ameri... |
[
0.027429042,
0.011364294,
-0.028465478,
0.018743422,
-0.010904468,
0.002530873,
-0.013984579,
0.0013147036,
0.021677556,
0.038683854,
0.02738525,
0.025341574,
-0.0069411974,
-0.035005238,
-0.021312615,
0.03316593,
0.009203838,
-0.03246524,
-0.06936818,
0.018174114,
0.01200659... | model.fit(x=tf_train_set, validation_data=tf_test_set, epochs=3, callbacks=callbacks)
Once training is completed, your model is automatically uploaded to the Hub so everyone can use it!
For a more in-depth example of how to finetune a model for summarization, take a look at the corresponding
PyTorch notebook
or Tenso... |
[
0.015922982,
-0.0011553641,
-0.0029438562,
-0.0008568081,
-0.036910992,
-0.014194202,
0.0010909139,
0.0036509125,
0.0035523416,
0.044493362,
-0.01428519,
0.0019410874,
-0.0009781261,
-0.024202934,
0.00019311356,
0.007825009,
-0.00565645,
-0.044917975,
-0.07103167,
-0.0059900745... | from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("stevhliu/my_awesome_billsum_model")
inputs = tokenizer(text, return_tensors="pt").input_ids
Use the [~transformers.generation_utils.GenerationMixin.generate] method to create the summarization. For more details about the different text g... |
[
0.018065598,
-0.028792497,
-0.011829866,
0.027019097,
-0.028806914,
-0.007082781,
0.0021861102,
0.007994711,
0.025389878,
0.04111978,
0.013668145,
-0.0059401644,
0.0018409824,
-0.0409756,
-0.02713444,
0.017474465,
0.0013931271,
-0.03526612,
-0.047723167,
-0.01587408,
-0.01822... | You can also manually replicate the results of the pipeline if you'd like:
Tokenize the text and return the input_ids as PyTorch tensors:
from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("stevhliu/my_awesome_billsum_model")
inputs = tokenizer(text, return_tensors="pt").input_ids |
[
0.010571888,
0.0054825284,
-0.0015954303,
0.06418854,
-0.011846048,
-0.025060907,
0.016848035,
0.010018538,
-0.030463345,
0.04269528,
0.0055152928,
0.012275621,
0.00033879004,
-0.04752981,
-0.028133454,
-0.0063708,
0.013025556,
-0.043976724,
0.000173263,
0.019119682,
-0.02417... | Decode the generated token ids back into text:
tokenizer.decode(outputs[0], skip_special_tokens=True)
'the inflation reduction act lowers prescription drug costs, health care costs, and energy costs. it's the most aggressive action on tackling the climate crisis in american history. it will ask the ultra-wealthy and c... |
[
0.018353246,
0.0037792705,
-0.015132064,
0.013049533,
-0.035537876,
-0.021963967,
0.006288796,
0.00299083,
-0.013371651,
0.052108236,
-0.01958179,
0.0074087186,
0.0031462708,
-0.031043205,
-0.011289119,
0.0020394577,
-0.0038841462,
-0.048782177,
-0.065262645,
-0.01836823,
-0.... | from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("stevhliu/my_awesome_billsum_model")
inputs = tokenizer(text, return_tensors="tf").input_ids
Use the [~transformers.generation_tf_utils.TFGenerationMixin.generate] method to create the summarization. For more details about the different t... |
[
0.026846932,
0.007910896,
-0.0070840106,
0.03823003,
-0.019100698,
-0.03281769,
0.011676626,
0.005881268,
0.00700526,
0.04375692,
0.010903435,
0.022107555,
0.028407635,
-0.026589202,
-0.0060423496,
0.030755846,
0.010860479,
-0.054839335,
-0.03361952,
-0.009006252,
-0.01945865... | from transformers import TFAutoModelForSeq2SeqLM
model = TFAutoModelForSeq2SeqLM.from_pretrained("stevhliu/my_awesome_billsum_model")
outputs = model.generate(inputs, max_new_tokens=100, do_sample=False)
Decode the generated token ids back into text: |
[
0.032798365,
0.0039536287,
0.009561436,
0.03784646,
-0.017568516,
-0.017867979,
0.012399208,
-0.001241525,
0.008292282,
0.05672691,
0.014802044,
0.020548888,
0.011422387,
-0.031999797,
-0.015115768,
0.037219014,
0.013269077,
-0.051849935,
-0.035593357,
-0.008534705,
-0.016983... | from transformers import AutoModelForSeq2SeqLM
model = AutoModelForSeq2SeqLM.from_pretrained("stevhliu/my_awesome_billsum_model")
outputs = model.generate(inputs, max_new_tokens=100, do_sample=False)
Decode the generated token ids back into text: |
[
0.023702923,
-0.00006121167,
-0.04593765,
-0.025058182,
0.013912586,
-0.050906934,
0.017364262,
0.007146876,
0.0037446101,
0.07233697,
0.0074256924,
0.013129076,
0.026314622,
-0.02927925,
-0.022390015,
0.009945628,
0.015670188,
-0.038088437,
-0.025876986,
-0.029561596,
0.0207... |
Mask Generation
Mask generation is the task of generating semantically meaningful masks for an image.
This task is very similar to image segmentation, but many differences exist. Image segmentation models are trained on labeled datasets and are limited to the classes they have seen during training; they return a set ... |
[
0.057450775,
0.020796278,
-0.0402099,
-0.01608396,
-0.00017150932,
-0.021529932,
-0.0018711712,
0.0102147255,
0.013875943,
0.081661366,
0.012726081,
0.001608396,
0.04043564,
-0.025282856,
-0.015392631,
0.050932538,
0.028048169,
-0.031095656,
-0.0027423857,
-0.04266482,
0.0113... | SAM serves as a powerful foundation model for segmentation as it has large data coverage. It is trained on
SA-1B, a dataset with 1 million images and 1.1 billion masks.
In this guide, you will learn how to:
- Infer in segment everything mode with batching,
- Infer in point prompting mode,
- Infer in box prompting mod... |
[
0.02520375,
0.0030027633,
-0.03280797,
-0.02899891,
-0.016167656,
-0.026983164,
0.009682521,
-0.002387614,
0.004163554,
0.055189677,
-0.009877145,
-0.02124177,
0.06322485,
-0.022256592,
-0.019239929,
0.055022858,
-0.013227451,
-0.031223178,
0.006474708,
-0.03275236,
0.0066554... | pip install -q transformers
Mask Generation Pipeline
The easiest way to infer mask generation models is to use the mask-generation pipeline.
thon
from transformers import pipeline
checkpoint = "facebook/sam-vit-base"
mask_generator = pipeline(model=checkpoint, task="mask-generation") |
[
0.05241244,
-0.007965767,
-0.0052167117,
-0.01143636,
-0.024965176,
-0.044677563,
0.000411727,
0.0017641577,
0.009661379,
0.051575456,
-0.021617245,
-0.014481246,
0.07411627,
-0.039395913,
-0.007828675,
0.015686212,
-0.009711887,
-0.045052763,
-0.016653072,
-0.013139186,
0.00... | from transformers import pipeline
checkpoint = "facebook/sam-vit-base"
mask_generator = pipeline(model=checkpoint, task="mask-generation")
Let's see the image.
thon
from PIL import Image
import requests
img_url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bee.jpg"
image = Image.open... |
[
0.0059755147,
-0.006628617,
0.007979864,
0.08005388,
-0.008092469,
-0.0037759847,
0.0149538005,
0.01090006,
-0.02071912,
0.040297188,
0.0348922,
0.023721892,
-0.005153506,
-0.028256077,
-0.03010278,
0.021589926,
0.004222647,
-0.040987827,
-0.006602343,
0.030778404,
-0.0362134... | Decode the generated token ids back into text:
tokenizer.decode(outputs[0], skip_special_tokens=True)
'the inflation reduction act lowers prescription drug costs, health care costs, and energy costs. it's the most aggressive action on tackling the climate crisis in american history. it will ask the ultra-wealthy and c... |
[
0.04041939,
0.0036812022,
-0.03400629,
-0.012165195,
-0.007147931,
-0.04925146,
-0.0075100744,
0.011265111,
0.031868592,
0.06486229,
-0.011201824,
-0.005400503,
0.0324874,
-0.030068425,
-0.021573884,
0.04489168,
0.011335431,
-0.03482199,
0.015849913,
-0.020505033,
-0.00107236... | Let's segment everything. points-per-batch enables parallel inference of points in segment everything mode. This enables faster inference, but consumes more memory. Moreover, SAM only enables batching over points and not the images. pred_iou_thresh is the IoU confidence threshold where only the masks above that certain... |
[
0.038285732,
-0.0059929243,
0.024992077,
-0.031157458,
-0.021327337,
-0.039924085,
-0.0107858265,
-0.014213434,
-0.00044125062,
0.074387,
0.0067438367,
0.019875815,
0.036015034,
-0.024287872,
-0.015693702,
0.044149313,
-0.02323875,
-0.05346206,
-0.036877323,
-0.015765559,
-0.... |
{'masks': [array([[False, False, False, , True, True, True],
[False, False, False, , True, True, True],
[False, False, False, , True, True, True],
,
[False, False, False, , False, False, False],
[False, False, False, , False, False, False],
[False, False,... |
[
0.021970522,
-0.0050588083,
-0.031176377,
0.00236764,
-0.010757321,
0.0033400634,
-0.031323437,
0.021602876,
0.01660289,
0.071882136,
-0.004077194,
-0.0137646645,
0.052235138,
-0.017044066,
-0.0026948447,
0.039705765,
-0.0138676055,
-0.055646893,
-0.029338147,
-0.018852884,
0... | Below is the original image in grayscale with colorful maps overlaid. Very impressive.
Model Inference
Point Prompting
You can also use the model without the pipeline. To do so, initialize the model and
the processor.
thon
from transformers import SamModel, SamProcessor
device = torch.device('cuda' if torch.cuda.is_av... |
[
0.034991816,
-0.021698581,
-0.01556207,
-0.040108114,
-0.026221022,
0.0059956606,
-0.030728236,
0.0216529,
-0.0024287184,
0.054665197,
-0.02503331,
0.005953786,
-0.0072823483,
-0.023799917,
0.0064067915,
0.041661274,
-0.005082036,
-0.0521375,
-0.006460086,
-0.01847044,
-0.012... |
To do point prompting, pass the input point to the processor, then take the processor output
and pass it to the model for inference. To post-process the model output, pass the outputs and
original_sizes and reshaped_input_sizes we take from the processor's initial output. We need to pass these
since the processor re... |
[
0.010477868,
-0.01452051,
0.020983238,
-0.04523909,
0.012650444,
-0.07755272,
-0.014465508,
-0.03333117,
-0.0018786597,
0.011742912,
0.005665199,
0.032396138,
0.024145849,
-0.013138587,
-0.0017669371,
0.04356153,
-0.048814215,
-0.0427365,
-0.041608963,
0.020089455,
0.02294955... | axes[i].imshow(overlayed_image)
axes[i].set_title(f'Mask {i}')
for ax in axes:
ax.axis('off')
plt.show() |
[
-0.014062704,
-0.012772209,
-0.018656863,
-0.01957127,
-0.02255047,
0.011223615,
-0.029615005,
0.005884655,
-0.032594204,
0.051767267,
-0.023509122,
-0.015559677,
0.041915264,
-0.0113711,
-0.017816199,
0.019040326,
0.009453794,
-0.0071382783,
-0.061412793,
0.010338705,
-0.020... |
Zero-shot object detection
[[open-in-colab]]
Traditionally, models used for object detection require labeled image datasets for training,
and are limited to detecting the set of classes from the training data.
Zero-shot object detection is supported by the OWL-ViT model which uses a different approach. OWL-ViT
is an o... |
[
0.02729601,
-0.04062185,
0.0031319389,
-0.05678859,
-0.025026225,
-0.017982565,
-0.0019018613,
0.017792195,
0.023532558,
0.036638744,
0.008434819,
0.0024985953,
-0.012703481,
0.021145621,
0.0010973684,
0.019212643,
0.01804114,
-0.057696503,
-0.02682741,
0.028467514,
-0.029785... | You can visualize the bounding box around the bee as shown below.
thon
import matplotlib.patches as patches
fig, ax = plt.subplots()
ax.imshow(image)
rectangle = patches.Rectangle((2350, 1600, 500, 500, linewidth=2, edgecolor='r', facecolor='none')
ax.add_patch(rectangle)
ax.axis("off")
plt.show()
You can see the infe... |
[
0.028880214,
-0.010319843,
0.002727661,
-0.029555416,
-0.039008237,
-0.007833873,
0.0025262516,
0.02872676,
-0.0016122357,
0.05938705,
-0.014900472,
0.028956942,
-0.0027660248,
-0.019304628,
-0.0064949794,
0.019458083,
0.02467555,
-0.046803746,
-0.022204926,
-0.010596062,
0.0... |
Box Prompting
You can also do box prompting in a similar fashion to point prompting. You can simply pass the input box in the format of a list
[x_min, y_min, x_max, y_max] format along with the image to the processor. Take the processor output and directly pass it
to the model, then post-process the output again.
th... |
[
0.010749356,
-0.0015891301,
-0.030080741,
-0.016800415,
-0.044946562,
-0.0041346475,
-0.033542644,
0.0118112005,
-0.018196812,
0.04148466,
-0.025906093,
-0.045208387,
0.0496885,
-0.022531465,
-0.010465713,
0.0434338,
0.0025091527,
-0.016553136,
-0.058881454,
0.0039891894,
-0.... | pip install -q transformers
Zero-shot object detection pipeline
The simplest way to try out inference with OWL-ViT is to use it in a [pipeline]. Instantiate a pipeline
for zero-shot object detection from a checkpoint on the Hugging Face Hub:
thon
from transformers import pipeline
checkpoint = "google/owlv2-base-patch1... |
[
0.03367405,
0.01645603,
-0.02653773,
0.00037389662,
-0.0115983505,
-0.019870326,
-0.039242428,
0.046276174,
0.0043301485,
0.0439609,
0.008982677,
-0.011004878,
0.049499974,
-0.04138186,
0.00038442892,
0.014873438,
0.013334806,
-0.017159404,
-0.026640305,
-0.033058595,
-0.0166... | from transformers import pipeline
checkpoint = "google/owlv2-base-patch16-ensemble"
detector = pipeline(model=checkpoint, task="zero-shot-object-detection")
Next, choose an image you'd like to detect objects in. Here we'll use the image of astronaut Eileen Collins that is
a part of the NASA Great Images dataset.
impo... |
[
0.05840891,
-0.014667577,
-0.00013989111,
-0.025646478,
-0.019154985,
-0.027476294,
0.00073700945,
0.035056964,
0.0066403463,
0.07371547,
0.012917634,
-0.015567963,
0.026575908,
-0.009759022,
-0.00029339694,
0.02381666,
0.031687777,
-0.0057290685,
-0.033081923,
-0.028579993,
... | import skimage
import numpy as np
from PIL import Image
image = skimage.data.astronaut()
image = Image.fromarray(np.uint8(image)).convert("RGB")
image
Pass the image and the candidate object labels to look for to the pipeline.
Here we pass the image directly; other suitable options include a local path to an image or ... |
[
0.009171194,
0.0030718334,
0.013084829,
-0.0040059364,
0.0016254503,
-0.020749643,
-0.008233399,
0.021355148,
-0.006697483,
0.0488835,
0.041735582,
-0.036684778,
0.011445533,
0.0024312527,
-0.027129605,
-0.014126003,
-0.02454513,
-0.028517837,
-0.006948546,
-0.022935372,
-0.0... |
predictions = detector(
image,
candidate_labels=["human face", "rocket", "nasa badge", "star-spangled banner"],
)
predictions
[{'score': 0.3571370542049408,
'label': 'human face',
'box': {'xmin': 180, 'ymin': 71, 'xmax': 271, 'ymax': 178}},
{'score': 0.28099656105041504,
'label': 'nasa badge',
'bo... |
[
0.015164312,
-0.016115857,
0.016825741,
-0.0012045357,
-0.025283923,
-0.049510572,
0.014001313,
0.024528729,
-0.015164312,
0.054283403,
0.0030226673,
0.008767812,
0.016191376,
0.0020918897,
0.0024015196,
0.0014424222,
0.023441248,
-0.018819455,
-0.046368964,
-0.013314085,
-0.... | xmin, ymin, xmax, ymax = box.values()
draw.rectangle((xmin, ymin, xmax, ymax), outline="red", width=1)
draw.text((xmin, ymin), f"{label}: {round(score,2)}", fill="white")
image
Text-prompted zero-shot object detection by hand
Now that you've seen how to use the zero-shot object detection pipeline, let's rep... |
[
0.02190706,
-0.0004758601,
0.0003134578,
-0.0038730712,
0.020757241,
-0.0071220635,
-0.015000586,
-0.0030201634,
-0.01028028,
0.0426643,
-0.021301892,
-0.023798207,
0.012806854,
-0.036521852,
-0.0045009325,
0.035008933,
-0.018790446,
-0.08484446,
-0.050652508,
-0.018775318,
-... | Use the processor to prepare the inputs for the model. The processor combines an image processor that prepares the
image for the model by resizing and normalizing it, and a [CLIPTokenizer] that takes care of the text inputs.
text_queries = ["hat", "book", "sunglasses", "camera"]
inputs = processor(text=text_queries, i... |
[
0.010320723,
-0.018791234,
-0.012351622,
-0.019195968,
-0.040733613,
-0.041080527,
-0.016333919,
0.0005849675,
0.010479726,
0.071001954,
0.008318734,
-0.02001989,
0.07464456,
-0.027926663,
-0.0071551236,
0.04718045,
0.012488943,
-0.03362185,
-0.05067851,
-0.03099108,
0.003230... | from transformers import AutoProcessor, AutoModelForZeroShotObjectDetection
model = AutoModelForZeroShotObjectDetection.from_pretrained(checkpoint)
processor = AutoProcessor.from_pretrained(checkpoint)
Let's take a different image to switch things up.
import requests
url = "https://unsplash.com/photos/oj0zeY2Ltk4/dow... |
[
0.022772415,
-0.007296845,
-0.0020375692,
-0.06298329,
0.0022135896,
-0.05257142,
0.016272105,
0.029983915,
0.004420067,
0.06742114,
0.04264316,
-0.0006405186,
0.03573036,
0.03797773,
0.0085841045,
0.019941865,
-0.02257328,
-0.03948546,
-0.033881254,
0.017438464,
-0.019628938... | Let's visualize the predictions:
from PIL import ImageDraw
draw = ImageDraw.Draw(image)
for prediction in predictions:
box = prediction["box"]
label = prediction["label"]
score = prediction["score"]
xmin, ymin, xmax, ymax = box.values()
draw.rectangle((xmin, ymin, xmax, ymax), outline="red", ... |
[
-0.0053418716,
-0.026127001,
0.009231444,
-0.020188393,
-0.016852418,
-0.00913798,
-0.029621145,
0.010345832,
-0.007405286,
0.07114827,
0.00062010286,
-0.0009831776,
0.02809695,
-0.016909935,
-0.0032820518,
0.014767435,
-0.0068660663,
-0.052340277,
-0.054497156,
-0.022158341,
... |
import torch
with torch.no_grad():
outputs = model(**inputs)
target_sizes = torch.tensor([im.size[::-1]])
results = processor.post_process_object_detection(outputs, threshold=0.1, target_sizes=target_sizes)[0]
draw = ImageDraw.Draw(im)
scores = results["scores"].tolist()
labels = results["labels"].toli... |
[
0.0039773667,
-0.001144519,
0.008103978,
-0.019759975,
-0.015155781,
-0.00197749,
-0.019580882,
0.0217897,
0.0022200122,
0.058802344,
-0.026341658,
-0.0018161193,
0.00670481,
-0.01267086,
-0.01746161,
0.0030613784,
-0.0008758788,
-0.04554943,
-0.0327144,
0.0042086956,
-0.0223... | text_queries = ["hat", "book", "sunglasses", "camera"]
inputs = processor(text=text_queries, images=im, return_tensors="pt")
Pass the inputs through the model, post-process, and visualize the results. Since the image processor resized images before
feeding them to the model, you need to use the [~OwlViTImageProcessor.... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.