📄 ethos_binary¶
Note
ID: cards.ethos_binary | Type: TaskCard
{
"loader": {
"name": "binary",
"path": "ethos",
"type": "load_hf"
},
"preprocess_steps": [
{
"page_size": 1000000,
"type": "shuffle"
},
{
"mix": {
"test": "train[80%]",
"train": "train[20%]"
},
"type": "split_random_mix"
},
{
"mappers": {
"label": {
"0": "not hate speech",
"1": "hate speech"
}
},
"type": "map_instance_values"
},
{
"fields": {
"classes": [
"not hate speech",
"hate speech"
],
"text_type": "sentence",
"type_of_class": "hate speech"
},
"type": "add_fields"
}
],
"task": "tasks.classification.multi_class",
"templates": {
"items": [
{
"input_format": "Given this {text_type}: {text}. Classify if it contains {type_of_class}. classes: {classes}.",
"output_format": "{label}",
"postprocessors": [
"processors.take_first_non_empty_line"
],
"type": "input_output_template"
},
{
"input_format": "Does the following {text_type} contains {type_of_class}? Answer only by choosing one of the options {classes}. {text_type}: {text}.",
"output_format": "{label}",
"postprocessors": [
"processors.take_first_non_empty_line"
],
"type": "input_output_template"
},
{
"input_format": "Given this {text_type}: {text}. Classify if it contains {type_of_class}. classes: {classes}. I would classify this {text_type} as: ",
"output_format": "{label}",
"postprocessors": [
"processors.take_first_non_empty_line",
"processors.lower_case_till_punc"
],
"type": "input_output_template"
},
{
"input_format": "Given this {text_type}: {text}. Classify if it contains {type_of_class}. classes: {classes}. I would classify this {text_type} as: ",
"output_format": "{label}",
"postprocessors": [
"processors.take_first_non_empty_line",
"processors.hate_speech_or_not_hate_speech"
],
"type": "input_output_template"
}
],
"type": "templates_list"
},
"type": "task_card"
}
Explanation about TaskCard¶
TaskCard delineates the phases in transforming the source dataset into a model-input, and specifies the metrics for evaluation of model-output.
- Attributes:
loader: specifies the source address and the loading operator that can access that source and transform it into a unitxt multistream.
preprocess_steps: list of unitxt operators to process the data source into a model-input.
task: specifies the fields (of the already (pre)processed instance) making the inputs, the fields making the outputs, and the metrics to be used for evaluating the model output.
templates: format strings to be applied on the input fields (specified by the task) and the output fields. The template also carries the instructions and the list of postprocessing steps, to be applied to the model output.
Explanation about Shuffle¶
Shuffles the order of instances in each page of a stream.
- Args (of superclass):
page_size (int): The size of each page in the stream. Defaults to 1000.
Explanation about InputOutputTemplate¶
Generate field ‘source’ from fields designated as input, and fields ‘target’ and ‘references’ from fields designated as output, of the processed instance.
Args specify the formatting strings with which to glue together the input and output designated fields of the processed instance into one string (‘source’ and ‘target’), and into a list of strings (‘references’).
Explanation about AddFields¶
Adds specified fields to each instance in a given stream or all streams (default) If fields exist, updates them.
- Args:
- fields (Dict[str, object]): The fields to add to each instance.
Use ‘/’ to access inner fields
use_deepcopy (bool) : Deep copy the input value to avoid later modifications
- Examples:
# Add a ‘classes’ field with a value of a list “positive” and “negative” to all streams AddFields(fields={“classes”: [“positive”,”negatives”]})
# Add a ‘start’ field under the ‘span’ field with a value of 0 to all streams AddFields(fields={“span/start”: 0}
# Add a ‘classes’ field with a value of a list “positive” and “negative” to ‘train’ stream AddFields(fields={“classes”: [“positive”,”negatives”], apply_to_stream=[“train”]})
# Add a ‘classes’ field on a given list, prevent modification of original list # from changing the instance. AddFields(fields={“classes”: alist}), use_deepcopy=True) # if now alist is modified, still the instances remain intact.
Explanation about MapInstanceValues¶
A class used to map instance values into other values.
This class is a type of StreamInstanceOperator, it maps values of instances in a stream using predefined mappers.
- Attributes:
- mappers (Dict[str, Dict[str, str]]): The mappers to use for mapping instance values.
Keys are the names of the fields to be mapped, and values are dictionaries that define the mapping from old values to new values.
- strict (bool): If True, the mapping is applied strictly. That means if a value
does not exist in the mapper, it will raise a KeyError. If False, values that are not present in the mapper are kept as they are.
- process_every_value (bool): If True, all fields to be mapped should be lists, and the mapping
is to be applied to their individual elements. If False, mapping is only applied to a field containing a single value.
- Examples:
MapInstanceValues(mappers={“a”: {“1”: “hi”, “2”: “bye”}}) replaces ‘1’ with ‘hi’ and ‘2’ with ‘bye’ in field ‘a’ in all instances of all streams: instance {“a”:”1”, “b”: 2} becomes {“a”:”hi”, “b”: 2}.
MapInstanceValues(mappers={“a”: {“1”: “hi”, “2”: “bye”}}, process_every_element=True) Assuming field ‘a’ is a list of values, potentially including “1”-s and “2”-s, this replaces each such “1” with “hi” and “2” – with “bye” in all instances of all streams: instance {“a”: [“1”, “2”], “b”: 2} becomes {“a”: [“hi”, “bye”], “b”: 2}.
MapInstanceValues(mappers={“a”: {“1”: “hi”, “2”: “bye”}}, strict=True) To ensure that all values of field ‘a’ are mapped in every instance, use strict=True. Input instance {“a”:”3”, “b”: 2} will raise an exception per the above call, because “3” is not a key in the mapper of “a”.
MapInstanceValues(mappers={“a”: {str([1,2,3,4]): ‘All’, str([]): ‘None’}}, strict=True) replaces a list [1,2,3,4] with the string ‘All’ and an empty list by string ‘None’. Note that mapped values are defined by their string representation, so mapped values must be converted to strings.
Explanation about SplitRandomMix¶
Splits a multistream into new streams (splits), whose names, source input stream, and amount of instances, are specified by arg ‘mix’.
The keys of arg ‘mix’, are the names of the new streams, the values are of the form: ‘name-of-source-stream[percentage-of-source-stream]’ Each input instance, of any input stream, is selected exactly once for inclusion in any of the output streams.
Examples: When processing a multistream made of two streams whose names are ‘train’ and ‘test’, by SplitRandomMix(mix = { “train”: “train[99%]”, “validation”: “train[1%]”, “test”: “test” }) the output is a multistream, whose three streams are named ‘train’, ‘validation’, and ‘test’. Output stream ‘train’ is made of randomly selected 99% of the instances of input stream ‘train’, output stream ‘validation’ is made of the remaining 1% instances of input ‘train’, and output stream ‘test’ is made of the whole of input stream ‘test’.
When processing the above input multistream by SplitRandomMix(mix = { “train”: “train[50%]+test[0.1]”, “validation”: “train[50%]+test[0.2]”, “test”: “test[0.7]” }) the output is a multistream, whose three streams are named ‘train’, ‘validation’, and ‘test’. Output stream ‘train’ is made of randomly selected 50% of the instances of input stream ‘train’ + randomly selected 0.1 (i.e., 10%) of the instances of input stream ‘test’. Output stream ‘validation’ is made of the remaining 50% instances of input ‘train’+ randomly selected 0.2 (i.e., 20%) of the original instances of input ‘test’, that were not selected for output ‘train’, and output stream ‘test’ is made of the remaining instances of input ‘test’.
References: processors.take_first_non_empty_line, tasks.classification.multi_class, processors.lower_case_till_punc, processors.hate_speech_or_not_hate_speech
Read more about catalog usage here.