Creare un motore di ricerca che utilizza il deep learning con python

Una guida sulla creazione di un motore di ricerca che utilizzano il deep learning con python .

In questo articolo tratteremo un caso d'uso molto interessante ma complicato della NLP, che è un sistema di recupero delle informazioni ( motore di ricerca ) . Il sistema di recupero delle informazioni è un'applicazione molto utilizzata della NLP.

In un sistema di recupero delle informazioni ( o motore di ricerca ), avremo varie raccolte di documenti e avremo bisogno di cercare un documento specifico passando un significato di contesto.

Creare un motore di ricerca che utilizza il deep learning con python

introduzione

Google ha trilioni di pagine Web, in che modo Google ricerca in modo efficiente le pagine Web pertinenti per noi senza prendere l'URL della pagina?.

I motori di ricerca moderni fanno molto affidamento sull'intelligenza artificiale (AI) per funzionare e sapere come funziona l' IA nella ricerca può aiutarti a classificare meglio il tuo sito web.

L'IA nella ricerca è responsabile di tutto, dai risultati di ricerca che vedi agli argomenti correlati che sei incoraggiato a esplorare ulteriormente.

E oggi è impossibile che un moderno motore di ricerca funzioni senza un'intelligenza artificiale sofisticata. Il modo migliore in cui i motori di ricerca utilizzano l'IA è classificare pagine Web, video e altri contenuti nei risultati di ricerca.

Creare un motore di ricerca che utilizza il deep learning con python

Google (e altri motori di ricerca) si affidano a un'intelligenza artificiale complessa per determinare il modo in cui i contenuti vengono classificati. Gli algoritmi utilizzati da questi sistemi di intelligenza artificiale hanno molte regole che danno la priorità a diversi fattori, dai tipi di parole chiave nei tuoi contenuti all'esperienza utente del tuo sito.

Insieme, questi fattori aiutano l'IA di Google a determinare quali pagine pubblicare in risposta alla tua query di ricerca.

Sebbene Google fornisca indicazioni su ciò che conta per i suoi algoritmi, nessuno al di fuori dell'azienda ha piena visibilità su come questi algoritmi prendono le decisioni. Noi oggi faremo la stessa cosa. Semplificata natualmente.

Creare un motore di ricerca che utilizza il deep learning

Per creare un motore di ricerca dotato di IA per fare concorrenza google dobbiamo prima tenere a mente e conoscere bene uno strumento fondamentale :

Sistemi information retrieval

Un sistema IR ( information retrieval ) ci consente di cercare un documento in base alle informazioni significative su quel documento in modo efficiente.

Come sappiamo, due frasi possono avere strutture molto diverse e parole diverse ma possono avere lo stesso significato. In NLP il nostro obiettivo è catturare il significato delle frasi, utilizzando vari concetti di NLP che vedremo in dettaglio più avanti nell'articolo.

Nel sistema IR utilizziamo il significato del contesto per cercare i documenti.

Quindi per creare un motore di ricerca bisogna prima creare un sistema di recupero delle informazioni utilizzando il significato del contesto.

Creare un motore di ricerca basato su IR

Potrebbero esserci diversi modi per eseguire il recupero delle informazioni. Ma il modo più semplice ma molto efficiente per farlo utilizzando l'incorporamento delle parole. l'inclusione di parole prende in considerazione il significato del contesto indipendentemente dalla struttura della frase.

Applicazioni dei sistemi IR:

• Recupero documenti

• Motori di ricerca

• Risposte alle domande

Come creare un motore di ricerca con IA in grado di contestualizzare

Il word embedding è in grado di comprendere il significato della frase, indipendentemente dalla struttura della parola.

Per esempio :

" Lo amo " e " Mi piace " avranno quasi lo stesso significato se usiamo l'incorporamento delle parole. È una tecnica di apprendimento delle funzionalità predittive in cui le parole vengono mappate sui vettori utilizzando la loro gerarchia contestuale.

Creare un motore di ricerca che utilizza il deep learning con python

Come vedi gattino (Kitten) e gatto (cat) sono posti molto vicini perché hanno significati molto vicini. L'incorporamento di parole è stato addestrato su oltre 8 miliardi di parole utilizzando reti neurali poco profonde, utilizzeremo il vettore di incorporamento di parole pre-addestrato per creare il nostro motore di ricerca dotato di Intelligenza Artificiale, più nello specifico implementerà teciche di deep learning.

Creare un motore di ricerca che utilizza il deep learning con Python

Implementeremo il sistema di recupero delle informazioni usando python.

Durante l'implementazione del sistema di recupero delle informazioni, ci sono alcuni passaggi che dobbiamo seguire:

1. Ottenere i dati

2. Pulizia dei dati

3. Caricamento di word2vec pre-addestrato

4. Ottenere il significato contestuale dei documenti

5. Confronto di query con documenti

1. Creare i documenti

abbiamo creato il nostro set di dati contenente 4 documenti, per una migliore comprensione utilizzeremo un piccolo set di dati.

doc1 = ["""Wasting natural resources is a very serious problem, since we all know that natural resources are limited but still we dont feel it. We use it more than we need, Government are also encouraging people to save the natural resoucres""" ]

doc2 = ["""Machine learning is now days a very popular field of study, a continuous reasearch is going on this , Machine learning is all about maths. Analysing the patters solve the task."""]

doc3 = ["""Nowdays books are loosing its charm since the phones and smart gadgets has taken over the old time, Books are now printed in Digital ways, This saves papers and ultimately saves thousands of trees"""]

doc4 = ["""The man behind the wicket is MS DHONI , his fast hand behind wicket are a big advantage for india, but pant has now carrying the legacy of DHONI but he is not that fast"""]

qui abbiamo 4 documenti e il nostro set di dati sarà un elenco di documenti separati da una virgola.

#------unione di tutti i documenti-------
data = doc1+doc2+doc3+doc4
print(data)

Output:

2. Importiamo le librerie

import numpy as np
import nltk
import itertools
from nltk.corpus import stopwords
from nltk.tokenize import sent_tokenize, word_tokenize
import scipy
from scipy import spatial
import re
tokenizer = ToktokTokenizer()
stopword_list = nltk.corpus.stopwords.words('english')

3. Pulizia dei dati

Nella NLP la pulizia dei dati generalizza sempre la nostra formazione e promette risultati migliori. È sempre buona norma eseguire la pulizia dei dati dopo averli caricati. Creiamo una funzione per pulire i nostri dati

def remove_stopwords(text, is_lower_case=False):
    pattern = r'[^a-zA-z0-9s]'
    text = re.sub(pattern," ",''.join(text))
    tokens = tokenizer.tokenize(text)
    tokens = [tok.strip() for tok in tokens]
    if is_lower_case:
        cleaned_token = [tok for tok in tokens if tok not in stopword_list]
    else:
        cleaned_tokens = [tok for tok in tokens if tok.lower() not in stopword_list]
    filtered_text = ' '.join(cleaned_tokens)
    return filtered_text

La funzione remove_stopwords prende i documenti uno per uno e restituisce il documento pulito.

• abbiamo prima rimosso tutti i caratteri non necessari usando le espressioni regolari.

• Dopo aver rimosso i caratteri non necessari, abbiamo tokenizzato la parola filtrata e utilizzato stopword_list per filtrare tutte le stopword.

4. Implementazione dell'incorporamento di parole

Useremo un vettore di parole pre-addestrato di 300 dimensioni. puoi scaricare la parola vettore usando questo link . Ti suggerirei di creare un taccuino su Kaggle è un'opzione migliore se non vuoi scaricare il grande file di vettori.

Caricamento dei vettori di parole

glove_vectors = dict()
file = open('../input/glove6b/glove.6B.300d.txt', encoding = 'utf-8')
for line in file:
    values = line.split()
    word = values[0]
    vectors = np.asarray(values[1:])
    glove_vectors[word] = vectors
file.close()    
    

• glove_vector : È un dizionario contenente parole come chiavi e valori come vettori di caratteristiche.

• glove.6B.300d : Questa incorporazione di parole è addestrata su 6 miliardi di parole e la lunghezza dei vettori di funzionalità è 300.

• Se una parola non è presente nel nostro dizionario dei vettori di parole, restituirà un vettore zero di 300 lunghezze.

Creare un motore di ricerca che utilizza il deep learning con python

Creazione di un vettore di funzionalità per il nostro documento utilizzando incorporamenti di parole. Stiamo creando una funzione che prende una frase e restituisce il vettore di caratteristiche di 300 dimensioni.

vec_dimension = 300
def get_embedding(x):
    arr  = np.zeros(vec_dimension)
    text = str(x).split()
    for t in text:
        try:
            vec = glove_vectors.get(t).astype(float)
            arr = arr + vec
        except:
            pass
    arr = arr.reshape(1,-1)[0]
    return(arr/len(text))

5. Riepilogo

Un documento contiene molte frasi e una frase ha molti vettori in base al numero di parole presenti in quella frase. Per riassumere il significato di un documento, dobbiamo fare la media del significato di tutte le frasi all'interno di quel documento. Nel linguaggio della NLP, facciamo la media di tutti i vettori di caratteristiche di tutte le frasi all'interno di quel documento.

out_dict = {}
for sen in fin:
    average_vector = (np.mean(np.array([get_embedding(x) for x in nltk.word_tokenize(remove_stopwords(sen))]), axis=0))
    dict = { sen : (average_vector) }
    out_dict.update(dict)

Creare un motore di ricerca che utilizza il deep learning con python

• Il dizionario out_dict contiene documenti come chiave e i loro vettori di caratteristiche medie come valori corrispondenti.

• I vettori di caratteristiche medie codificano il significato di un documento in vettori.

6. Confrontare il significato di un contesto

A partire da ora, abbiamo il vettore di funzionalità di ogni singolo documento e dobbiamo costruire una funzione in grado di confrontare i vettori di funzionalità in base al loro significato. La somiglianza di due parole può essere calcolata utilizzando la distanza del coseno tra i vettori delle loro caratteristiche.

def get_sim(query_embedding, average_vector_doc):
    sim = [(1 - scipy.spatial.distance.cosine(query_embedding, 
    average_vector_doc))]
    return sim

• la funzione get_sim prende il vettore di funzionalità delle query e il vettore di funzionalità di tutti i documenti e restituisce la somiglianza tra query e documento.

• Se la somiglianza sim è maggiore, più vicino a 1 possiamo dire che ha quasi lo stesso significato.

• Se la somiglianza sim è più vicina a 0, possiamo dire che il loro significato è diverso.

• il pacchetto scipy fornisce la classe scipy.spatial.distance.cosine per il calcolo della distanza del coseno.

7. Usiamo il nostro motore

Siamo pronti con i vettori di funzionalità dei documenti e abbiamo creato la funzione per confrontare la somiglianza di due vettori di funzionalità.

def Ranked_documents(query):
    query_word_vectors = (np.mean(np.array([get_embedding(x) for x in nltk.word_tokenize(query.lower())],dtype=float), axis=0))
    rank = []
    for k,v in out_dict.items():
        rank.append((k, get_sim(query_word_vectors, v)))
        rank = sorted(rank,key=lambda t: t[1], reverse=True)
    print('Ranked Documents :')
    return rank[0]

• query_word_vectors Contiene i vettori di funzionalità della query di input.

• La funzione Ranked_document confronta la somiglianza tra i vettori di funzionalità della query con il vettore di funzionalità dei documenti in modo iterativo.

• stiamo restituendo solo un documento più simile al nostro output.

8. Risultati

Quando chiamiamo la Ranked_documentfunzione passando una query, la funzione restituirà il documento più rilevante relativo alla nostra query.

Esempio 1:

Ranked_documents('bat and ball')

Creare un motore di ricerca che utilizza il deep learning con python

Come vedi bat and ball è correlato al cricket quando abbiamo cercato questa parola chiave il modello restituisce il documento relativo al cricket. Inoltre, nel documento non è presente alcuna parola mazza e palla. ( Doc4 )

Esempio 2:

Ranked_documents(‘computer science’)

Creare un motore di ricerca che utilizza il deep learning con python

Come tutti sappiamo, l'informatica è legata all'apprendimento automatico. quando abbiamo interrogato la parola chiave computer science ha restituito il documento relativo all'informatica.

Conclusione sui motori di ricerca con deep learning

In questo articolo abbiamo discusso il sistema di recupero dei documenti, che si basa sul confronto del significato di un documento/frase confrontando i vettori delle caratteristiche.

Abbiamo implementato il sistema di recupero dei documenti utilizzando Python e l'incorporamento di parole pre-addestrato. Esistono diversi modi per eseguire la corrispondenza dei documenti, ma utilizzando l'incorporamento di parole e scipy’s la distanza del coseno diventa molto più facile da implementare.

Puoi copiare e scaricare i codici utilizzati in questo articolo utilizzando questo link .