def train_ei_reg(emotion, pretrained=None, finetune=True, unfreeze=0):
"""
1. Task EI-reg: Detecting Emotion Intensity (regression)
Given:
- a tweet
- an emotion E (anger, fear, joy, or sadness)
Task: determine the intensity of E that best represents the mental state of
the tweeter—a real-valued score between 0 and 1:
- a score of 1: highest amount of E can be inferred
- a score of 0: lowest amount of E can be inferred
For each language: 4 training sets and 4 test sets: one for each emotion E.
(Note that the absolute scores have no inherent meaning --
they are used only as a means to convey that the instances
with higher scores correspond to a greater degree of E
than instances with lower scores.)
:param emotion: emotions = ["anger", "fear", "joy", "sadness"]
:param pretrained:
:param finetune:
:param unfreeze:
:return:
"""
model_config = TASK1_EIREG
task = 'EI-reg'
X_train, y_train = parse(task=task, emotion=emotion, dataset="train")
X_dev, y_dev = parse(task=task, emotion=emotion, dataset="dev")
X_test, y_test = parse(task=task, emotion=emotion, dataset="gold")
# keep only scores
y_train = [y[1] for y in y_train]
y_dev = [y[1] for y in y_dev]
y_test = [y[1] for y in y_test]
datasets = {
"train": (X_train, y_train),
"dev": (X_dev, y_dev),
"gold": (X_test, y_test),
}
name = model_config["name"] + "_" + emotion
trainer = define_trainer("reg", config=model_config, name=name,
datasets=datasets,
monitor="dev",
pretrained=pretrained, finetune=finetune)
model_training(trainer, model_config["epochs"], unfreeze=unfreeze)
desc = emotion
if pretrained is not None:
desc += "_PT:" + pretrained
if finetune is not None:
desc += "_FT:" + str(finetune)
trainer.log_training(model_config["name"], desc)
def train_v_reg(pretrained=None, finetune=True, unfreeze=0):
"""
3. Task V-reg: Detecting Valence or Sentiment Intensity (regression)
Given:
- a tweet
Task: determine the intensity of sentiment or valence (V)
that best represents the mental state of the tweeter—a real-valued score
between 0 and 1:
a score of 1: most positive mental state can be inferred
a score of 0: most negative mental state can be inferred
For each language: 1 training set, 1 test set.
(Note that the absolute scores have no inherent meaning --
they are used only as a means to convey that the instances
with higher scores correspond to a greater degree of positive sentiment
than instances with lower scores.)
:param pretrained:
:param finetune:
:param unfreeze:
:return:
"""
model_config = TASK1_VREG
task = 'V-reg'
# load the dataset and split it in train and val sets
X_train, y_train = parse(task=task, dataset="train")
X_dev, y_dev = parse(task=task, dataset="dev")
X_test, y_test = parse(task=task, dataset="gold")
# keep only scores
y_train = [y[1] for y in y_train]
y_dev = [y[1] for y in y_dev]
y_test = [y[1] for y in y_test]
datasets = {
"train": (X_train, y_train),
"dev": (X_dev, y_dev),
"gold": (X_test, y_test),
}
name = model_config["name"]
trainer = define_trainer("reg", config=model_config, name=name,
datasets=datasets,
monitor="dev",
pretrained=pretrained, finetune=finetune)
model_training(trainer, model_config["epochs"], unfreeze=unfreeze)
desc = ""
if pretrained is not None:
desc += "PT:" + pretrained
if finetune is not None:
desc += "_FT:" + str(finetune)
trainer.log_training(name, desc)
def train_ei_oc(emotion, pretrained=None, finetune=True, unfreeze=0):
"""
2. Task EI-oc: Detecting Emotion Intensity (ordinal classification)
Given:
a tweet
an emotion E (anger, fear, joy, or sadness)
Task: classify the tweet into one of four ordinal classes of intensity of E
that best represents the mental state of the tweeter:
0: no E can be inferred
1: low amount of E can be inferred
2: moderate amount of E can be inferred
3: high amount of E can be inferred
For each language: 4 training sets and 4 test sets: one for each emotion E.
:param emotion: emotions = ["anger", "fear", "joy", "sadness"]
:param pretrained:
:param finetune:
:param unfreeze:
:return:
"""
model_config = TASK1_EIOC
task = 'EI-oc'
X_train, y_train = parse(task=task, emotion=emotion, dataset="train")
X_dev, y_dev = parse(task=task, emotion=emotion, dataset="dev")
X_test, y_test = parse(task=task, emotion=emotion, dataset="gold")
# keep only scores
y_train = [y[1] for y in y_train]
y_dev = [y[1] for y in y_dev]
y_test = [y[1] for y in y_test]
datasets = {
"train": (X_train, y_train),
"dev": (X_dev, y_dev),
"gold": (X_test, y_test),
}
name = model_config["name"] + "_" + emotion
trainer = define_trainer("clf", config=model_config, name=name,
datasets=datasets,
monitor="dev",
ordinal=True,
pretrained=pretrained,
finetune=finetune)
model_training(trainer, model_config["epochs"], unfreeze=unfreeze,
checkpoint=True)
desc = emotion
if pretrained is not None:
desc += "_PT:" + pretrained
if finetune is not None:
desc += "_FT:" + str(finetune)
trainer.log_training(name, desc)
def train_e_c(pretrained=None, finetune=True, unfreeze=0):
"""
5. Task E-c: Detecting Emotions (multi-label classification)
-- This is a traditional Emotion Classification Task
Given:
- a tweet
Task: classify the tweet as 'neutral or no emotion' or as one, or more,
of eleven given emotions that best represent the mental state
of the tweeter:
- anger (also includes annoyance and rage) can be inferred
- anticipation (also includes interest and vigilance) can be inferred
- disgust (also includes disinterest, dislike and loathing) can be
inferred
- fear (also includes apprehension, anxiety, concern, and terror)
can be inferred
- joy (also includes serenity and ecstasy) can be inferred
- love (also includes affection) can be inferred
- optimism (also includes hopefulness and confidence) can be inferred
- pessimism (also includes cynicism and lack of confidence) can be
inferred
- sadness (also includes pensiveness and grief) can be inferred
- surprise (also includes distraction and amazement) can be inferred
- trust (also includes acceptance, liking, and admiration) can be
inferred
For each language: 1 training set, 1 test set.
(Note that the set of emotions includes the eight basic emotions
as per Plutchik (1980), as well as a few other emotions that are common
in tweets (love, optimism, and pessimism).)
:param pretrained:
:param finetune:
:param unfreeze:
:return:
"""
model_config = TASK1_EC
task = 'E-c'
# load the dataset and split it in train and val sets
X_train, y_train = parse(task=task, dataset="train")
X_dev, y_dev = parse(task=task, dataset="dev")
X_test, y_test = parse(task=task, dataset="gold")
datasets = {
"train": (X_train, y_train),
"dev": (X_dev, y_dev),
"gold": (X_test, y_test),
}
name = model_config["name"]
trainer = define_trainer("mclf", config=model_config, name=name,
datasets=datasets,
monitor="dev",
pretrained=pretrained,
finetune=finetune)
model_training(trainer, model_config["epochs"], unfreeze=unfreeze)
desc = ""
if pretrained is not None:
desc += "PT:" + pretrained
if finetune is not None:
desc += "_FT:" + str(finetune)
trainer.log_training(name, desc)
def train_v_oc(pretrained=None, finetune=True, unfreeze=0):
"""
4. Task V-oc: Detecting Valence (ordinal classification)
-- This is the traditional Sentiment Analysis Task
Given:
- a tweet
Task: classify the tweet into one of seven ordinal classes,
corresponding to various levels of positive and negative sentiment
intensity, that best represents the mental state of the tweeter:
3: very positive mental state can be inferred
2: moderately positive mental state can be inferred
1: slightly positive mental state can be inferred
0: neutral or mixed mental state can be inferred
-1: slightly negative mental state can be inferred
-2: moderately negative mental state can be inferred
-3: very negative mental state can be inferred
For each language: 1 training set, 1 test set.
:param pretrained:
:param finetune:
:param unfreeze:
:return:
"""
model_config = TASK1_VOC
task = 'V-oc'
# load the dataset and split it in train and val sets
X_train, y_train = parse(task=task, dataset="train")
X_dev, y_dev = parse(task=task, dataset="dev")
X_test, y_test = parse(task=task, dataset="gold")
# keep only scores
y_train = [str(y[1]) for y in y_train]
y_dev = [str(y[1]) for y in y_dev]
y_test = [str(y[1]) for y in y_test]
datasets = {
"train": (X_train, y_train),
"dev": (X_dev, y_dev),
"gold": (X_test, y_test),
}
# pass explicit mapping
label_map = {"-3": 0, "-2": 1, "-1": 2, "0": 3, "1": 4, "2": 5, "3": 6, }
inv_label_map = {v: int(k) for k, v in label_map.items()}
transformer = LabelTransformer(label_map, inv_label_map)
name = model_config["name"]
trainer = define_trainer("clf", config=model_config, name=name,
datasets=datasets,
monitor="dev",
ordinal=True,
label_transformer=transformer,
pretrained=pretrained,
finetune=finetune)
model_training(trainer, model_config["epochs"], unfreeze=unfreeze)
desc = ""
if pretrained is not None:
desc += "PT:" + pretrained
if finetune is not None:
desc += "_FT:" + str(finetune)
trainer.log_training(name, desc)
def train_ei_oc(emotion, pretrained=None, finetune=True, unfreeze=0):
"""
2. Task EI-oc: Detecting Emotion Intensity (ordinal classification)
Given:
a tweet
an emotion E (anger, fear, joy, or sadness)
Task: classify the tweet into one of four ordinal classes of intensity of E
that best represents the mental state of the tweeter:
0: no E can be inferred
1: low amount of E can be inferred
2: moderate amount of E can be inferred
3: high amount of E can be inferred
For each language: 4 training sets and 4 test sets: one for each emotion E.
:param emotion: emotions = ["anger", "fear", "joy", "sadness"]
:param pretrained:
:param finetune:
:param unfreeze:
:return:
"""
model_config = TASK1_EIOC
task = 'EI-oc'
X_train, y_train = parse(task=task, emotion=emotion, dataset="train")
X_dev, y_dev = parse(task=task, emotion=emotion, dataset="dev")
X_test, y_test = parse(task=task, emotion=emotion, dataset="gold")
# keep only scores
y_train = [y[1] for y in y_train]
y_dev = [y[1] for y in y_dev]
y_test = [y[1] for y in y_test]
datasets = {
"train": (X_train, y_train),
"dev": (X_dev, y_dev),
"gold": (X_test, y_test),
}
name = model_config["name"] + "_" + emotion
trainer = define_trainer("clf",
config=model_config,
name=name,
datasets=datasets,
monitor="dev",
ordinal=True,
pretrained=pretrained,
finetune=finetune)
model_training(trainer,
model_config["epochs"],
unfreeze=unfreeze,
checkpoint=True)
desc = emotion
if pretrained is not None:
desc += "_PT:" + pretrained
if finetune is not None:
desc += "_FT:" + str(finetune)
trainer.log_training(name, desc)
from dataloaders.task3 import parse
from model.params import TASK3_A, TASK3_B
from utils.train import define_trainer, model_training
TASK = 'a'
# select config by args.task
if TASK == "a":
model_config = TASK3_A
else:
model_config = TASK3_B
X_train, y_train = parse(task=TASK, dataset="train")
X_test, y_test = parse(task=TASK, dataset="gold")
datasets = {
"train": (X_train, y_train),
"gold": (X_test, y_test),
}
name = "_".join([model_config["name"], model_config["token_type"]])
trainer = define_trainer("clf",
config=model_config,
name=name,
datasets=datasets,
monitor="gold")
model_training(trainer, model_config["epochs"])
trainer.log_training(name, model_config["token_type"])
def train_e_c(pretrained=None, finetune=True, unfreeze=0):
"""
5. Task E-c: Detecting Emotions (multi-label classification)
-- This is a traditional Emotion Classification Task
Given:
- a tweet
Task: classify the tweet as 'neutral or no emotion' or as one, or more,
of eleven given emotions that best represent the mental state
of the tweeter:
- anger (also includes annoyance and rage) can be inferred
- anticipation (also includes interest and vigilance) can be inferred
- disgust (also includes disinterest, dislike and loathing) can be
inferred
- fear (also includes apprehension, anxiety, concern, and terror)
can be inferred
- joy (also includes serenity and ecstasy) can be inferred
- love (also includes affection) can be inferred
- optimism (also includes hopefulness and confidence) can be inferred
- pessimism (also includes cynicism and lack of confidence) can be
inferred
- sadness (also includes pensiveness and grief) can be inferred
- surprise (also includes distraction and amazement) can be inferred
- trust (also includes acceptance, liking, and admiration) can be
inferred
For each language: 1 training set, 1 test set.
(Note that the set of emotions includes the eight basic emotions
as per Plutchik (1980), as well as a few other emotions that are common
in tweets (love, optimism, and pessimism).)
:param pretrained:
:param finetune:
:param unfreeze:
:return:
"""
model_config = TASK1_EC
task = 'E-c'
# load the dataset and split it in train and val sets
X_train, y_train = parse(task=task, dataset="train")
X_dev, y_dev = parse(task=task, dataset="dev")
X_test, y_test = parse(task=task, dataset="gold")
datasets = {
"train": (X_train, y_train),
"dev": (X_dev, y_dev),
"gold": (X_test, y_test),
}
name = model_config["name"]
trainer = define_trainer("mclf",
config=model_config,
name=name,
datasets=datasets,
monitor="dev",
pretrained=pretrained,
finetune=finetune)
model_training(trainer, model_config["epochs"], unfreeze=unfreeze)
desc = ""
if pretrained is not None:
desc += "PT:" + pretrained
if finetune is not None:
desc += "_FT:" + str(finetune)
trainer.log_training(name, desc)
def train_ei_reg(emotion, pretrained=None, finetune=True, unfreeze=0):
"""
1. Task EI-reg: Detecting Emotion Intensity (regression)
Given:
- a tweet
- an emotion E (anger, fear, joy, or sadness)
Task: determine the intensity of E that best represents the mental state of
the tweeter—a real-valued score between 0 and 1:
- a score of 1: highest amount of E can be inferred
- a score of 0: lowest amount of E can be inferred
For each language: 4 training sets and 4 test sets: one for each emotion E.
(Note that the absolute scores have no inherent meaning --
they are used only as a means to convey that the instances
with higher scores correspond to a greater degree of E
than instances with lower scores.)
:param emotion: emotions = ["anger", "fear", "joy", "sadness"]
:param pretrained:
:param finetune:
:param unfreeze:
:return:
"""
model_config = TASK1_EIREG
task = 'EI-reg'
X_train, y_train = parse(task=task, emotion=emotion, dataset="train")
X_dev, y_dev = parse(task=task, emotion=emotion, dataset="dev")
X_test, y_test = parse(task=task, emotion=emotion, dataset="gold")
# keep only scores
y_train = [y[1] for y in y_train]
y_dev = [y[1] for y in y_dev]
y_test = [y[1] for y in y_test]
datasets = {
"train": (X_train, y_train),
"dev": (X_dev, y_dev),
"gold": (X_test, y_test),
}
name = model_config["name"] + "_" + emotion
trainer = define_trainer("reg",
config=model_config,
name=name,
datasets=datasets,
monitor="dev",
pretrained=pretrained,
finetune=finetune)
model_training(trainer, model_config["epochs"], unfreeze=unfreeze)
desc = emotion
if pretrained is not None:
desc += "_PT:" + pretrained
if finetune is not None:
desc += "_FT:" + str(finetune)
trainer.log_training(model_config["name"], desc)
def train_v_oc(pretrained=None, finetune=True, unfreeze=0):
"""
4. Task V-oc: Detecting Valence (ordinal classification)
-- This is the traditional Sentiment Analysis Task
Given:
- a tweet
Task: classify the tweet into one of seven ordinal classes,
corresponding to various levels of positive and negative sentiment
intensity, that best represents the mental state of the tweeter:
3: very positive mental state can be inferred
2: moderately positive mental state can be inferred
1: slightly positive mental state can be inferred
0: neutral or mixed mental state can be inferred
-1: slightly negative mental state can be inferred
-2: moderately negative mental state can be inferred
-3: very negative mental state can be inferred
For each language: 1 training set, 1 test set.
:param pretrained:
:param finetune:
:param unfreeze:
:return:
"""
model_config = TASK1_VOC
task = 'V-oc'
# load the dataset and split it in train and val sets
X_train, y_train = parse(task=task, dataset="train")
X_dev, y_dev = parse(task=task, dataset="dev")
X_test, y_test = parse(task=task, dataset="gold")
# keep only scores
y_train = [str(y[1]) for y in y_train]
y_dev = [str(y[1]) for y in y_dev]
y_test = [str(y[1]) for y in y_test]
datasets = {
"train": (X_train, y_train),
"dev": (X_dev, y_dev),
"gold": (X_test, y_test),
}
# pass explicit mapping
label_map = {
"-3": 0,
"-2": 1,
"-1": 2,
"0": 3,
"1": 4,
"2": 5,
"3": 6,
}
inv_label_map = {v: int(k) for k, v in label_map.items()}
transformer = LabelTransformer(label_map, inv_label_map)
name = model_config["name"]
trainer = define_trainer("clf",
config=model_config,
name=name,
datasets=datasets,
monitor="dev",
ordinal=True,
label_transformer=transformer,
pretrained=pretrained,
finetune=finetune)
model_training(trainer, model_config["epochs"], unfreeze=unfreeze)
desc = ""
if pretrained is not None:
desc += "PT:" + pretrained
if finetune is not None:
desc += "_FT:" + str(finetune)
trainer.log_training(name, desc)
def train_v_reg(pretrained=None, finetune=True, unfreeze=0):
"""
3. Task V-reg: Detecting Valence or Sentiment Intensity (regression)
Given:
- a tweet
Task: determine the intensity of sentiment or valence (V)
that best represents the mental state of the tweeter—a real-valued score
between 0 and 1:
a score of 1: most positive mental state can be inferred
a score of 0: most negative mental state can be inferred
For each language: 1 training set, 1 test set.
(Note that the absolute scores have no inherent meaning --
they are used only as a means to convey that the instances
with higher scores correspond to a greater degree of positive sentiment
than instances with lower scores.)
:param pretrained:
:param finetune:
:param unfreeze:
:return:
"""
model_config = TASK1_VREG
task = 'V-reg'
# load the dataset and split it in train and val sets
X_train, y_train = parse(task=task, dataset="train")
X_dev, y_dev = parse(task=task, dataset="dev")
X_test, y_test = parse(task=task, dataset="gold")
# keep only scores
y_train = [y[1] for y in y_train]
y_dev = [y[1] for y in y_dev]
y_test = [y[1] for y in y_test]
datasets = {
"train": (X_train, y_train),
"dev": (X_dev, y_dev),
"gold": (X_test, y_test),
}
name = model_config["name"]
trainer = define_trainer("reg",
config=model_config,
name=name,
datasets=datasets,
monitor="dev",
pretrained=pretrained,
finetune=finetune)
model_training(trainer, model_config["epochs"], unfreeze=unfreeze)
desc = ""
if pretrained is not None:
desc += "PT:" + pretrained
if finetune is not None:
desc += "_FT:" + str(finetune)
trainer.log_training(name, desc)
from model.params import SEMEVAL_2017
from utils.train import define_trainer, model_training
config = SEMEVAL_2017
train = load_data_from_dir(os.path.join(DATA_DIR, 'semeval_2017_4A'))
X = [obs[1] for obs in train]
y = [obs[0] for obs in train]
X_train, X_test, y_train, y_test = train_test_split(X, y,
test_size=0.05,
stratify=y,
random_state=42)
# pass a transformer function, for preparing tha labels for training
label_map = {label: idx for idx, label in
enumerate(sorted(list(set(y_train))))}
inv_label_map = {v: k for k, v in label_map.items()}
transformer = LabelTransformer(label_map, inv_label_map)
datasets = {
"train": (X_train, y_train),
"val": (X_test, y_test),
}
name = "_".join([config["name"], config["token_type"]])
trainer = define_trainer("clf", config=config, name=name, datasets=datasets,
monitor="val", label_transformer=transformer)
model_training(trainer, config["epochs"], checkpoint=True)
args = parser.parse_args()
print(args)
if args.context not in ["none", "mean", "last"]:
raise ValueError("Invalid attention type!")
model_config = TASK2_A
model_config["attention_context"] = args.context
model_config["embed_finetune"] = args.finetune
X_train, y_train = load_task2("train")
X_trial, y_trial = load_task2("trial")
X_test, y_test = load_task2("test")
datasets = {
"train": (X_train, y_train),
"trial": (X_trial, y_trial),
"gold": (X_test, y_test)
}
name = "_".join([model_config["name"], model_config["token_type"]])
trainer = define_trainer("clf", config=model_config, name=name,
datasets=datasets, monitor="gold")
model_training(trainer, model_config["epochs"])
desc = "context:{}, finetuning:{}".format(args.context, str(args.finetune))
trainer.log_training(name, desc)
from dataloaders.task2 import load_task2
from model.params import TASK2_A
from utils.train import define_trainer, model_training
model_config = TASK2_A
X_train, y_train = load_task2("train")
X_trial, y_trial = load_task2("trial")
X_test, y_test = load_task2("test")
datasets = {
"train": (X_train, y_train),
"trial": (X_trial, y_trial),
"gold": (X_test, y_test),
}
name = "_".join([model_config["name"]])
trainer = define_trainer("clf",
config=model_config,
name=name,
datasets=datasets,
monitor="gold",
absolute_path=False,
embedding_size_auto_detect=True)
model_training(trainer, model_config["epochs"], checkpoint=True)