PPLM: Une technique simple de Deep Learning pour générer des phrases avec des attributs spécifiés

introduction

Cet article a été rédigé dans le cadre d'un stage chez Nittetsu Solutions (NSSOL).

Cet article se compose de la structure suivante.

Aperçu

Je vais donner une explication approximative du modèle PPLM expliqué dans cet article.

Qu'est-ce que le modèle de langage Plug and Play?

Le modèle de langage Plug and Play (PPLM) est le modèle proposé dans MODÈLES DE LANGAGE PLUG AND PLAY: UNE APPROCHE SIMPLE POUR LA GÉNÉRATION DE TEXTE CONTRÔLÉE. .. Author Implementation existe également sur Github.

Cette recherche est une recherche qui aborde la tâche de génération de texte contrôlée. La génération de texte contrôlée consiste à générer des phrases qui correspondent aux attributs spécifiés (polarité telle que positive / négative et sujets tels que «politique» et «science») lorsque le modèle de génération de langage génère des phrases.

Qu'est-ce qui est incroyable avec PPLM?

L'avantage de PPLM est qu'il réalise une génération de texte contrôlée simplement en apprenant un nouveau petit modèle pour le modèle de génération de langage existant. Cette grandeur peut être vue en la comparant aux méthodes existantes. Les approches de recherche existantes pour la génération de texte contrôlée peuvent être classées comme suit.

Le premier a des performances suffisantes pour contrôler les attributs, mais présente un problème majeur en termes de coût d'apprentissage. Lorsque vous souhaitez ajouter de nouveaux attributs, vous devez recycler le grand modèle. Ce dernier n'a aucun problème en termes de coût d'apprentissage, mais ses performances semblent nettement inférieures aux premières. La méthode proposée par PPLM présente l'avantage que le coût d'apprentissage est très faible tout en conservant des performances comparables à la première.

Configuration du modèle

PPLM est destiné aux modèles de génération de langage qui utilisent Transformer comme décodeur. Puisque GPT-2 est utilisé dans l'implémentation de l'auteur, il sera décrit en supposant que GPT-2 sera utilisé à l'avenir.

pplm_architecture.png

Il s'agit d'une figure tirée de l'article original de PPLM (https://openreview.net/pdf?id=H1edEyBKDS). Cependant, les lettres bleues ($ H_1, H_2, x_0, x_1, x_2 $) sont mes ajouts. Si vous regardez uniquement la flèche noire dans la figure et ignorez [Modèle d'attribut p (a | x)], ce sera un modèle utilisant le Transformer Decoder original (ci-après dénommé le modèle original). Le LM (Language Model) de la figure est une pile de blocs L Transformer Decoder. $ H_t $ contient les paires clé et valeur d'auto-attention qui se produisent dans chacun de ces blocs de couche L. V_t} ^ {(1)}), ..., ({K_t} ^ {(l)}, {V_t} ^ {(l)})] $$ Ici, $ {K_t} ^ {(i)} et {V_t} ^ {(i)} $ sont les paires Clé et Valeur créées par le bloc Decoder de la i-ième couche à un certain moment. Dans le modèle d'origine, ce $ H_t $ est passé à LM avec le mot produit à l'instant précédent. En d'autres termes $ o_{t+1}, H_{t+1} = \text{LM}(x_t, H_t) $ $ o_ {t + 1} $ est la sortie de LM, et après conversion linéaire par la matrice $ W $ comme suit, la distribution de vraisemblance de tous les mots $ p_ {t + 1} $ est obtenue en appliquant la fonction Softmax. Je vais. $ x_ {t + 1} $ suit cette distribution. $ x_{t+1} \sim p_{t+1} = \text{Softmax}(W o_{t+1}) $ Le modèle original consiste à générer les mots les uns après les autres de cette manière. C'est l'histoire de PPLM. Dans PPLM, le modèle d'attribut connecté reçoit $ H_t $ et $ p (a | x_ {t + 1} représente la plausibilité de $ x_ {t + 1} $ pour l'attribut spécifié $ a $. ) Mettez à jour $ H_t $ pour que $ soit plus grand. Puisque $ \ tilde {p_ {t + 1}} $ est nouvellement calculé sur la base de $ \ tilde {H_t} $ qui est mis à jour à partir de ce $ H_t $, la distribution de la vraisemblance des mots change. Dans la figure, la sortie $ p_3 $ du modèle original avait une forte probabilité de «ok», mais $ \ tilde {p_3} $ avait une forte probabilité de «délicieux». Est tiré.

Conception et apprentissage du modèle d'attribut PPLM

PPLM propose deux méthodes pour la construction du modèle d'attribut $ p (a | x) $. L'un utilise Bag-of-Words et l'autre utilise un discriminateur. Ici, nous allons les expliquer avec le code d'implémentation.

Modèle d'attribut par sac de mots

Ici, un ensemble de mots-clés liés aux attributs est créé à l'avance. Attributs fournis dans l'implémentation de l'auteur comprend "ordinateurs", "fantaisie", "cuisine", "juridique" , "militaire", "politique", "mots_ positifs", "religion", "science", "espace". Par exemple, «science» comprend 48 mots tels que «astronomie», «atome», «biologie», «cellule» et «chimique».

Étant donné l'ensemble de mots clés $ \ {w_1, ..., w_k \} $ pour un attribut $ a $, la distribution de la vraisemblance des mots calculée par le modèle d'origine $ p_ {t + 1} $ L'utilisation de $ p (a | x_ {t + 1}) $, qui représente la plausibilité du mot de sortie $ x_ {t + 1} $ pour l'attribut $ a , peut être considérée comme suit: Je peux le faire. $ p(a|x_{t+1}) = \sum_{i}^k p_{t+1}[w_i] $ Le côté droit de cette équation représente la probabilité qu'un mot de l'ensemble de mots-clés apparaisse, c'est-à-dire la probabilité qu'un mot lié à l'attribut souhaité apparaisse. Je ne l'ai pas écrit dans le papier original,p(a|x_{t+1})(C'est dans le papierp(a|x)Est écrit comme)p(a|p_{t+1})En tant qu'attribut de la distribution de la vraisemblance des motsa$Il peut être plus facile de comprendre si cela convient. De plus, contrairement au discriminateur décrit plus loin, le modèle d'attribut utilisant le sac de mots n'a pas de paramètres d'apprentissage et ne s'entraîne pas.

Modèle d'attribut par discriminateur

Le modèle d'attribut utilisant le sac de mots mentionné ci-dessus était une conception simple, mais il y a un problème. Autrement dit, il existe des cas où il est difficile d'exprimer un attribut uniquement avec un ensemble de mots-clés. Dans de tels cas, le modèle discriminateur décrit dans cette section est utile. Le discriminateur d'attribut est le mot de sortiexAttributs deaReprésente l'unicitép(a|x), Soi-Touche attention,Paire de valeurH_tEn utilisantp(a|H_t)Réinterpréter comme. En d'autres termesH_tEst reçu comme entrée et attributsaNous allons apprendre un discriminateur qui renvoie la vraisemblance de. Dans l'implémentation, ce discriminateur renvoie la logarithmique de la distribution de vraisemblance pour tous les attributs. Jetons un coup d'œil au code réel ci-dessous.

run_pplm_discrim_train.py


class Discriminator(torch.nn.Module):
    """Transformer encoder followed by a Classification Head"""

    def __init__(
            self,
            class_size,
            pretrained_model="gpt2-medium",
            cached_mode=False,
            device='cpu'
    ):
        super(Discriminator, self).__init__()
        self.tokenizer = GPT2Tokenizer.from_pretrained(pretrained_model)
        self.encoder = GPT2LMHeadModel.from_pretrained(pretrained_model)
        self.embed_size = self.encoder.transformer.config.hidden_size
        self.classifier_head = ClassificationHead(
            class_size=class_size,
            embed_size=self.embed_size
        )
        self.cached_mode = cached_mode
        self.device = device

    def get_classifier(self):
        return self.classifier_head

    def train_custom(self):
        for param in self.encoder.parameters():
            param.requires_grad = False
        self.classifier_head.train()

    def avg_representation(self, x):
        mask = x.ne(0).unsqueeze(2).repeat(
            1, 1, self.embed_size
        ).float().to(self.device).detach()  #le masque est utilisé pour ignorer 0 dans le remplissage
        hidden, _ = self.encoder.transformer(x)
        masked_hidden = hidden * mask
        avg_hidden = torch.sum(masked_hidden, dim=1) / (
                torch.sum(mask, dim=1).detach() + EPSILON
        )
        return avg_hidden

    def forward(self, x):
        if self.cached_mode:
            avg_hidden = x.to(self.device)
        else:
            avg_hidden = self.avg_representation(x.to(self.device))

        logits = self.classifier_head(avg_hidden)
        probs = F.log_softmax(logits, dim=-1)

        return probs


class ClassificationHead(torch.nn.Module):
    """Classification Head for  transformer encoders"""

    def __init__(self, class_size, embed_size):
        super(ClassificationHead, self).__init__()
        self.class_size = class_size
        self.embed_size = embed_size
        self.mlp = torch.nn.Linear(embed_size, class_size)

    def forward(self, hidden_state):
        logits = self.mlp(hidden_state)
        return logits

La classe Discriminator se compose de deux parties: un modèle pré-entraîné et un ClassificationHead à apprendre. Nous ne recyclons pas du tout le modèle formé. Lors de l'exécution de PPLMp(a|x)(Plus précisémentp(a|H_t)) Est utilisé uniquement pour la partie ClassificationHead. Je vais expliquer le traitement de Discriminator. L'entrée x est un mini-lot, et c'est un Tensor dans lequel des phrases représentant chaque mot par ID sont alignées pour la taille du lot. Ceci est traité par le modèle pré-entraîné et masqué est généré.

hidden, _ = self.encoder.transformer(x)

Ce caché est comme une représentation distribuée de chaque mot d'entrée x. Ensuite, puisque ce masqué contient des mots supplémentaires en raison du remplissage dû au traitement par lots de Tensor, masquez-le pour l'ignorer. Cela fera la représentation distribuée des mots ajoutés par padding 0 (masked_hidden). Enfin, avg_hidden peut être obtenu en ajoutant les expressions distribuées dans chaque phrase de ce masked_hidden. Si vous pensez que les mots d'une phrase sont additionnés, cela peut être interprété comme une représentation distribuée de la phrase. Cet avg_hidden est l'entrée de ClassificationHead. ClassificationHead est un réseau neuronal sans couche intermédiaire et uniquement des couches d'entrée et de sortie. Le nombre de nœuds dans la couche d'entrée est le nombre de dimensions de la représentation distribuée de avg_hidden, et le nombre de nœuds dans la couche de sortie est le nombre d'attributs. La sortie est un logit, qui est passé par une fonction softmax pour prendre une valeur logarithmique supplémentaire.

logits = self.classifier_head(avg_hidden)
probs = F.log_softmax(logits, dim=-1)

La valeur (probabilité logarithmique négative) de ce probs (= output_t) correspondant à la classe de réponse correcte (target_t) devient une perte, et cette perte est un backprop pour l'apprentissage.

loss = F.nll_loss(output_t, target_t)
loss.backward(retain_graph=True)
optimizer.step()

Exécutez PPLM

Après avoir appris le modèle d'attribut dans le chapitre précédent, l'étape suivante consiste à exécuter réellement PPLM. En fait, un modèle d'attribut entraîné est préparé, donc si vous souhaitez simplement vérifier l'opération, vous n'avez pas besoin de la réapprendre. De plus, aucun apprentissage n'est requis lors de l'utilisation du modèle d'attributs par sac de mots. Comme mentionné dans [Configuration du modèle](# Configuration du modèle), PPLM contrôle le mot de sortie en utilisant $ \ tilde {H_t} $ qui est une version mise à jour de $ H_t $ du modèle d'origine. Cette mise à jour se fait en fait comme suit.

\begin{align}
\tilde{H_t} &= H_t + \Delta H_t \\
\Delta H_t & \leftarrow \Delta H_t + \alpha \frac{\nabla_{\Delta H_t} \log p(a | H_t + \Delta H_t)}{||\nabla_{\Delta H_t} \log p(a | H_t + \Delta H_t)||^{\gamma}}
\end{align}

$ \ Alpha, \ gamma $ sont des hyper paramètres. Ce que nous faisons ici, c'est le calcul de la mise à jour $ \ Delta H_t $ qui augmente la probabilité de l'attribut $ a $. Ce $ \ Delta H_t $ lui-même est calculé et mis à jour plusieurs fois, puis ajouté à $ H_t $. Ce nombre est dit être 3 à 10 fois (la valeur par défaut dans le code d'implémentation est 3). Cette mise à jour est effectuée dans la fonction perturb_past de run_pplm.py. Tout d'abord, examinons l'implémentation par Attribute Model en utilisant Bag-of-Words.

loss = 0.0
bow_logits = torch.mm(probs, torch.t(one_hot_bow))
bow_loss = -torch.log(torch.sum(bow_logits))
loss += bow_loss

Bien que le processus soit omis, probs équivaut à $ p_ {t + 1} $ et est la distribution de la probabilité de tous les mots dans la connaissance du modèle de langage. one_hot_bow représente chaque mot appartenant au mot-clé d'attribut défini comme un vecteur unique pour tous les mots dans la connaissance du modèle de langage. La somme des bow_logits multipliée par ceux-ci est $ \ sum_ {i} ^ k p_ {t + décrite dans [Attribute Model by Bag-of-Words](-attribute-model by # bag-of-words). 1} [w_i] Correspond au calcul de $. La logarithmique négative de cette somme est bow_loss. Cette bow_loss correspond à $ - \ log p (a | H_t + \ Delta H_t) $.

Ensuite, l'implémentation par le modèle d'attribut utilisant le discriminateur est la suivante.

ce_loss = torch.nn.CrossEntropyLoss()

prediction = classifier(new_accumulated_hidden / (curr_length + 1 + horizon_length))
label = torch.tensor(prediction.shape[0] * [class_label],
                     device=device,
                     dtype=torch.long)
discrim_loss = ce_loss(prediction, label)
loss += discrim_loss

Le classificateur est la partie ClassificationHead du discriminateur appris dans le chapitre précédent. Je vais expliquer new_accumulated_hidden. La sortie d'état masqué de la dernière couche du transformateur à 12 couches calculée en donnant le $ \ tilde {H_t} $ mis à jour à GPT-2 est définie sur [Modèle d'attribut par discriminateur](# par discriminateur -Comme avec avg_hidden expliqué dans (modèle-attribut), considérez la somme des expressions distribuées. Faites ceci pour le $ H_t $ non mis à jour de la même manière, et ajoutez les deux ensemble pour obtenir new_accumulated_hidden. Vous ne connaissez peut-être pas cette zone à moins que vous ne suiviez réellement le code, mais il peut être correct de reconnaître que vous entrez dans l'état caché dans le classificateur. La valeur par défaut pour curr_length est le nombre de mots d'entrée pour GPT-2 pour le moment, et la valeur par défaut pour horizon_length est 1. Le class_label utilisé pour le label est donné par l'utilisateur lorsque run_pplm.py est exécuté. Par exemple, un index pré-assigné pour la classe positive. Trouvez la perte d'entropie croisée entre cette étiquette et la prédiction. La perte discrim_loss ainsi calculée correspond également à $ - \ log p (a | H_t + \ Delta H_t) $. Le sac de mots et le modèle d'attribut du discriminateur peuvent être utilisés ensemble. Dans ce cas, ajoutez bow_loss et discrim_loss.

loss = 0.0
loss += bow_loss
loss += discrim_loss

Jusqu'ici\log p(a | H_t + \Delta H_t)Est calculé (\log p(a | H_t + \Delta H_t) = - \text{loss}), Puis en trouvant le dégradé\Delta H_tPeut être mis à jour, mais cela seul ne fonctionnera pas. Ce que j'ai pensé jusqu'ici estp(a|x)(Oup(a|H_t)) A juste été augmenté.p(x)Il ne se considère pas. Par conséquent, il est possible que la phrase générée ne soit pas naturelle. Ce problème est résolu par deux approches. L'un est la KL-Divergence entre $ p_ {t + 1} $ et $ \ tilde {p_ {t + 1}} , c'est-à-dire $ \text{kl_loss} = \sum_i \tilde{p_{t+1}}[w_i] \log{ \frac{ \tilde{p_{t+1}}[w_i] }{ p_{t+1}[w_i] } } $$ Est de le rendre plus petit. Jetons un coup d'œil à l'implémentation.

kl_loss = kl_scale * (
    (corrected_probs * (corrected_probs / unpert_probs).log()).sum()
)
loss += kl_loss

Ici, corrected_probs est $ \ tilde {p_ {t + 1}} $ et unpert_probs est $ p_ {t + 1} $. kl_scale est un hyper paramètre, et en gros, il devrait être défini sur 0,01. Le kl_loss calculé est ajouté à bow_loss, discrim_loss ou à leur somme. Lors de la mise à jour de $ \ Delta H_t $, tous sont déplacés ensemble dans la direction du dégradé.

KL-Divergence est la seule contre-mesure au stade de la conception du renouvellement. Une autre approche consiste à échantillonner les mots en fonction de leur probabilité après avoir calculé $ \ tilde {p_ {t + 1}} . L'échantillonnage est effectué comme suit. $ x_{t+1} \sim \frac{1}{\beta} \left( \tilde{p_{t+1}}^{\gamma_{gm}} {p_{t+1}}^{1-\gamma_{gm}} \right) $$ Ce que signifie cet échantillonnage, c'est que non seulement la distribution mise à jour $ \ tilde {p_ {t + 1}} $ mais aussi les $ p_ {t + 1} $ avant la mise à jour sont prises en compte lors de l'échantillonnage. $ \ Beta $ est un coefficient de normalisation à établir comme une simple distribution de probabilité, $ \ tilde {p_ {t + 1}} ^ {\ gamma_ {gm}} {p_ {t + 1}} ^ {1- \ C'est la somme de gamma_ {gm}} $. $ \ Gamma_ {gm} $ est un hyper paramètre, et quand $ \ gamma_ {gm} $ s'approche de 1, il s'approche de $ \ tilde {p_ {t + 1}} $, et lorsqu'il s'approche de 0, il s'approche de $ p_ {t + 1}. Il approche $. En fait, il semble que $ \ gamma_ {gm} $ devrait être mis à 0,8 $ \ sim 0,95 $. En d'autres termes, la distribution après la mise à jour ne doit être considérée que peu, et la distribution avant la mise à jour doit être sérieusement considérée. La mise en œuvre est la suivante.

pert_probs = ((pert_probs ** gm_scale) * (unpert_probs ** (1 - gm_scale)))
pert_probs = top_k_filter(pert_probs, k=top_k, probs=True)
if torch.sum(pert_probs) <= 1:
    pert_probs = pert_probs / torch.sum(pert_probs)

if sample:
    last = torch.multinomial(pert_probs, num_samples=1)
else:
    _, last = torch.topk(pert_probs, k=1, dim=-1)

La première ligne calcule $ \ tilde {p_ {t + 1}} ^ {\ gamma_ {gm}} {p_ {t + 1}} ^ {1- \ gamma_ {gm}} $. Dans la deuxième ligne, nous filtrons pour ne conserver que les k mots avec la plus grande probabilité afin que les mots avec une probabilité trop faible n'apparaissent pas lors de l'échantillonnage. L'opération sur les lignes 3-4 est l'opération de division par $ \ beta $. Les lignes 6 à 7 sont échantillonnées selon la distribution de vraisemblance et les lignes 8 à 9 échantillonnent avidement les mots avec le maximum de vraisemblance.

Ce qui précède est l'idée de PPLM de mettre à jour $ H_t $ et de concevoir un échantillonnage.

Exemple de test

Voici un exemple de test réel. Author Implementation a deux exemples d'instructions, alors essayez-les.

Exemple de modèle PPLM Bag-of-Words

Tout d'abord, à propos de PPLM utilisant Bag-of-Words. Utilisez les instructions suivantes mises en œuvre par l'auteur à titre d'essai.

python run_pplm.py -B military --cond_text "The potato" --length 50 --gamma 1.5 --num_iterations 3 --num_samples 10 --stepsize 0.03 --window_length 5 --kl_scale 0.01 --gm_scale 0.99 --colorama --sample

-Β militaire spécifie le modèle Bag-of-Words de l'attribut militaire. Voici les résultats.

Unperturbed generated text <|endoftext|>The potato is probably the world's most widely eaten plant. But what if it's also the most dangerous?

In the last two decades, there's been a dramatic decrease in potato crop damage from crop rot and disease. The decline, which started in

Perturbed generated text 1 <|endoftext|>The potato-flour soup that is the best way to start a weekend! The following recipe is one of several that I have been working on over the past few months. I think it is the best of them. It uses all the elements of the

Perturbed generated text 2 <|endoftext|>The potato bomb and the anti-Semitic attack that killed four Jewish students at a Jewish school in France are the most recent examples of bomb threats targeting Israeli facilities. The latest bomb threat targeting a U.S. nuclear facility, the bomb was sent out over the

Perturbed generated text 3 <|endoftext|>The potato chip explosion has been a boon to the world's food industry since its release in late March. A handful of companies have already announced plans to produce chips using the chips, including Chipotle Mexican Grill Corp.'s parent company, Taco Bell Corp.'s

Perturbed generated text 4 <|endoftext|>The potato is a very popular and delicious vegetable in many countries, but it can also cause severe health problems for people. The health of your body depends on your diet. If your diet doesn't include enough protein to get through the meal, or if you are

Perturbed generated text 5 <|endoftext|>The potato plant, which is a member of the same family as wheat, can be found around the world. It's also used to make potato chips, bread, and other food products.

The Plant

The plant grows as a seed and produces

Perturbed generated text 6 <|endoftext|>The potato bomb has been a controversial weapon for years. The device is packed with bomb-like devices and packed on a bomb-filled potato bomb. It's a bomb that detonates in the bomb-packed potato bomb and explodes in the potato bomb. So

Perturbed generated text 7 <|endoftext|>The potato has a lot in common with the human earworm: The first, and only, time you hear it, you'll hear the sound of the potato in your ear as well.

It's the first sound you hear when your cat or dog

Perturbed generated text 8 <|endoftext|>The potato salad is coming to a restaurant near you!

The new restaurant, in the heart of downtown Chicago, will be named the Potato Salad.

A photo posted by @the_mike_barnes on Aug 7, 2016 at

Perturbed generated text 9 <|endoftext|>The potato is a staple in many people's diet, and it is an easy food to make in your home.

The best potato chips in the world are made by hand using only potatoes.

The potato is a staple in many people's diet

Perturbed generated text 10 <|endoftext|>The potato bomb is an improvised explosive device, typically containing one bomb and no more than 10 grams of explosive and containing no explosive material.

Bombardment of an aircraft aircraft, a tank truck or explosive device

Bombardment of an aircraft aircraft

Génère des instructions indépendantes pour le nombre de num_samples spécifié au moment de l'exécution (10 cette fois). Les mots surlignés en rouge sont liés à l'attribut. Cela peut être affiché en rouge sur la sortie standard en spécifiant --colorama à l'exécution. Regardons un exemple de génération. Premièrement, il n'y a aucun élément militaire dans la déclaration de génération de modèle non contrôlée d'origine. Pour les phrases contrôlées, le mot «bombe» est souvent trouvé pour 2, 6 et 10. Cependant, je n'ai pas l'impression que les autres exemples sont des déclarations militaires. Attributs militaires commençant par La pomme de terre La phrase a peut-être été un peu difficile.

Exemple de modèle Discriminator PPLM

Essayez un modèle qui utilise un discriminateur d'attribut. L'exécution est la déclaration suivante de la mise en œuvre de l'auteur.

python run_pplm.py -D sentiment --class_label 2 --cond_text "My dog died" --length 50 --gamma 1.0 --num_iterations 10 --num_samples 10 --stepsize 0.04 --kl_scale 0.01 --gm_scale 0.95 --sample

Voici les résultats.

Unperturbed generated text <|endoftext|>My dog died in February, after suffering from severe arthritis. He had been suffering with a terrible cold that was causing his skin to break. I couldn't afford a replacement dog and couldn't afford to have him taken to the vet. I knew the vet would be

Perturbed generated text 1 <|endoftext|>My dog died of a heart attack at the age of 88, his son said, and her death has shocked and brought closure to the family. (Published Wednesday, March 12, 2017)

A mother who was found dead at home with a heart attack on

Perturbed generated text 2 <|endoftext|>My dog died from a rare and potentially deadly form of a rare form of sickle cell disease.

A rare form of sickle cell is called hemizygaly in the families.

The family is an important part of the game and it's

Perturbed generated text 3 <|endoftext|>My dog died after being shot.

A woman in the United States died after a man in his 20s opened fire at her home in North Carolina and injured several others.

On March 12 a neighbor heard a woman screaming. After she ran outside to

Perturbed generated text 4 <|endoftext|>My dog died of a heart attack, after suffering from a heart attack.

The title text of this page has a a a

of of the work and work in to be an in a way, that the idea of the idea to a

Perturbed generated text 5 <|endoftext|>My dog died from a rare form of cancer that was not known before.

The rare form of brain cancer called glioblastomatosis is more common in people of European descent. People of European descent are also at greater risk of glioma

Perturbed generated text 6 <|endoftext|>My dog died from anaphase and I don't know how to give birth to a child with a rare genetic condition, an important personal health gain, with health - "" " The " " " "'The'"'" The book " The word

Perturbed generated text 7 <|endoftext|>My dog died from a rare form of cancer, the Daily Mail reports. "I have a really strong desire to help others and so I am happy to have the chance to help others to be happy and to love their loved ones and that's something I love

Perturbed generated text 8 <|endoftext|>My dog died because I didn't let him go.

I have a 6-year-old, 3-year-old, 1-year-old, 2-year-old, and 2-year-old. I have a very active and

Perturbed generated text 9 <|endoftext|>My dog died of a heart attack while while while I was in the house. I had the old man's head and body, and a large one, I have my hands and feet with me. I have a good time, and the best, as I am

Perturbed generated text 10 <|endoftext|>My dog died from a rare form of cancer, scientists have found.... James M. He he is is is is a

A lot of a lot of a fun!! The Great Escape The Great Escape! The Great Escape! The Great Escape

Contrairement à Bag-of-Words, les mots associés ne peuvent pas être mis en évidence. -D sentiment spécifie un discriminateur de «sentiment» pré-appris. Ce discriminateur discrimine deux classes, "very_positive" et "very_negative", et le class_label = 2 spécifié cette fois représente "very_positive". (Notez que "very_negative" peut être spécifié en définissant class_label = 3). Ceci est un exemple de tentative de générer une phrase positive pour le début qui semble générer uniquement une phrase négative "Mon chien est mort". Regardons chaque exemple. Le texte généré du modèle d'origine sans contrôle d'attribut est pessimiste. Quant aux phrases générées contrôlées, 2, 5, 7 etc. sont générées des phrases relativement positives (ou plutôt non négatives). Des mots tels que rare et amour ressortent. Puisque les négatifs de 1, 3, 4, 6, 8, 9, 10 etc. n'ont pas disparu ou que les phrases ne sont pas naturelles, il est difficile de les générer correctement si le début de la phrase et les attributs ne correspondent pas. Vous pouvez voir la situation.

Essayez un exemple qui semble un peu plus facile à générer

L'exemple ci-dessus était une combinaison de débuts de phrase et d'attributs qui seraient difficiles à générer. Associons un peu plus le début de la phrase et les attributs. Définissez le début sur The potato et l'attribut sur positive_words.

python run_pplm.py -B positive_words --cond_text "The potato" --length 50 --gamma 1.5 --num_iterations 3 --num_samples 10 --stepsize 0.03 --window_length 5 --kl_scale 0.01 --gm_scale 0.99 --colorama --sample

Voici les résultats.

Unperturbed generated text <|endoftext|>The potato is probably the world's most widely eaten plant. But what if it's also the most dangerous?

In the last two decades, there's been a dramatic decrease in potato crop damage from crop rot and disease. The decline, which started in

Perturbed generated text 1 <|endoftext|>The potato-like, gluten-free, low-calorie, sweet, and nutritious sweet potato pie recipe. Easy to make, and perfect for those who love to eat sweet, healthy, and filling pie!

When my kids are home from school

Perturbed generated text 2 <|endoftext|>The potato has been a popular favorite since the 1980s. But with its recent popularity and rising popularity, is it time to eat your favorite potato again?

The potato is still a great food to enjoy and enjoy, with its healthy benefits and delicious flavor

Perturbed generated text 3 <|endoftext|>The potato chip craze is in full swing.

The popular snacks have been making the rounds in recent weeks as people seek out fresh and healthier alternatives to fried foods.

But there may have never been a better time to eat these crispy snacks than

Perturbed generated text 4 <|endoftext|>The potato is a very versatile, versatile vegetable and it is a great addition to many tasty salads, soups and stews.

The potato is the star of many salads and stirfries. I love the versatility of potatoes in many recipes.

Perturbed generated text 5 <|endoftext|>The potato is a common dish, so much so in fact that it is often served with pasta. It is often served with rice, or topped with a sweet and savoury sauce.

Serves 4

1 onion

2 cloves garlic

Perturbed generated text 6 <|endoftext|>The potato has become the new darling of American farmers in recent years. Its popularity is so great that it has even been featured in many successful television shows like "The Big Bang Theory".

But there has never been an easier way to prepare your favorite snack

Perturbed generated text 7 <|endoftext|>The potato is a favorite among the health-conscious, so what better time to try a new way to eat them? The recipe below is easy and healthy, and you can easily freeze it, freeze it for later, reheat it for breakfast or lunch,

Perturbed generated text 8 <|endoftext|>The potato salad that inspired the popular dish is one of a number of new varieties of the dish being sold at popular popular restaurants. (Photo: Thinkstock)

When it comes to classic American comfort food, a popular dish that's popular around the country

Perturbed generated text 9 <|endoftext|>The potato is a staple in many people's diet, and it is not only delicious in its own right, but is also a good protein source. It is easy to eat, nutritious, and healthy.

Potato, as we know it, originated

Perturbed generated text 10 <|endoftext|>The potato has been used as an ingredient in everything from salad dressing to soups for decades. However, it was once thought to be a poor performer in the kitchen. In recent years, scientists have shown potatoes to be a promising food source. The research shows

La première phrase originale générée est une phrase qui énonce des faits objectifs et ne donne pas une impression positive. Vous pouvez voir que les autres phrases sont pour la plupart positives (bien que 2 ne soit pas sûr de ce que vous dites, 3 est mieux précédé de jamais ... ).

Après tout, il semble qu'il soit nécessaire de considérer dans une certaine mesure le début de la phrase et la combinaison des attributs. Ceci est également indiqué dans le document comme "difficile à contrôler en fonction de l'attribut".

Points d'amélioration

Long temps d'exécution

Dans cette expérience, nous avons généré une phrase de 50 mots. À ce moment-là, il ne faut que 2-3 secondes pour générer une phrase par le GPT-2 d'origine, mais cela prend environ 22 secondes dans le modèle par Bag-of-Words et 95 secondes dans le modèle par le discriminateur. C'est sur le point de prendre. Cela dépend de la tâche utilisée, mais le goulot d'étranglement est qu'il faut tellement de temps pour créer une phrase d'environ 50 mots. Les paramètres à apprendre sont très peu nombreux par rapport au modèle d'origine, mais les hyper paramètres sont $ \ alpha, \ gamma $, KL-Divergenece kl_loss, $ p_ {t + 1} $ lors de la mise à jour de $ \ Delta H_t $. Et $ \ tilde {p_ {t + 1}} $ pour équilibrer $ \ gamma_ {gm} $, et on pense que prendre trop de temps à exécuter une fois affectera le coût de réglage. Je vais. Je soupçonne que cette longueur est due au fait que les opérations différentielles partielles sont effectuées plusieurs fois lors de la mise à jour de $ H_t $. Dans un réseau normal, il se propage uniquement dans le sens aller, et une telle opération n'existe pas. Ce problème peut être résolu si nous pouvons configurer et apprendre un réseau qui génère $ \ tilde {H_t} $ lorsque $ H_t $ est entré sans différenciation partielle.

Limité aux modèles d'utilisation de Transformer

La mise à jour de $ H_t $, qui est l'idée principale de ce modèle, est limitée au modèle de langage qui utilise Transformer comme décodeur. À l'avenir, cette méthode pourrait ne pas être disponible si différentes structures deviennent courantes.

Résumé

Dans cet article, nous avons expliqué PPLM, une méthode pour générer des phrases qui correspondent à des attributs spécifiés lors de la génération de phrases avec un modèle qui utilise Transformer comme décodeur. L'idée principale de PPLM est de mettre à jour de manière récursive la clé et la valeur de l'attention personnelle de Transformer dans le sens de la génération d'instructions avec des attributs spécifiés par un modèle externe connecté. Cette idée vous permet de contrôler les attributs sans avoir à recycler le grand modèle d'origine. D'après les résultats du test, on peut voir que bien qu'il puisse être contrôlé en général, il est difficile de le générer si le début de la phrase et l'attribut ne sont pas compatibles. Il présente également l'inconvénient que le temps d'exécution sera plus long que le modèle d'origine.

Les références

Ce que j'ai lu

Autre / littérature connexe

Recommended Posts

PPLM: Une technique simple de Deep Learning pour générer des phrases avec des attributs spécifiés
Générez des Pokémon avec Deep Learning
Essayez de créer un réseau de neurones / d'apprentissage en profondeur avec scratch
[Evangelion] Essayez de générer automatiquement des lignes de type Asuka avec Deep Learning
J'ai essayé d'écrire dans un modèle de langage profondément appris
"Minecraft où le yaji vole" Générez du texte approprié avec Deep Learning ~ Collectez des données ~
"Minecraft où le yaji vole" Générer du texte approprié avec Deep Learning ~ Déplacer avec mod ~
J'ai essayé d'extraire le dessin au trait de l'image avec Deep Learning
Effectuez une recherche Twitter à partir de Python et essayez de générer des phrases avec la chaîne de Markov.
Étapes pour créer rapidement un environnement d'apprentissage en profondeur sur Mac avec TensorFlow et OpenCV
Une histoire de prédiction du taux de change avec Deep Learning
Je veux escalader une montagne avec l'apprentissage par renforcement
Learning Deep Forest, un nouveau dispositif d'apprentissage comparable à DNN
Introduction à l'apprentissage automatique à partir de Simple Perceptron
Générez un mot de passe facile à retenir avec apg
Comment faire un simple jeu Flappy Bird avec Pygame
J'ai capturé le projet Toho avec Deep Learning ... je le voulais.
Apprentissage profond du noyau avec Pyro
Essayez le Deep Learning avec FPGA
Introduction au Deep Learning ~ Règles d'apprentissage ~
Apprentissage par renforcement profond 1 Introduction au renforcement de l'apprentissage
Introduction au Deep Learning ~ Rétropropagation ~
À utiliser avec Cabocha pour générer automatiquement des données d'apprentissage "IOB2 tag corpus"
Rubyist a essayé de créer une API simple avec Python + bouteille + MySQL
J'ai essayé de rendre le deep learning évolutif avec Spark × Keras × Docker
Les utilisateurs de Rails essaient de créer un moteur de blog simple avec Django
J'ai recherché une carte similaire de Hearthstone avec Deep Learning
Introduction au Deep Learning (2) - Essayez votre propre régression non linéaire avec Chainer-
Comment créer une API de machine learning sans serveur avec AWS Lambda