Extraindo atributos de textos. Prof. Fabrício Olivetti de França

Transcrição

1 Extraindo atributos de textos Prof. Fabrício Olivetti de França

2 Configuração Faça o download do Anaconda Python: E do notebook: 2

3 Crie o ambiente Crie o ambiente: conda create --name lcon python=3 scikit-learn numpy scipy gensim pandas jupyter ipython nltk pip install powerlaw Ative-o com source activate lcon E abra o notebook: jupyter notebook 3

4 Representação computacional Muitos algoritmos de aprendizado de máquina foram formalizados assumindo como entrada amostras em um espaço vetorial. Quando trabalhamos com bases de dados que não são naturalmente representadas no espaço vetorial, devemos extrair os atributos. 4

5 Documentos de textos d1: o gato caçou o rato d2: o rato comeu o queijo Precisamos encontrar v1 e v2 de tal forma que cada posição dos vetores represente um aspecto específico dos documentos. 5

6 Documentos de textos d1: o gato caçou o rato d2: o rato comeu o queijo v1 = [1, 4, 5, 1, 4] v2 = [1, 4, 5, 1, 6] 6

7 Documentos de textos d1: o gato caçou o rato d2: o rato comeu o queijo v1 = [1, 4, 5, 1, 4] v2 = [1, 4, 5, 1, 6] v1-v2 = 2, distância baixa, similaridade alta. [Euclidiana] 7

8 Documentos de textos d1: o gato caçou o rato d2: o rato comeu o queijo provolone v1 = [1, 4, 5, 1, 4,?] v2 = [1, 4, 5, 1, 6, 9] 8

9 Bag of Words Cada objeto é representado por um conjunto F de atributos que é um subconjunto do conjunto F de atributos observados na base. O 1 = {F 1, F 4, F 5, F 9 } O 2 = {F 3, F 4, F 5 } 9

10 Bag of Words É possível representar computacionalmente esses conjuntos de diversas formas: vetor binário denso, vetor esparso, bitmaps, tries, etc. A escolha deve ser de acordo com a aplicação. 10

11 Bag of Words Nos vetores binários cada posição corresponde a um token do dicionário. Os vetores terão tamanho igual ao total de tokens distintos. Um token é um elemento textual: letra, palavra, frase, símbolo, etc. 11

12 Bag of Words d1: o gato caçou o rato d2: o rato comeu o queijo provolone dicionário = { o : 0, gato : 1, caçou : 2, rato : 3, comeu : 4, queijo : 5, provolone : 6} v1 = [1, 1, 1, 1, 0, 0, 0] v2 = [1, 0, 0, 1, 1, 1, 1] 12

13 Bag of Words Cada elemento do vetor representa se determinado token existe ou não no documento. v1 = [1, 1, 1, 1, 0, 0, 0] v2 = [1, 0, 0, 1, 1, 1, 1] sum(v1 == v2)/len(dicionario) = 1/7 = 0.14 [Jaccard] 13

14 Bag of Words Podemos também atribuir pesos representando a frequência dos termos: v1 = [2, 1, 1, 1, 0, 0, 0] v2 = [2, 0, 0, 1, 1, 1, 1] np.dot(v1, v2)/(np.dot(v1,v1)*np.dot(v2,v2)) = 5/(7.8) = 0.09 [Cosseno] 14

15 Cosseno w2 w1 15

16 Bag of Words A biblioteca scikit-learn possui classes para extrair atributos do tipo BOW. import pandas as pd import sklearn.feature_extraction.text as txtfeats tweets = pd.read_csv('tweets.csv.gz') bagofwords = txtfeats.countvectorizer() bow = bagofwords.fit_transform(tweets.text) 16

17 Bag of Words print(len(bagofwords.get_feature_names())) >> bagofwords.get_feature_names()[5000:5004] >> ['alemanharoubo', 'alemanhas', 'alemao', 'alemaoe'] Cada tweet tem em média 16 palavras! Cada tweet será representado por um vetor em que, em média, elementos serão 0. 17

18 Bag of Words Geralmente representamos como vetor esparso: [ (5002,1), (201288, 1), (220665, 2) ] O tweet contém uma ocorrência do token 5002, uma do token e duas do token

19 Bag of Words Quando vamos gerar um vetor BOW para um novo exemplo, os tokens novos são ignorados: novo_tweet = 'um novo tweet sobre um alemao kywz' print(bagofwords.transform([novo_tweet])) >> (0, 5002) 1 (0, ) 1 (0, ) 1 (0, ) 1 (0, ) 2 19

20 Padronização Macarrão, macarrão, macarrao, MaCarrãO representam a mesma informação. Para evitar que eles formem tokens diferentes, antes da construção do dicionário é feito uma padronização: Remover acentos Transformar em minúsculas 20

21 Padronização Existem também tokens que não contém informação necessária para o processo de aprendizado: e, ou, está, quando, etc. Podemos remover essas palavras com o uso de uma lista de stopwords. 21

22 Bag of Words Parâmetros de pré-processamento: strip_accents : remove acentos das palavras com codificação ascii ou unicode. stop_words : permite usar uma lista de stop words. lowercase : transforma as letras em caixa baixa (padrão). binary : não contabiliza a frequência dos termos. 22

23 Corte de Luhn A lei de Zipf diz que a frequência das palavras em um documento é inversamente proporcional ao seu rank. Ou seja, a palavra mais frequente vai aparecer duas vezes com mais frequência que a segunda mais frequente, três vezes mais frequente que a terceira, Luhn argumentou que as palavras muito frequentes e as pouco frequentes não colaboram para discriminação e similaridade entre documentos. LUHN, H.P., 'The automatic creation of literature abstracts', IBM Journal of Research and Development, 2, (1958). 23

24 Corte de Luhn 24

25 Corte de Luhn Mas como determinar os cortes? Basicamente queremos o meio da distribuição. df = sorted(bow.sum(axis=0).a1) # frequencia dos termos fit = powerlaw.fit(df) mediana = fit.xmin*np.power(2, 1/(fit.power_law.alpha-1)) df_max = int(np.round(np.power(mediana, 4/3))) df_min = int(np.round(np.power(mediana, 2/3))) >> df_min = 106, df_max =

26 Corte de Luhn bagofwords = txtfeats.countvectorizer(min_df=df_min, max_df=df_max, strip_accents='unicode', stop_words=['e', 'ou', 'ele', 'ela']) bow = bagofwords.fit_transform(tweets.text) >> 5333 tokens 26

27 tf-idf Uma outra forma de reduzir a influência dos termos frequentes é penalizar as frequências dos tokens pelo inverso da frequência no documento. Quanto mais a frequência do token se aproxima de N, mais idf se aproxima de 0. 27

28 tf-idf tfidf = txtfeats.tfidfvectorizer() bow = tfidf.fit_transform(tweets.text) 28

29 tf-idf norm : l1, l2 or None, optional. Norma usada para normalizar os vetores resultantes. use_idf : se deseja usar o idf. smooth_idf : técnica de smooth para evitar divisões por 0. sublinear_tf : calcula a frequência dos termos como 1 + log(tf). 29

30 Contexto Um ponto negativo da tokenização por palavras é que os tokens não possuem o contexto. Para aliviar esse problema surgiu o n-grams. 30

31 N-grams d1: o gato caçou o rato d2: o rato comeu o queijo provolone 2-gram: dicionário = { o gato : 0, gato caçou : 1, caçou o : 2, o rato : 3, rato comeu : 4, comeu o : 5, o queijo : 6, queijo provolone : 7} 31

32 N-grams bagofwords = txtfeats.countvectorizer(min_df=df_min, max_df=df_max, strip_accents='unicode', ngram_range=(2,2)) bow = bagofwords.fit_transform(tweets.text) >> tokens 32

33 N-grams analyzer : string, { word, char, char_wb }: se os n-grams serão determinados por palavras, por caracteres ou por caracteres dentro das palavras. ngram_range : tuple (min_n, max_n): gera n-gramas com min_n <= n <= max_n. 33

34 N-grams Problemas: Pode aumentar muito a dimensionalidade Muitos tokens continuam sem contexto: o gato 34

35 k-skip-n-grams Tokeniza realizando pulos de 0 a k tokens. d1: o gato caçou o rato d2: o rato comeu o queijo provolone 3-skip-2-gram: dicionário = { o gato : 0, o caçou : 1, o o : 2, gato caçou : 3, gato o : 4, gato rato : 5,...} 35

36 k-skip-n-grams Tem uma chance maior de capturar o contexto, porém pode aumentar a dimensionalidade exageradamente. Podemos utilizar o parâmetro tokenizer que permite passar um tokenizador customizado. A biblioteca nltk implementa o k-skip-n-gram. 36

37 k-skip-n-grams skip3n2grams = lambda s: nltk.skipgrams(s.split(), 2, 3) tfidf = txtfeats.tfidfvectorizer(tokenizer=skip3n2grams, min_df=df_min, max_df=df_max) bow = tfidf.fit_transform(tweets.text) >> tokens 37

38 Aprendendo uma representação Ideia: d1: o gato caçou o rato d2: o rato comeu o queijo provolone Aprender que entre o e caçou vem a palavra gato. 38

39 Continuous Bag-of-Word o gato caçou 39

40 Aprendendo uma representação Cada neurônio de entrada e o neurônio de saída é um vetor binário em que o elemento representando a palavra de entrada tem valor 1 e o restante, 0. 40

41 Continuous Bag-of-Word o gato caçou v(gato) 41

42 Skip-gram o gato caçou v(gato) 42

43 Continuous Bag-of-Word Pesos W 1 dim: V x N 43

44 Continuous Bag-of-Word A entrada são vetores binários, cada vetor binário contém apenas um elemento igual a 1. entrada x W 1 = Soma das linhas de W 1 correspondentes as palavras da entrada (a ordem então não importa) h(entrada x W 1 ) = (entrada x W 1 ) / entradas 44

45 Continuous Bag-of-Word y = softmax(z. W 2 ) z = h(x. W 1 ) 45

46 softmax Saída é um vetor de dimensão V que representa a distribuição categórica de probabilidade para as possíveis saídas. 46

47 softmax O objetivo é minimizar a função custo definida como o logaritmo da probabilidade de p(wt wt+j) ou p(wt+j wt) dependendo do modelo de word2vec utilizado. wt = palavra alvo do vetor wt+j = contexto da palavra 47

48 Função custo 48

49 Atualizando os pesos O processo de atualização demanda que os pesos das V possíveis palavras de saída sejam atualizados! Lembrem-se que V é geralmente centenas de milhares! 49

50 Continuous Bag-of-Word w1 w2 w3 w4 50

51 Continuous Bag-of-Word w1 w2 w3 w4 51

52 Atualizando os pesos Agora só precisamos fazer o processo de atualização em log(v) elementos! 52

53 Demo 53

54 GloVe: Global Vectors for Word Repr. X = matriz de co-ocorrência que a palavra j ocorreu no contexto de i com janela k. 54

55 GloVe: Global Vectors for Word Repr. 55

56 GloVe: Global Vectors for Word Repr. Objetivo: encontrar uma representação vetorial de cada palavra tal que: 56

57 GloVe: Global Vectors for Word Repr. Minimizar: 57

58 GloVe: Global Vectors for Word Repr. Com: 58

59 Polêmica No artigo original os autores indicaram que GloVe era mais rápido que o word2vec e apresentava 12% de melhora na tarefa de analogia de palavras. Discussão sobre validade dos experimentos: U5IMJJsbxAi-kRl8czSwpti15s/edit# 59

60 Polêmica O argumento é que os autores utilizaram apenas os resultados numéricos do artigo original do word2vec, e isso pode ter causado um viés por conta de diferenças na base de treinamento. Um novo teste realizado indicou que não existe diferença significativa entre os dois sob as mesmas condições. 60

61 Polêmica Mas ainda está em discussão Código: 61

62 doc2vec doc id o gato caçou v(gato) 62

63 doc2vec Igual a word2vec, mas agora existe uma nova entrada identificando o parágrafo/documento. Com isso, cada documento pode ser descrito também como um vetor. 63

64 gensim from gensim.models import doc2vec class LabeledLineSentence(object): def init (self, stream): self.stream = stream def iter (self): for uid, line in enumerate(self.stream): yield doc2vec.labeledsentence(words=line.split(), tags=['sent_%s' % uid]) 64

65 gensim model = doc2vec.doc2vec( ) LabeledLineSentence(tweets.text.values[:1000]) 65

66 Minhash Lembrando em nossa representação Bag-of-Words: Token D1 D2 D3 D4 A B C D E

67 Minhash Ela gera uma matriz esparsa e de alta dimensão! Token D1 D2 D3 D4 A B C D E

68 Minhash O cálculo da similaridade (de Jaccard) pode se tornar muito custosa. Token D1 D2 D3 D4 A B C D E

69 Minhash Pré-calcular uma assinatura da matriz que é equivalente a sim. de Jaccard. Token D1 D2 D3 D4 A B C D E

70 Minhash Se permutarmos aleatoriamente as linhas dessa matriz: Token D1 D2 D3 D4 B A E C D

71 Minhash E representarmos cada documento pelo índice da primeira linha contendo 1: Minhash Token D1 D2 D3 D4 B A E C D

72 Minhash Dessa forma cada documento pode ser representado por apenas 1 valor! Minhash Token D1 D2 D3 D4 B A E C D

73 Minhash Mas qual a probabilidade de mh(di) = mh(dj)? 73

74 Minhash Quantas linhas o valor 1 coincide dividido pelo total de linhas com pelo menos um valor 1: 74

75 Minhash Comparando D1 e D4 Minhash Token D1 D2 D3 D4 B A E C D

76 Minhash J = ⅔ = P(mh(D1)=mh(D4)) Minhash Token D1 D2 D3 D4 B A E C D

77 Minhash Se temos P = 2/3, se fizermos 100 permutações diferentes, teremos cerca de 67 valores iguais de minhash entre os dois documentos! 77

78 Minhash Cada documento é representado por N minhashes diferentes. Di = [mh 1 (Di), mh 2 (Di),, mh N (Di)] 78

79 Minhash Computar permutações é custoso! Vamos simplificar utilizando funções hashes! 79

80 Minhash Dada a função hash: h(x) = (ax + b) mod p onde x é o índice do atributo. ela gera uma permutação aleatória com diferentes valores de a,b e mantendo p fixo. 80

81 Minhash Sorteamos N valores de a e b e escolhemos um p primo. Escolhemos um p grande o suficiente para representar nossas variáveis. 81

82 Minhash Exemplo: h1(x) = (x + 1) mod 5 h2(x) = (3x + 1) mod 5 82

83 Minhash h1(x) = (x + 1) mod 5 h2(x) = (3x + 1) mod 5 Linha Token D1 D2 D3 D4 h1 h2 0 A B C D E

84 Minhash Para cada documento, marcamos as linhas iguais a 1: Linha Token D1 D2 D3 D4 h1 h2 0 A B C D E

85 Minhash Representamos o documento com os menores valores marcados de cada hash: SIG(D1) = [1, 0] Linha Token D1 D2 D3 D4 h1 h2 0 A B C D E

86 Minhash - Algoritmo SIG1 e SIG2 inicializam com o maior valor possível +1. SIG SIG Linha Token D1 D2 D3 D4 h1 h2 0 A B C D E

87 Minhash - Algoritmo Para cada linha, atualizamos os documentos com valor igual a 1: SIG SIG Linha Token D1 D2 D3 D4 h1 h2 0 A B C D E

88 Minhash - Algoritmo SIG SIG Linha Token D1 D2 D3 D4 h1 h2 0 A B C D E

89 Minhash - Algoritmo Repare que apenas atualizamos os valores se for menor! SIG SIG Linha Token D1 D2 D3 D4 h1 h2 0 A B C D E

90 Minhash - Algoritmo SIG SIG Linha Token D1 D2 D3 D4 h1 h2 0 A B C D E

91 Minhash - Algoritmo SIG SIG Linha Token D1 D2 D3 D4 h1 h2 0 A B C D E

92 Minhash - Algoritmo D1' = [1, 0] D3' = [0, 0] D2' = [3, 2] D4' = [1, 0] SIG SIG Linha Token D1 D2 D3 D4 h1 h2 0 A B C D E

93 Minhash - Algoritmo D1' = [1, 0] D3' = [0, 0] D2' = [3, 2] D4' = [1, 0] J D2 D3 D4 D1 0 0,25 0,67 D2 0 0,33 D3 0,2 J D2' D3' D4' D1' 0 0,5 1 D2' 0 0 D3' 0,5 93

94 Código P = nhashes = 3 alphas = np.random.randint(1, P-1, (nhashes,)) betas = np.random.randint(1, P-1, (nhashes,)) 94

95 Código H = [list(map(hash,t.split())) for t in tweets.text[:100]] MH = np.zeros((100,nhashes)) for i, h in enumerate(h): for j in range(nhashes): MH[i,j] = np.min(np.remainder(alphas[j]*h + betas[j], P)) 95