Replace as_target context managers by direct calls

[sgugger]

What does this PR do?

This PR deprecates the context managers as_target_tokenizer and as_target_processor to the profit of passing more arguments to the __call__ method (or the pad method for certain processors).

Let's look at one example for a tokenizer in a seq2seq task. The current workflow is:

# Tokeniz inputs
model_inputs = tokenizer(inputs, max_length=128, truncation=True)
# Tokenize labels inside the context manager
with tokenizer.as_target_tokenizer():
    labels = tokenizer(targets, max_length=128, truncation=True)
# Put everything together
model_inputs["labels"] = labels["input_ids"]

After this PR, this simply becomes:

model_inputs = tokenizer(inputs, text_target=targets, max_length=128, truncation=True)

which is more natural and way easier.

It gets tricky if:

1. you want to tokenizer the targets with different keyword arguments
2. you want to add more than the input IDs for the targets to your model inputs.
   In this case you still need to do two calls:

# Tokenize inputs
model_inputs = tokenizer(inputs, max_length=128, truncation=True)
# Tokenize labels
labels = tokenizer(text_target=targets, max_length=64, truncation=True)
# Put everything together
model_inputs["labels"] = labels["input_ids"]
model_inputs["labels_mask"] = labels["attention_mask"]

Like before, if you forget to indicate to the tokenizer you are tokenizing labels (here by passing them as text_target=... (and before by tokenizing under the context manager), the labels will be tokenized like the inputs.

For processors, the same changes are done, except you can directly use modality names:

input_values = processor(ds[0]["audio"]["array"], return_tensors="pt")
with processor.as_target_processor():
    labels = processor(ds[0]["text"], return_tensors="pt")
input_values["labels"] = labels["input_ids"]

can now simply be:

input_values = processor(audio=ds[0]["audio"]["array"], text=processor(ds[0]["text"], return_tensors="pt")

Like before, you can also do it in two individual calls (with audio and text) to get the objects if you need to use different values of keyword arguments, or want to do a more complex merge than just taking the label input IDs.

Padding is also treated: previous code required to do something like this:

batch = self.processor.pad(input_features, padding=padding, return_tensors="pt")
with self.processor.as_target_processor():
    labels_batch = self.processor.pad(label_features, padding=self.padding, return_tensors="pt")
batch["labels"] = labels_batch["input_ids"]

This can now be done with:

batch = self.processor.pad(input_features, labels=label_features, padding=padding, return_tensors="pt")

or in two calls like before if something more involved (different keyword arguments for labels or accessing more than the labels input IDs) is needed.

This comes at no breaking change.

Current version does not touch any of the documentation, examples and tests (to double-check there is no breaking change), those will need to be adapted. This can be done in this PR or in followups if you prefer to read lighter diffs.

[HuggingFaceDocBuilderDev]

The documentation is not available anymore as the PR was closed or merged.

[amyeroberts]

All looks good to me!

[patrickvonplaten]

Checked the audio processors and it looks very nice to me! Thanks for doing the refactor here. Like the simple naming of "audio" and "text"

[LysandreJik]

Thanks for your efforts, this looks good!

[LysandreJik]

That's a clean API :)

[amyeroberts]

LGTM! Thanks for doing this refactor - the result looks 🤩

Only one comment where I think the call to the tokenizer might want to be different.