Pré-processamento de Dados

(1)

Pr´

e-processamento de Dados

Fabr´ıcio Olivetti de Fran¸ca

(2)

(3)

T´

opicos

1. Pr´e-Processamento dos Dados

2. Conceitos B´asicos

3. Representa¸c˜ao Textual

4. Padr˜oes Recorrentes

5. Padronizando e Normalizando os Atributos

(4)

(5)

Data Sets

Conjunto de objetos de dados. Objeto de dados ´e uma entidade:

• funcion´ario de uma empresa

• medi¸cões da atividade cerebral em um paciente • descri¸cão de uma ocorrência policial

(6)

Objetos de Dados

• Idade • Local

• Valor do impulso el´etrico • etc.

(7)

Tipos de Atributos

• Categóricos: • Nominal • Binário • Ordinal • Numéricos: • Intervalar • Razão

(8)

Atributos Nominais

S´ımbolos ou nomes descritivos: • Descreve uma caracter´ıstica

• Não apresentam rela¸cão de ordem, apenas igualdade Ex.: ocupa¸cão, cor dos olhos, etc.

(9)

Atributos Bin´

arios

Atributo nominal com apenas dois valores poss´ıveis: 0 ou 1. Ex.: resultado de um exame, gˆenero, etc.

(10)

Atributos Ordinais

Valores que apresentam ordem, mas não possuem rela¸cão de magnitude. Ex.: {péssimo, ruim, regular, bom, ótimo}

(11)

Atributos Intervalares

Atributo num´erico com rela¸c˜ao de ordem e magnitude.

Ex.: Temperatura de 20◦C é 10 unidades mais quente do que 10◦C . Não podemos dizer que 20◦C é duas vezes mais quente do que 10◦C .

(12)

Atributos Intervalares

O 0 absoluto em Celsius est´a em −273.15◦C .

20◦C est´a a 293.15 de nenhum calor, o dobro desse calor seria 586.30 ou 313.15◦C .

(13)

Atributos de Raz˜

oes

Atributos num´ericos com a mesmas propriedades do intervalar, mas com um ponto-zero.

• Altura

• Contagem de palavras • Temperatura em Kelvin

(14)

Representando Objetos

Precisamos de uma representa¸cão numérica. • Dados numéricos: ok! (ou quase sempre ok) • Dados nominais: vetor binário

• Dados ordinais: rank

(15)

Representando Objetos

Tabela 1: Base de Dados.

Profiss˜ao Conceito Nota Engenheiro A 9.5

Professor B 8.4 Engenheiro A 7.3

(16)

Atributos Categ´

oricos → Bin´

arios

Engenheiro Professor Gerente Conceito Nota

1 0 0 A 9.5

0 1 0 B 8.4

1 0 0 A 7.3

0 0 1 D 9.1

(17)

Atributos Ordinais → Num´

ericos

# conceitos = 5 Rank: 5, 4, 3, 2, 1 z =(rank−1)_#−1

Engenheiro Professor Gerente Conceito Nota

1 0 0 1 9.5

0 1 0 0.75 8.4

1 0 0 1 7.3

(18)

Leitura da Base de Dados

data Profissao = Engenheiro | Professor | Gerente | Estudante

deriving (Show, Read, Eq, Enum, Bounded)

data Conceito = F | D | C | B | A

deriving (Show, Read, Enum)

type Nota = Double

type Objeto = (Profissao, Conceito, Nota)

type Objeto’ = [Double]

(19)

Leitura da Base de Dados

parseFile :: String -> [Objeto]

parseFile file = map parseLine (lines file) where

parseLine l = toObj (words l)

toObj [w1, w2, w3] = (read w1 :: Profissao, read w2 :: Conceito, read w3 :: Nota)

A fun¸c˜ao words separa uma string em uma lista de strings cortando nos caracteres de espa¸co.

(20)

Leitura da Base de Dados

transformData :: [Objeto] -> [Objeto’]

transformData data = map parseObj data where

parseObj (prof, conc, nota) = (binariza prof)

++ [rank conc, nota]

(21)

Leitura da Base de Dados

binariza :: Profissao -> [Double]

binariza p = map bool2double [p == p’ | p’ <- profissoes] where

profissoes = [minBound..] :: [Profissao] bool2double True = 1.0

(22)

Leitura da Base de Dados

rank :: Conceito -> Double

rank co = (fromEnum’ co) / (fromEnum’ A) where

fromEnum’ = fromIntegral . fromEnum

(23)

Fluxo dos Dados

A leitura e transforma¸cão dos dados segue um fluxo bem definido. É fácil perceber que, enquanto uma linha do arquivo está sendo processada pela fun¸cão transformData, outra pode ser processada pela fun¸cão parseFile.

(24)

(25)

Minera¸

c˜

ao de Textos

Documentos de textos:

• Não possuem representa¸cão vetorial • Interdependência dos atributos • Tamanho variável

(26)

Textos como conjuntos

Se representarmos os documentos de textos como o conjunto de suas palavras:

D1 = ”Estou assistindo a uma aula de Big Data, mas tudo que aprendi foi Haskell durante a aula!”

D2 = ”Hoje aprendi Haskell na aula, será que o que aprendi será útil na minha vida?”

(27)

Textos como conjuntos

Se representarmos os documentos de textos como o conjunto de suas palavras:

D1 = {Estou, assistindo, a, uma, aula, de, Big , Data, mas, tudo, que, aprendi , foi , Haskell , durante, aula!}

(28)

Textos como conjuntos

Calculando a similaridade de Jaccard, temos:

D1 ∩ D2 = {que, aprendi , Haskell }

D1 ∪ D2 = {Estou, assistindo, a, uma, aula, de, Big , Data, mas, tudo, que, aprendi , foi , Haskell , durante, aula!, Hoje, na, aula, ser ´a, o, ´util , minha, vida?}

J(D1, D2) = 3 24= 0.125

Essa representa¸cão é conhecida como Bag-of-Words, em que geramos os atributos do texto como atributos categóricos.

(29)

Normaliza¸

c˜

ao do Texto

Pode ser interessante padronizar a forma do texto para termos serem considerados como um elemento ´unico do conjunto independente de como ´e escrito.

Por exemplo: Estou, estou, esTou, aula!, aula, aula?, ´util, util.

D1 = {estou, assistindo, a, uma, aula, de, big , data, mas, tudo, que, aprendi , foi , haskell , durante, aula}

D2 = {hoje, aprendi , haskell , na, aula, sera, que, o, util , minha, vida}

J(D1, D2) = 4 23= 0.17

(30)

Elimina¸

c˜

ao de atributos irrelevantes

Podemos eliminar palavras que n˜ao apresentam significado sozinhas:

D1 = {estou, assistindo, aula, big , data, tudo, aprendi , haskell , durante, aula} D2 = {hoje, aprendi , haskell , aula, sera, util , minha, vida}

J(D1, D2) = 4 14= 0.28

(31)

Bag-of-Words

type Doc = String

type Token = String

bagofwords :: [Doc] -> [[Token]]

bagofwords docs = naoVazio $ map tokeniza docs where

tokeniza doc = nub

$ filter maisDe2

$ map normaliza (words doc) normaliza palavra = map toLower

$ filter isAlphaNum palavra

(32)

Bag-of-Words

A fun¸cão toLower converte um caractere maiúsculo para minúsculo, e a fun¸cão isAlphaNum retorna verdadeiro se o caractere é uma letra do alfabeto ou um número.

(33)

Fluxo dos Dados

O fluxo dos dados pode ser descrito com o seguinte fluxograma:

map tokeniza words map normaliza filter isAlphaNum map toLower

filter maisDe2 nub

(34)

Term-Frequency

Se um termo aparece repetidas vezes em um documento, isso significa que ele pode ter uma importˆancia maior do que os outros termos. No nosso exemplo, a repeti¸c˜ao do termo Haskell indica um dos temas dos nossos documentos.

(35)

Term-Frequency

A informa¸cão de frequência pode ser importante para a representa¸cão de nossos documentos. Podemos fazer então:

fn(t, d ) = f (t, d ) |d | ,

com f (t, d ) sendo a frequˆencia do termo t no documento d e |d | a quantidade de termos no documento d .

(36)

Term-Frequency

A ideia para computar os vetores TF ´e primeiro representar cada documento como uma lista (token, 1.0) e, em seguida:

• Ordenar essa lista pelo token • Agrupar os itens com mesmo token • Somar os valores em cada grupo • Dividir os valores pelo n´umero de tokens

(37)

TF

type Freq = Double

tf :: [Doc] -> [[(Token, Freq)]]

tf docs = naoVazio $ map tokeniza docs where

tokeniza doc = fn $ map normTupla (words doc) normTupla w = (normaliza w, 1.0)

(38)

TF

fn :: [(Token, Double)] -> [(Token, Freq)]

A partir desse momento trabalharemos frequentemente com bases de dados representadas como listas de tuplas.

Essas tuplas devem ser encaradas como chave e valor, respectivamente. Para tornar o c´odigo mais leg´ıvel, vamos definir as fun¸c˜oes mapByKey, foldByKey, groupByKey, sortByKey

(39)

mapByKey

mapByKey aplica a fun¸c˜ao g apenas no valor da tupla, deixando a chave intacta:

(40)

foldByKey

foldByKey’ assume uma lista de tuplas chave-valor em que todas as chaves s˜ao iguais.

Essa fun¸cão aplica foldl1’ apenas nos valores das tuplas, resultando em uma tupla (k, v ) em que k é a chave de todas as tuplas e v o resultado da opera¸cão fold:

foldByKey’ g = foldl1’ (\(k1,v1) (k2,v2) -> (k1, g v1 v2))

(41)

sortByKey

sortByKey ordena uma lista de tuplas pela chave:

sortByKey = sortBy ordenaTupla

ordenaTupla :: (Ord a) => (a, t) -> (a, t) -> Ordering

ordenaTupla (a1,b1) (a2,b2)

| a1 < a2 = LT | a1 > a2 = GT

(42)

groupByKey

groupByKey agrupa uma lista ordenada de tuplas gerando uma lista de listas, com cada lista agrupando as tuplas de mesma chave:

groupByKey = groupBy agrupaTupla

agrupaTupla :: (Eq a) => (a, t0) -> (a, t0) -> Bool

agrupaTupla (a1, b1) (a2, b2) = a1==a2

groupByKey [(1,0.1), (1,0.2), (2,0.1)]

== [ [(1,0.1),(1,0.2)], [2,0.1] ]

(43)

TF

fn tokens = mapByKey (/n) $ map (foldByKey’ (+)) $ groupByKey $ sortByKey tokens where n = length’ tokens

(44)

Fluxo dos Dados

map tokeniza words map normaliza sortByKey groupByKey

map foldByKey mapByKey

(45)

Inverse Document Frequency

Algumas palavras aparecem com uma frequˆencia muito superior as demais, como: e, que, ou, etc.

Essas palavras n˜ao costumam apresentar um significado discriminat´orio e, portanto, podem ter um peso menor. Para isso podemos multiplicar o TF por:

idf (t) = log |D| |{d ∈ D : t ∈ D}|

(46)

TF-IDF

Como veremos mais adiante, ´e poss´ıvel pensar no vetor IDF como uma matriz associativa. Para isso utilizaremos o HashMap do Haskell.

idf :: [[(Token, Freq)]] -> M.HashMap Token Freq

idf corpus = M.fromList

$ mapByKey (\v -> log (n/v)) $ map (foldByKey’ (+)) $ groupByKey $ sortByKey $ map (\ (k,v) -> (k,1)) $ concat corpus where n = length’ corpus 43

(47)

HashMap

-- importa a biblioteca HashMap.Strict apelidade de M

import qualified Data.HashMap.Strict as M

-- cria um mapa M.HashMap Integer Double da lista de tuplas

mapa = M.fromList [(1, 0.1), (2, 0.3), (3, 0.04)]

mapa M.! 2 -- retorna 0.3

(48)

TF-IDF

tfidf :: [[(Token, Freq)]] -> M.HashMap Token Freq

-> [[(Token, Freq)]]

tfidf tf’ idf’ = map multIDF tf’ where

multIDF = mapByKey (\(k,v) -> (k, v * (idf’ M.! k)) )

(49)

Fluxo dos Dados

map multIDF mapByKey concat map sortByKey

groupByKey map foldByKey

mapByKey fromList

(50)

(51)

Padr˜

oes de sequˆ

encia de fun¸

c˜

oes

Nos exemplos anteriores, podemos perceber um padrão recorrente de chamada de fun¸cões utilizadas em diversas solu¸cões:

map (foldByKey’ (+)) $ groupByKey $ sortByKey

Esse padr˜ao precede a chamada de uma fun¸c˜ao map que transforma um valor em uma tupla chave-valor (k, v ).

(52)

Padr˜

oes de sequˆ

encia de fun¸

c˜

oes

Basicamente esse padrão combina os valores das tuplas com a mesma chave utilizando uma fun¸cão (nos exemplos utilizamos (+)). É interessante, então, criar a fun¸cão:

combine :: Ord k

=> (v -> v -> v) -> [(k, v)] -> [(k, v)]

combine f xs = map (foldByKey’ f) $ groupByKey $ sortByKey xs Com isso, muitas fun¸c˜oes se tornam sequˆencias de combine . map.

(53)

fn

fn tokens = mapByKey (/n)

$ combine (+) tokens

where

(54)

idf

Como veremos mais adiante, ´e poss´ıvel pensar no vetor IDF como uma matriz associativa. Para isso utilizaremos o HashMap do Haskell.

idf :: [[(Token, Freq)]] -> M.HashMap Token Freq

idf corpus = M.fromList

$ mapByKey (\v -> log (n/v)) $ combine (+) $ mapByKey (\v -> 1) $ concat corpus where n = length’ corpus 52

(55)

Padronizando e Normalizando os

Atributos

(56)

Padroniza¸

c˜

ao

Muitos algoritmos de Aprendizado de M´aquina sup˜oem que os valores dos atributos seguem N(0, 1).

Se um atributo não segue esse padrão, pode dominar a fun¸cão-objetivo e se tornar importante demais.

(57)

Padroniza¸

c˜

ao

Dado uma matriz de dados X , podemos padronizar os valores de cada um de seus elementos como:

ˆ

Xi ,j = Xi ,j− ¯Xi ,j σj

(58)

Padroniza¸

c˜

ao

padroniza :: [[Double]] -> [[Double]]

padroniza x = mapColunas padroniza’ x

padroniza’ :: [Double] -> [Double]

padroniza’ x = devMedia ./ sigma where

media xs = (sum xs) / n devMedia = x .- (media x)

sigma = sqrt $ media $ devMedia .** 2

n = length’ x

(59)

Fluxo dos Dados

mapColunas padroniza’ media devMedia ./ .** 2

(60)

Escalonamento

Algoritmos baseados em m´etodos de gradiente tendem a se beneficiar quando os atributos est˜ao entre [0, 1].

ˆ

Xi ,j = Xi ,j − min X:,j max X:,j− min X:,j

(61)

Padroniza¸

c˜

ao

maxminScale :: [[Double]] -> [[Double]]

maxminScale x = mapColunas maxminScale’ x

maxminScale’ :: [Double] -> [Double]

maxminScale’ x = map scale x where

(62)

Normaliza¸

c˜

ao

Finalmente podemos normalizar cada amostra da base utilizando a normaliza¸c˜ao de vetores:

ˆ

Xi ,j = Xi ,j kXikp

(63)

Padroniza¸

c˜

ao

normaliza :: [[Double]] -> [[Double]]

normaliza x = map normaliza’ x where

normaliza’ xi = xi ./ (norma xi) norma xi = sqrt . sum $ xi .^ 2

(64)

Paralelizando o

Pr´

e-Processamento

(65)

Paralelizando chunks

Conforme vimos na aula anterior, ao paralelizar um programa

objetivamos minimizar o n´umero de sparks e tentar distribuir a tarefa de forma homogˆenea entre as threads.

(66)

Paralelizando chunks

Para isso adotamos a estrat´egia de dividir nossos dados em peda¸cos (denominados chunks), processar cada chunk em paralelo e, em seguida, juntar os resultados.

(67)

Paralelizando chunks

Vamos continuar utilizando o tipo ChunksOf definido anteriormente para representar nossos arquivos distribu´ıdos entre diversas m´aquinas.

(68)

Paralelizando Leitura dos Dados

Com isso, nossa fun¸c˜ao de processamento dos dados em paralelo

simplesmente aplica a fun¸c˜ao transformData em cada um dos chunks em paralelo.

transformDataPar :: ChunksOf [Objeto] -> ChunksOf [Objeto’]

transformDataPar chunks = (map transformData chunks ‘using‘ parList rdeepseq) Note que nenhuma altera¸cão é necessária para a fun¸cão transformData que continuará recebendo o tipo [Objeto] e retornando [Objeto’].

(69)

Paralelizando a Padroniza¸

c˜

ao

Na padroniza¸cão, não podemos calcular as três partes da equa¸cão em paralelo. Além disso, temos um outro desafio, recebemos peda¸cos de linhas, mas temos que trabalhar com as colunas:

padroniza :: [[Double]] -> [[Double]]

padroniza x = mapColunas padroniza’ x

padroniza’ :: [Double] -> [Double]

padroniza’ x = (x .- media) ./ sigma where

media = (sum x) / n

sigma = sqrt $ sum $ (x .- media) .** 2

(70)

Paralelizando a Padroniza¸

c˜

ao

Primeiro, vamos alterar a assinatura da fun¸c˜ao para sabermos onde queremos chegar:

padronizaPar :: ChunksOf [[Double]] -> ChunksOf [[Double]]

padronizaPar chunks = parmap padroniza chunks where

padroniza = map (\xi -> (xi .-. media) ./. desvio) media = mapReduce id (.+.) chunks

desvio = map (\x -> sqrt (x/n))

$ mapReduce desvQuad (.+.) chunks desvQuad xi = (xi .-. media).**2

n = sum $ map length’ chunks

(71)

Paralelizando a Normaliza¸

c˜

ao

A implementa¸c˜ao paralela de normaliza pode ser feita diretamente aplicando a vers˜ao sequencial em cada chunk.

normalizaPar :: ChunksOf [[Double]] -> ChunksOf [[Double]]

normalizaPar chunks = parmap normaliza chunks

normaliza :: [[Double]] -> [[Double]]

normaliza x = map normaliza’ x where

normaliza’ xi = xi ./ (norma xi) norma xi = sqrt . sum $ xi .^ 2

(72)

Paralelizando o TF

Da forma que organizamos o algoritmo de TF, utilizando map e combine, basta aplicar a fun¸c˜ao tf em cada chunk.

tfPar :: ChunksOf [Doc] -> ChunksOf [[(Token, Freq)]]

tfPar chunks = parmap tf chunks

tf :: [[Token]] -> [[(Token, Freq)]]

tf docs = map normFreq docs where

normFreq doc = fn $ map (\w -> (w, 1.0)) doc

(73)

Paralelizando a o IDF

Para paralelizar o IDF, precisamos calcular a contagem de quantos documentos contém cada token em cada chunk. Em seguida, é necessário combinar os resultados de cada chunk para então calcular o idf.

idfPar :: ChunksOf [[(Token, Freq)]] -> M.HashMap Token Freq

idfPar chunks = M.fromList

$ mapByKey (\v -> log (n/v))

$ combine (+) $ concat

$ (map idf chunks ‘using‘ parList rdeepseq) where

idf :: [[(Token, Freq)]] -> [(Token, Freq)]

(74)

Padr˜

ao de paralelismo

Note que o padrão de paralelismo do cálculo do IDF difere dos anteriores pois é necessário o uso do combine no lugar de foldl1’ e a aplica¸cão de concat na sa´ıda do map.

(75)

Padr˜

ao de paralelismo

Uma fun¸cão genérica pode ser escrita da seguinte forma e aplicada em muitas situa¸cões em que trabalhamos com lista de tuplas:

mapReduceByKey :: (NFData k, NFData v, Ord k)

=> (a -> (k, v)) -> (v -> v -> v) -> ChunksOf [a] -> [(k, v)]

mapReduceByKey f g xs = combine g

$ concat

$ (map f’ xs

‘using‘ parList rdeepseq) where

(76)

Padr˜

ao de paralelismo

Nossa fun¸c˜ao idfPar ficaria:

idfPar :: ChunksOf [[(Token, Freq)]] -> M.HashMap Token Freq

idfPar chunks = M.fromList

$ mapByKey (\v -> log (n/v))

$ mapReduceByKey (\(k,v) -> (k,1)) (+)

$ parmap concat chunks where