Intelligence artificielle

Déduplication Déduplication – Vers la science des données

Déduplication Déduplication - Vers la science des données


Oui, c'est le problème que je veux vous aider à résoudre. Éliminer ces petits doublons sales qui causent des torts, nuisent à l’efficacité de certaines tâches ou même polluent nos systèmes.

déduplication
/ diːˌdjuːplɪˈkeɪʃ (ə) n /

nom
l'élimination des informations en double ou redondantes, en particulier dans les données informatiques.

"la déduplication supprime les informations répétitives avant de les stocker"

Comme le dit la définition, nous essayons de supprimer les textes / phrases en double, etc. Ce n'est rien d'autre que l'acte de vérifier similaire le texte est l'un pour l'autre. Ils peuvent être exactement identiques comme:
Apprendre en profondeur, c'est génial! et Apprendre en profondeur, c'est génial!.
Ou bien, ils pourraient être très similaires les uns aux autres en termes de ce que la phrase tente de transmettre, comme:
Apprendre en profondeur, c'est génial! et Deep Learning est tellement cool.
Nous savons que ces deux phrases expriment la même chose, et c’est ce que nous voulons que nos machines capturent.

Une telle tâche dans la littérature est appelée Similarité textuelle sémantique (STS). Il s’agit de déterminer comment deux pièces similaires de des textes sont. Cela inclurait non seulement le similitude syntaxique, c’est-à-dire dans quelle mesure les mots utilisés dans les deux phrases sont similaires ou identiques. similitude sémantique qui rend compte de la similitude de ce qui est véhiculé à l’aide des deux phrases, c’est-à-dire que la signification du texte joue un rôle important dans la détermination de ce qui est similaire et non similaire.

Le problème. Oui, c’est notre objectif principal. Résoudre le problème. Laisse moi te donner un exemple. Dites, vous devez envoyer des blagues vraiment drôles (votre blague peut être une phrase ou un tas de phrases) à un groupe de personnes par e-mail (LOL!)et votre patron vous demande de vous assurer que les gens ne reçoivent pas le même genre de blagues. Vous devez donc vous assurer que toutes vos blagues sont uniques et que le contenu ne vous ennuie pas.
Quel travail, sérieusement?

En tant que codeur à part entière, vous décidez d’automatiser cette tâche. Vous avez cette API magique qui vous donne beaucoup de blagues gratuitement et vous écrivez un script pour envoyer les blagues à ce groupe de personnes que votre patron aime. Mais nous ne pouvons pas vraiment faire confiance à cette API magique, n'est-ce pas? Ses magique. Et si l'API vous donne des blagues similaires? Vous ne pouvez pas risquer de contrarier votre patron.
C’est là que vous pouvez utiliser un moteur de déduplication cela garantit qu'aucune blague envoyée ne ressemble à celle envoyée dans le passé.

Mon objectif principal ici est de ne pas parler beaucoup de ces modèles. Mais pour vous aider à les utiliser pour une tâche pratique, quelque chose comme celle énoncée ci-dessus. J’admets qu’envoyer des blagues aux gens pour impressionner votre patron n’est pas très pratique.

Essayons de décomposer ceci en définissant cette mesure de similarité et entre les deux entités sur lesquelles nous essayons de trouver la similarité (littéralement le texte tel quel, ou autre chose?).

d'abord, en parlant de la mesure de similarité, il y en a plusieurs qui peuvent être utilisées. Juste pour être complet, citons quelques exemples:
1. Similarité Jaccard
2 Similitude cosinus
3 Terrassement Distance
4 Jensen-Shannon distance

Mais pour aller droit au but, nous allons utiliser Cosinité Similitude. Mathématiquement, Similitude cosinus est une mesure de similarité entre deux vecteurs (non nuls) d'un espace de produit interne qui mesure le cosinus de l'angle entre eux.

Si deux documents sont similaires et très éloignés l'un de l'autre dans l'espace euclidien, ils pourraient quand même être assez proches l'un de l'autre. Ceci est capturé par la distance cosinus et est donc avantageux.

Deuxièmement, Où utilisons-nous cette distance cosinus? Entre des paires de chaînes de phrases? Nan! C’est là que nous avons utilisé le pouvoir de Traitement du langage naturel et L'apprentissage en profondeur. Nous utilisons vecteurs.

Un vecteur mot / phrase est une rangée de nombres réels (par opposition aux nombres factices) où chaque point capture une dimension de la signification du mot / phrase et où les mots / phrases sémantiquement similaires ont des vecteurs similaires.

Et, encore une fois, il existe de nombreuses méthodes pour obtenir ces vecteurs. Pour en nommer quelques uns:
Incorporation de mots: word2vec, GloVe, intégration de mots BERT, ELMo, etc.
Phrase Enrobage: Incorporation de phrases BERT, encodeur de phrases universel, etc.

Je vais passer directement aux méthodes que j’ai personnellement expérimentées et qui ont fonctionné à merveille pour moi.

                              word2vec + Universal Phrase Encoder

Pour éviter que cela ne soit un article purement axé sur la mise en œuvre (ce à quoi il est destiné), je vais essayer d'expliquer ce que sont ces modèles, très brièvement.

word2vec est disponible en deux variantes: Skip-Gram et Modèle de sac de mots continu (CBOW). Il existe de nombreuses informations sur ces deux variantes si vous souhaitez une explication détaillée. Je serai très croustillant ici. Le modèle de saut de gramme est un peu plus lent, mais fait habituellement un meilleur travail avec des mots peu fréquents. Par conséquent, c'est ce qui est utilisé souvent. Nous allons en parler brièvement.

Vous trouverez ce diagramme dans presque tous les blogues et tutoriels word2vec (modèle Skip-Gram). Dans cette architecture, le modèle utilise le mot actuel pour prédire la fenêtre environnante de mots de contexte. Il pèse plus lourdement les mots de contexte proches que les mots de contexte lointains.

Ici, nous regardons une fenêtre de mots de contexte (2 mots de chaque côté, dans ce cas) et essayons de prédire le mot central.

Déduplication Déduplication Vers la science des données - Déduplication Déduplication - Vers la science des données
L'architecture du modèle Skip-gram (https://arxiv.org/pdf/1301.3781.pdf)

Considérer w (t) est le mot d'entrée, le produit scalaire habituel entre la matrice de pondération et le vecteur d'entrée w (t) est fait par la seule couche cachée. Nous appliquons le softmax fonction au produit scalaire entre le vecteur de sortie de la couche cachée et la matrice de pondération. Cela nous donne les probabilités des mots qui apparaissent dans le contexte de w (t) à l'emplacement actuel du mot.

Ce sont les vecteurs présents dans les couches cachées qui deviennent la représentation vectorielle de ce mot. Mais ce sont ‘incorporation du mot, et nous devons trouver des "phrases similaires". Alors, Comment pouvons-nous obtenir la représentation vectorielle de la phrase au lieu de simplement incorporer un mot?

Un moyen simple et trivial (celui que je vais montrer aujourd'hui) consiste simplement à faire la moyenne du mot incorporant tous les mots de cette phrase. Simple, n'est-ce pas?

Maintenant, pour la partie principale, codons ceci en.

w2vmodel = gensim.models.KeyedVectors.load_word2vec_format(
'models / GoogleNews-vectors-negative300.bin.gz'), binary = True)
def sent2vec(s):
'' '
Recherche de la représentation vectorielle de phrases word2vec @param s: phrase
'' '
mots = str(s).inférieur()
mots = word_tokenize(mots)
mots =[w[wpour w dans mots si ne pas w dans mots_arrêt]
mots =[w[wpour w dans mots si w.Isalpha()]

featureVec = np.zeros((300,), dtype = "float32")
nwords = 0

pour w dans mots:
essayer:
nwords = nwords + 1
featureVec = np.add(featureVec, w2vmodel[w])
sauf:
Continuez
# en moyenne
si nwords> 0:
featureVec = np.divide(featureVec, nwords)
revenir featureVec

def get_w2v_vectors(list_text1, list_text2):
'' '
Calcul de la représentation vectorielle word2vec de la liste de phrases
@param list_text1: première liste de phrases
@param list_text2: deuxième liste de phrases
'' '
impression(“Calculer les premiers vecteurs…”)
text1_vectors = np.zeros((len (list_text1), 300))
pour je, q dans tqdm (énumérer (list_text1)):
text1_vectors[i, :] = sent2vec (q)
text2_vectors = np.zeros((len (list_text2), 300))
pour je, q dans tqdm (énumérer (list_text2)):
text2_vectors[i, :] = sent2vec (q)
revenir text1_vectors, text2_vectors

C'est ça! 🤷‍♂ Vous avez votre phrase incorporant en utilisant word2vec.

Google a présenté une série de modèles pour coder des phrases en vecteurs. Les auteurs l’ont spécifiquement ciblé pour les tâches en aval, c’est-à-dire pour les tâches d’apprentissage par transfert. STS est l'une de ces tâches.

Il existe en deux variantes:
1. Un avec un Transformateur Codeur
2. Un avec un Réseau de moyenne étendue

Chacun d'entre eux ont des objectifs de conception différents:
1. Cible une grande précision au prix d’une plus grande complexité du modèle et d’une plus grande consommation de ressources.
2. Cible l'inférence efficace avec une précision légèrement réduite.

J'ai hyperlien ces deux architectures avec mes blogs préférés qui expliquent chacune d’elles très bien. Concentrons-nous davantage sur la façon de les mettre en œuvre.

usemodel = hub.Module('models / phrase_encoder')def get_use_vectors(list_text1, list_text2):
'' '
Calcul de la représentation vectorielle USE de la liste de phrases
@param list_text1: première liste de phrases
@param list_text2: deuxième liste de phrases
'' '
impression("Calculer les deuxièmes vecteurs ...")
messages1 = list_text1
messages2 = list_text2
num_batches = math.ceil(len (messages1) / BATCH_SIZE) # Réduit la sortie de journalisation.
tf.logging.set_verbosity(tf.logging.ERROR)
message_embeddings1 = []
message_embeddings2 = []
avec tf.Session () comme session:
session.courir([tfglobal_variables_initializer()[tfglobal_variables_initializer()
tf.tables_initializer ()])
pour lot dans plage (num_batches):
impression(batch * BATCH_SIZE, batch *
BATCH_SIZE + BATCH_SIZE)
batch_msgs1 = messages1[batch*BATCH_SIZE:batch*[batch*BATCH_SIZE:batch*
BATCH_SIZE + BATCH_SIZE]
batch_msgs2 = messages2[batch*BATCH_SIZE:batch*[batch*BATCH_SIZE:batch*
BATCH_SIZE + BATCH_SIZE]
message_embeddings1_temp, message_embeddings2_temp = session.courir([usemodel(batch_msgs1), usemodel(batch_msgs2)])

message_embeddings1.ajouter(message_embeddings1_temp)
message_embeddings2.ajouter(message_embeddings2_temp)

all_embedding1 = np.enchaîner(tuple(message_embeddings1))
all_embedding2 = np.enchaîner(tuple(message_embeddings2))
revenir all_embedding1, all_embedding2

Encore une fois, c’est tout! 🤷♂

Maintenant, nous avons la phrase incorporant pour vos blagues de deux modèles différents.

Maintenant nous avons besoin de similitudes cosinus!

def cosinité_similarité(list_vec1, list_vec2):
'' '
Calcul de la similarité cosinus entre deux représentations vectorielles
@param list_text1: première liste de phrases
@param list_text2: deuxième liste de phrases
'' '
cosine_dist =[cosinus(xy)[cosine(xy)pour (x, y) dans Zip *: français(np.nan_to_num (list_vec1), np.nan_to_num (list_vec2))]
cosine_sim =[(1-dist)[(1-dist)pour dist dans cosine_dist] revenir cosine_sim

Afficher plus

SupportIvy

SupportIvy.com : Un lieu pour partager le savoir et mieux comprendre le monde. Meilleure plate-forme de support gratuit pour vous, Documentation &Tutoriels par les experts.

Articles similaires

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Bouton retour en haut de la page
Fermer