4- Metodologia
4.2.2 Selec¸ ˜ao dos Kernel Range-Groups
A func¸ ˜ao F indKernelRangeGroup ´e a primeira a ser chamada pelo algoritmo principal, ela ´e apresentada no Algoritmo 2. Seu objetivo ´e encontrar as informac¸ ˜oes sobre os KRGs de uma sequ ˆencia candidata. Ela recebe como entrada a sequ ˆencia candidatac, a janela deslisante atualdde tamanhok(igual ao tamanho da sequ ˆencia candidata buscada) na qual ser ´a verificada a exist ˆencia dos KRGs, e os limites definidos pelo usu ´arioγ,β eσ.
Se a sequ ˆencia candidata estiver contida na janela deslisante recebida como entrada (linhas 2 a 5), novos RGs s ˜ao criados com o uso da func¸ ˜aoSplitGroups(linha 3), tendo um per´ıodo de tempo que inicia e termina na marcac¸ ˜ao de tempo do in´ıcio da janela deslisante atual d, e um grupo que cont ´em as posic¸ ˜oes onde a sequ ˆencia ocorre em d. Assim, RGs s ˜ao gerados com o estado aberto (i.e., closed = f also).
Em seguida (linha 4), os RGs abertos (rec ´em gerados e preexistentes) s ˜ao unidos respeitando a frequ ˆencia m´ınimaγ e o tamanho m´ınimo do grupoβ usando a func¸ ˜ao M ergeOpenKernelRangeGroups. Como resultado, os RGs da sequ ˆencia candidata de entrada s ˜ao atualizados. Vale ressaltar que se um RGrgtem seu atributorg.closedcom valorfalso, isso significa que ele ainda pode ser seu per´ıodo de tempo estendido.
Algoritmo 2 – FindKernelRangeGroup Input: c, d, γ, β, σ
1 begin
2 if(c.seq⊆d)then
3 c.rgs←c.rgs+SplitGroups(c, d, σ)
4 c.rgs←M ergeOpenKernelRangeGroups(c.rgs, d.timestamp, γ, β, σ)
5 end
6 end
Output:Atualiza o(s) RG(s) de um candidatoc
A func¸ ˜aoSplitGroups ´e apresentada no Algoritmo 3. Seu objetivo ´e criar novos RGs para grupos de posic¸ ˜oes da transac¸ ˜ao atualdque contenham a sequ ˆencia candidata
procurada. Ela recebe como entrada um candidatoc, a transac¸ ˜ao atualde a frequ ˆencia m´ınima definida pelo usu ´arioσ. O algoritmo encontra todas as posic¸ ˜oes onde a sequ ˆencia do candidatoc.seqocorre na transac¸ ˜ao atuald(linha 3). Caso exista alguma ocorr ˆencia, inicia-se uma repetic¸ ˜ao (linhas 4 a 14) na qual RGs s ˜ao criados com as posic¸ ˜oes onde a sequ ˆencia ocorre com uso da func¸ ˜aoCreateGroup(linha 5).
Para cada RG, as seguintes informac¸ ˜oes s ˜ao definidas: i) o in´ıcio (rs) e o fim (re) do per´ıodo de tempo,ii)o grupo de posic¸ ˜oes espaciais (g),iii)as ocorr ˆencias (occ) e a frequ ˆencia (f req) da sequ ˆencia, e, por fim,iv)o seu estado (closed). ´E importante destacar que novos RGs iniciam com o estado aberto (closed = f also) indicando que estes podem ser estendidos. Como sa´ıda, o algoritmo fornece um conjunto de novos RGs relativos aos conjuntos de posic¸ ˜oes onde a sequ ˆencia candidatac.seq ´e encontrada emd.
Algoritmo 3 – SplitGroups Input: c, d, σ
1 begin
2 Z ← ∅
3 pos←positions(c.seq, d)
4 while(pos6=nil)do
5 new group←CreateGroup(pos, σ)
6 pos←pos−new group
7 new rg.rs←d.timestamp
8 new rg.re←d.timestamp
9 new rg.g←new group
10 new rg.occ←d.timestamp
11 new rg.f req←1
12 new rg.closed←F alse
13 Z ←Z+new rg
14 end
15 end
Output:Z - conjunto de novos RGs relativos ao candidatocencontrados em d.
A func¸ ˜aoCreateGroup ´e apresentada no Algoritmo 4. Seu objetivo ´e gerar um grupo com o conjunto de posic¸ ˜oes fornecidas. Ela recebe como entrada um conjunto de posic¸ ˜oespose a distancia m ´axima de ao menos um outro elemento do mesmo grupoσ.
O algoritmo comec¸a obtendo uma posic¸ ˜ao do conjunto fornecido (linha 2). Esta posic¸ ˜ao passa a ser a primeira a fazer parte de um novo grupo (linha 3) e ´e removida do conjunto de posic¸ ˜oes fornecido (linha 4). A partir da´ı, inicia-se a busca por novas posic¸ ˜oes que possam fazer parte do novo grupo (linhas 5 a 16), respeitando o limiteσ(linha 9) fornecida pelo usu ´ario. Como sa´ıda, este algoritmo fornece um novo grupo, que ´e subconjunto do
grupo de posic¸ ˜oesposfornecido.
Algoritmo 4 – CreateGroup Input: pos, σ
1 begin
2 n←next(pos)
3 new group←n
4 pos←pos−n
5 p←next(new group)
6 while(p6=nil)do
7 q←next(pos)
8 while(q6=nil)do
9 if(dist(p, q)≤σ)then
10 new group←new group+q
11 pos←pos−q
12 end
13 q ←next(pos)
14 end
15 p←next(new group)
16 end
17 end
Output:new group- um subconjunto deposque forma um grupo.
A func¸ ˜aoM ergeOpenKernelRangeGroups ´e apresentada no Algoritmo 5. Seu objetivo ´e tentar estender o per´ıodo dos RGs cujos atributos closed tenha valor falso gerando novos com per´ıodo de tempo maior e, possivelmente, um grupo maior. Ela recebe como entrada um conjunto de RGsRGde um candidato, a marcac¸ ˜ao de tempo atualtimestamp, e os limites definidos pelo usu ´arioγ,β eσ.
A func¸ ˜ao tenta estender os per´ıodos atrav ´es da uni ˜ao de cada elemento do conjunto de RGs com um outro elemento do mesmo conjunto, ambos com atributosclosed com valor falso (linhas 6 a 21). Caso seus grupos de posic¸ ˜oes possuam intersec¸ ˜ao ou uma posic¸ ˜ao de um grupo tenha uma dist ˆancia menor ou igual aσde uma posic¸ ˜ao qualquer do outro grupo (linhas 8 e 9) e a frequ ˆencia do novo grupo gerado seja maior queγ (linhas 14 e 16). Se todas as condic¸ ˜oes forem verdadeiras, ent ˜ao o novo RG gerado
´e adicionado ao conjuntoRG(linha 17) e os elementos unidos s ˜ao inseridos a uma lista para remoc¸ ˜ao (linha 19).
Se houverem elementos inseridos na lista de remoc¸ ˜ao RGs estes s ˜ao removidos do conjuntoRG(linhas 23 a 25). Por fim, os RGs passam por uma validac¸ ˜ao atrav ´es do uso da func¸ ˜aoV alidateKernelRangeGroups(linha 26). Como sa´ıda, o algoritmo fornece o conjuntoRGatualizado com as uni ˜oes que foram poss´ıveis.
Algoritmo 5 – MergeOpenKernelRangeGroups Input: RG, timestamp, γ, β, σ
1 begin
2 mergeable←T rue
3 while(mergeable)do
4 mergeable←F alse
5 toRemove← ∅
6 foreach(q, r∈RG|q.closed=F alse∧r.closed=F alse∧r 6=q)do
7 pos←q.group∪r.group
8 group←CreateGroup(pos, σ)
9 if(pos−group=∅)then
10 new rg.rs←min(q.rs, r.rs)
11 new rg.re←max(q.re, r.re)
12 new rg.g←group
13 new rg.occ←q.occ∪r.occ
14 new rg.f req← suport(new rg.occ)
|[new rg.rs..new rg.re]|
15 new rg.closed←F alse
16 if(new krg.f req≥γ)then
17 RG←RG+new rg
18 mergeable←T rue
19 toRemove←toRemove+q+r
20 end
21 end
22 end
23 foreach(k∈toRemove)do
24 RG←RG−k
25 end
26 RG←V alidateKernelRangeGroups(RG, timestamp, γ, β)
27 end
28 end
Output:RG- conjunto de RGs
O algoritmo G-STSM busca sempre estender os RGs, contudo deve respeitar os limites definidos pelo usu ´ario. Se para algum RG, a extens ˜ao do per´ıodo de tempo resultar em uma frequ ˆencia menor queγ, o atributo do RGkrg.closed ´e atualizado para verdadeiro. A partir deste momento ele n ˜ao ´e mais capaz de ter seu per´ıodo estendido e passa a atender todas as condic¸ ˜oes da Definic¸ ˜ao 1, em outras palavras ele se torna um KRG.
A func¸ ˜aoV alidateKernelRangeGroups ´e apresentada no Algoritmo 6. Seu obje-tivo ´e verificar se os limites definidos pelo usu ´ario foram observados nos RGs, verificando se eles ainda podem ser estendidos mantendo-se a frequ ˆencia maior ou igual a m´ınima γ e se o tamanho m´ınimo do grupo β ocorre. Ela recebe como entrada um conjunto
de RGsRGde uma sequ ˆencia candidata, a marcac¸ ˜ao de tempo referente `a transac¸ ˜ao atual da janela deslizantetimestamp, os limites definidos pelo usu ´arioγ eβ. Para cada elemento do conjuntoRGcom atributoclosedcom valorfalso(krg.closed=f also) (linha 3 a 11), calcula-se a frequ ˆencia estendendo o per´ıodo de tempo do RG at ´e a marcac¸ ˜ao de tempo atual (linha 4). Depois, verifica-se se a frequ ˆencia ´e menor que o valor m´ınimo definido pelo usu ´ario (linhas 5 a 9). Se isso ocorrer, altera-se o estado (rg.closed) para verdadeiro(linha 6), e verifica-se se o tamanho do grupo ficou abaixo do m´ınimo definido pelo usu ´ario, marcando tal elemento para remoc¸ ˜ao caso isso ocorra (linhas 7 a 9). Por fim, todos os elementos marcados s ˜ao removidos do conjuntoRG(linhas 12 a 14). Como sa´ıda, a func¸ ˜ao retorna o conjuntoRGatualizado.
Algoritmo 6 – ValidateKernelRangeGroups Input: RG, timestamp, γ, β
1 begin
2 toRemove← ∅
3 foreach(rg∈RG|rg.closed=F alse)do
4 f req← support(rg.occ)
|[rg.rs..timestamp]|
5 if(f req < γ)then
6 rg.closed←T rue
7 if(length(rg.g)< β)then
8 toRemove←toRemove+rg
9 end
10 end
11 end
12 foreach(k∈toRemove)do
13 RG←RG−k
14 end
15 end
Output:RG
E importante observar que a func¸ ˜ao´ V alidateKernelRangeGroups ´e executada sem o conhecimento dos dados das pr ´oximas marcac¸ ˜oes de tempo do conjunto de dados.
Isso significa que um RG que tenha seu atributoclosedalterado para o valorverdadeiroem uma dada marcac¸ ˜ao de tempo talvez pudesse manter uma frequ ˆencia maior que o m´ınimo definido pelo usu ´ario com a utilizac¸ ˜ao dos pr ´oximos registros. A soluc¸ ˜ao para tal problema
´e dada na Subsec¸ ˜ao 4.2.3, onde ´e apresentada a func¸ ˜aoM ergeKernelRangeGroups, na qual RGs com estado fechado s ˜ao unidos para formar um novo.
A func¸ ˜ao V alidateAndClose ´e apresentada no Algoritmo 7. Ela ´e apresentada aqui por conta de sua semelhanc¸a com a func¸ ˜ao V alidateKernelRangeGroups. A
diferenc¸a entre as duas se deve principalmente ao contexto onde s ˜ao executadas. Como aV alidateKernelRangeGroups ´e executada durante a varredura do conjunto de dados, no escopo da busca por KRG ela sempre verifica se ´e poss´ıvel estender o per´ıodo de tempo do RG, j ´a a func¸ ˜aoV alidateAndClosepor ser executada ap ´os a leitura de todo o conjunto de dados n ˜ao precisa verificar a frequ ˆencia dos RGs eles sempre apresentam frequ ˆencia maior ou igualγ. Dessa forma, a ´unica verificac¸ ˜ao necess ´aria no contexto da func¸ ˜aoV alidateAndClosese refere ao tamanho do grupo, que deve ser maior ou igual a β.
A func¸ ˜aoV alidateAndCloserecebe como entrada um conjunto de RGs referentes a um candidato e o valor definido pelo usu ´ario como tamanho m´ınimo do grupo. Para cada elemento do conjunto de RGs recebido como entrada, que possua o valor do atributo closedcom o valor falso (linhas 3 a 8), a func¸ ˜ao altera o valor do atributoclosed para verdadeiro(linha 4) e verifica se o tamanho do grupo ´e menor que o permitido (linha 5), se sim, ele ´e adicionado a um conjunto de elementos que ser ˜ao removidos (linha 6). Por fim, a func¸ ˜ao remove do conjunto de entrada todos os elementos marcados para remoc¸ ˜ao (linhas 9 a 11). Como sa´ıda, o algoritmo fornece o conjunto atualizado dos RG recebidos, sendo agora todos validados quanto ao tamanho m´ınimo do grupo. Dessa forma, um conjunto de KRG.
Algoritmo 7 – ValidateAndClose Input: RG, β
1 begin
2 toRemove← ∅
3 foreach(rg∈RG|rg.closed=F alse)do
4 rg.closed←T rue
5 if(length(rg.g)< β)then
6 toRemove←toRemove+rg
7 end
8 end
9 foreach(k∈toRemove)do
10 RG←RG−k
11 end
12 end
Output:RG
Lema paraF indKernelRangeGroup: Sejamc edum candidato e a transac¸ ˜ao atual deD, respectivamente. O Algoritmo 2 em conjunto com a func¸ ˜aoV alidateAndClose torna poss´ıvel encontrar todos os KRG.
Prova: Sejarg∈c.rgs, um KRG da sequ ˆenciasno per´ıodo de tempor e grupo gap ´os a execuc¸ ˜ao da func¸ ˜aoV alidateAndClose; (i.e. rgn ˜ao pode ser descoberto por meio de uni ˜ao com qualquer outro KRG cujo atributoclosedtenha valorfalsoemc.rgs, ent ˜ao:
1. f req(s, r, g)≥γ. De acordo com a definic¸ ˜ao de KRG (Definic¸ ˜ao 1),s ´e frequente em cada KRG. Assim, o Algoritmo 2 gera os RG iniciais em ques ´e frequente e, se rg ´e um novo KRG resultante de um processo de uni ˜ao, ele verifica a frequ ˆencia desemrg. Suponha quef req(s, r, g)< γ, o Algoritmo 2 n ˜ao poderia ter criadorg como um KRG, o que seria uma contradic¸ ˜ao.
2. |g| ≥ β. De acordo com a Definic¸ ˜ao 1, g tem um tamanho m´ınimo. Assim, o Algoritmo 2 ou a func¸ ˜aoV alidateAndClosevalidaramrgverificando o limite definido pelo usu ´arioβ. Suponha que|g|< β, o Algoritmo 2 ou a func¸ ˜aoV alidateAndClose n ˜ao poderiam ter validado o tamanho degergn ˜ao seria um KRG, o que seria uma contradic¸ ˜ao.
3. ∀atal quea⊂reas=rs, temos os dois casos:
• s ´e suportado pela primeira e ´ultima marcac¸ ˜oes de tempo emr. Ent ˜ao,stem suporte inferior em qualquer sub-faixa der.
• f req(s, a, g)≥γ, caso contr ´ario,an ˜ao teria sido estendido para chegar ar, o que seria uma contradic¸ ˜ao.
4. ∀bem um grupo tal queg⊆b, temos por definic¸ ˜ao queoccur(s, r, b−g) = 0, ent ˜ao occur(s, r, b) =occur(s, r, g).
5. socorre em todas assts(g), caso contr ´ario, se existir uma TS que n ˜ao contenha uma ocorr ˆencia des, ela n ˜ao ser ´a inclu´ıda emsts(g). Ent ˜ao, o n ´umero de ocorr ˆencias de sem qualquer subconjuntobdeg ´e menor que emg:occur(s, r, b)< occur(s, r, g).
Com base nas cinco observac¸ ˜oes acima, c.rgs ´e formado por todos os KRG descobertos desemP ReP Glevando em contaγ,β eσ. Assim,KRG ´e o conjunto de todos os KRGkrg= (s, r, g)emP ReP Glevando em contaγ,β eσ.
Uma prova semelhante ´e aplicada para a definic¸ ˜ao de SRG na pr ´oxima subsec¸ ˜ao.