Vinicius Coelho, profile picture
Carregado porVinicius Coelho
287 visualizações

Aplicação do k-NN utilizando Bitonic Sort

1) O documento descreve a aplicação do algoritmo k-NN (k vizinhos mais próximos) utilizando a ordenação Bitônica para resolver o problema da mochila fracionária, onde objetos podem ser colocados parcialmente na mochila. 2) É apresentada a estrutura de dados, funções e algoritmos como Quicksort e Bitônica Sort utilizados para ordenar os elementos e resolver o problema da mochila fracionária de forma paralela. 3) Os resultados da abordagem paralela utilizando Bitônica Sort são comparados com

Incorporar apresentação

Baixar para ler offline
Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos A aplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho Instituto de Inform´atica Universidade Federal de Goi´as (UFG)
Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos A aplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados T´opicos 1 A aplica¸c˜ao; 2 Codifica¸c˜ao; 3 Resultados;
Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos A aplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Mochila fracion´aria Porque a mochila fracion´aria?
Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos A aplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Mochila fracion´aria Porque a mochila fracion´aria? Ela utiliza de um algoritmo guloso que visa preencher a mochila de forma a maximixar o valor. Utilizando a ordena¸c˜ao, teremos os valores j´a agrupados, onde o n-´esimo elemento possui maior valor por unidade de peso.
Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos A aplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Mochila fracion´aria Por exemplo: entre os elementos A, B e C, com respectivos valores e pesos (1020, 29), (340, 7) e (580, 13), qual a melhor escolha para preencher uma mochila de capacidade 450, de forma que maximize o valor?
Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos A aplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Mochila fracion´aria Por exemplo: entre os elementos A, B e C, com respectivos valores e pesos (1020, 29), (340, 7) e (580, 13), qual a melhor escolha para preencher uma mochila de capacidade 450, de forma que maximize o valor? Como a mochila aceita valores fracionados, a melhor escolha seria ordenar estes elementos, de forma que o de mais importˆancia ser´a o elemento com maior valor por unidade de peso. Portanto a ordem ficaria: (1020, 29), (580, 13) e (340, 7).
Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos A aplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Mochila fracion´aria Com a ideia dos k-vizinhos mais pr´oximos, o objetivo ´e: dada uma mochila de capacidade x, uma posi¸c˜ao n em um vetor e um n´umero m´aximo k de elementos adjacentes a n, qual a escolha que maximiza o valor e utiliza a maior capacidade poss´ıvel da mochila?
Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos A aplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Estrutura 1 #i n c l u d e <c s t d i o> 2 #i n c l u d e <c s t d l i b > 3 #i n c l u d e <cmath> 4 #i n c l u d e <u t i l i t y > 5 #i n c l u d e <iostream> 6 #d e f i n e THREADS 512 // 2ˆ9 7 #d e f i n e BLOCKS 32768 // 2ˆ15 8 #d e f i n e NUM VALS 2∗THREADS∗BLOCKS 9 #d e f i n e CAPACITY 67108864 10 #d e f i n e CUT 100000 11 #d e f i n e mp make pair 12 13 using namespace std ; 14 15 typedef pair<int , pair<double , double> > idd ; 16 17 s t r u c t kNN{ 18 double value , weight ; 19 kNN( double v a l u e = 0.0 , double weight = 0.0 ) : v a l u e ( v a l u e ) , weight ( weight ) {} 20 };
Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos A aplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Fun¸c˜oes 1 void p r i n t e l a p s e d ( c l o c k t s t a r t , c l o c k t stop ){ 2 double e l a p s e d = (( double ) ( stop − s t a r t ) ) / CLOCKS PER SEC ; 3 p r i n t f ( ” Elapsed time : %.3 f s n” , e l a p s e d ) ; 4 } 5 6 /∗Gera¸c˜ao a l e a t ´o r i a dos elementos que compoem o a r r a y ∗/ 7 double random (){ 8 double r = f a b s ( rand () + rand () ) /CUT; 9 i f ( r < 1.0 ) r += 1 . 0 ; 10 return r ; 11 } 12 13 void a r r a y f i l l (kNN ∗arr , i n t l e n g t h ){ 14 srand ( time (NULL) ) ; 15 f o r ( i n t i = 0; i < l e n g t h ; ++i ){ 16 a r r [ i ] . v a l u e = 2∗ c e i l ( random () ) ; 17 a r r [ i ] . weight = c e i l ( random () ) ; 18 } 19 }
Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos A aplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Fractionary Knapsack 1 idd f r a c t i o n a r y k n a p s a c k ( kNN ∗values , i n t pos , i n t k , double a t u a l c a p a c i t y ){ 2 i n t s t a r t p o s = pos + k − 1 , q t d i t e m s = 0; 3 double max value = 0.0 , cap reached = 0 . 0 ; 4 i f ( s t a r t p o s >= NUM VALS ) s t a r t p o s = NUM VALS−1; 5 f o r ( i n t i = s t a r t p o s ; i >= 0 && i >= pos ; i−− ){ 6 i f ( v a l u e s [ i ] . weight == 0.0 ) continue ; 7 i f ( a t u a l c a p a c i t y == 0.0 ) break ; 8 double aux = a t u a l c a p a c i t y − v a l u e s [ i ] . weight ; /∗Get the amount of ’ i ’ capable to f i l l the sack ∗/ 9 i f ( aux < 0.0 ){ 10 double v a l u e u s e d = ( v a l u e s [ i ] . v a l u e / v a l u e s [ i ] . weight )∗ a t u a l c a p a c i t y ; 11 cap reached += a t u a l c a p a c i t y ; 12 a t u a l c a p a c i t y = 0 . 0 ; 13 max value += v a l u e u s e d ; 14 v a l u e s [ i ] . weight −= a t u a l c a p a c i t y ; 15 q t d i t e m s++; 16 } 17 e l s e { 18 a t u a l c a p a c i t y −= v a l u e s [ i ] . weight ; 19 cap reached += v a l u e s [ i ] . weight ; 20 max value += v a l u e s [ i ] . v a l u e ; 21 v a l u e s [ i ] . weight = 0 . 0 ; 22 q t d i t e m s++; 23 } 24 } 25 return mp( qtd items , mp( cap reached , max value ) ) ; 26 }
Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos A aplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Quick Sort 1 void swap (kNN ∗a , kNN ∗b ) { 2 kNN tmp = ∗a ; 3 ∗a = ∗b ; 4 ∗b = tmp ; 5 } 6 7 i n t p a r t i t i o n (kNN ∗vec , i n t l e f t , i n t r i g h t ){ 8 i n t i , j ; 9 i = l e f t ; 10 f o r ( j = l e f t + 1; j <= r i g h t ; ++j ){ 11 i f ( vec [ j ] . v a l u e / vec [ j ] . weight > vec [ l e f t ] . v a l u e / vec [ l e f t ] . weight ) { 12 ++i ; 13 swap(&vec [ i ] , &vec [ j ] ) ; 14 } 15 } 16 swap(&vec [ l e f t ] , &vec [ i ] ) ; 17 return i ; 18 } 19 20 void q u i c k s o r t (kNN ∗vec , i n t l e f t , i n t r i g h t ) { 21 i n t r ; 22 i f ( r i g h t > l e f t ){ 23 r = p a r t i t i o n ( vec , l e f t , r i g h t ) ; 24 q u i c k s o r t ( vec , l e f t , r −1) ; 25 q u i c k s o r t ( vec , r +1, r i g h t ) ; 26 } 27 }
Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos A aplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Bitonic Sort 1 void b i t o n i c s o r t (kNN ∗ v a l u e s ){ 2 kNN ∗ d e v v a l u e s ; 3 s i z e t s i z e = NUM VALS ∗ s i z e o f (kNN) ; 4 5 cudaMalloc (( void ∗∗) &dev values , s i z e ) ; 6 cudaMemcpy( dev values , values , s i z e , cudaMemcpyHostToDevice ) ; 7 8 dim3 b l o c k s (BLOCKS, 1) ; /∗ Number of b l o c k s ∗/ 9 dim3 t h r e a d s (THREADS, 1) ; /∗ Number of t h r e a d s ∗/ 10 11 /∗ Major step ∗/ 12 f o r ( i n t k = 2; k <= NUM VALS; k <<= 1 ){ 13 /∗ Minor step ∗/ 14 f o r ( i n t j = k>>1; j > 0; j = j>>1 ){ 15 b i t o n i c s o r t s t e p<<<blocks , t h r e a d s>>>( dev values , j , k ) ; 16 } 17 } 18 cudaMemcpy( values , dev values , s i z e , cudaMemcpyDeviceToHost ) ; 19 cudaFree ( d e v v a l u e s ) ; 20 }
Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos A aplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Bitonic Step 1 g l o b a l void b i t o n i c s o r t s t e p (kNN ∗dev values , i n t j , i n t k ){ 2 unsigned i n t i , i x j ; /∗ S o r t i n g p a r t n e r s : i and i x j ∗/ 3 i = t h r e a d I d x . x + blockDim . x ∗ b l o c k I d x . x ; 4 i x j = i ˆ j ; 5 6 /∗ The t h r e a d s with the lo west i d s s o r t the a r r a y . ∗/ 7 i f ( i x j > i ){ 8 i f ( ( i & k ) == 0 ){ 9 /∗ Sort ascending ∗/ 10 i f ( d e v v a l u e s [ i ] . v a l u e / d e v v a l u e s [ i ] . weight < d e v v a l u e s [ i x j ] . v a l u e / d e v v a l u e s [ i x j ] . weight ){ 11 /∗ exchange ( i , i x j ) ; ∗/ 12 kNN temp = d e v v a l u e s [ i ] ; 13 d e v v a l u e s [ i ] = d e v v a l u e s [ i x j ] ; 14 d e v v a l u e s [ i x j ] = temp ; 15 } 16 } 17 i f ( ( i & k ) != 0 ){ 18 /∗ Sort descending ∗/ 19 i f ( d e v v a l u e s [ i ] . v a l u e / d e v v a l u e s [ i ] . weight > d e v v a l u e s [ i x j ] . v a l u e / d e v v a l u e s [ i x j ] . weight ){ 20 /∗ exchange ( i , i x j ) ; ∗/ 21 kNN temp = d e v v a l u e s [ i ] ; 22 d e v v a l u e s [ i ] = d e v v a l u e s [ i x j ] ; 23 d e v v a l u e s [ i x j ] = temp ; 24 } 25 } 26 } 27 }
Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos A aplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Main 1 i n t main (){ 2 c l o c k t s t a r t , stop ; 3 i n t k , pos ; 4 double c a p a c i t y ; 5 kNN ∗ v a l u e s = (kNN∗) malloc ( NUM VALS ∗ s i z e o f (kNN) ) ; 6 a r r a y f i l l ( values , NUM VALS) ; 7 pos = rand () % NUM VALS; 8 k = rand () % NUM VALS; 9 c a p a c i t y = rand () % CAPACITY ; 10 11 p r i n t f ( ”Number of v a l u e s : %dn” , NUM VALS) ; 12 p r i n t f ( ” P o s i t i o n : %dn” , pos ) ; 13 p r i n t f ( ”k−n e a r e s t range : %dn” , k ) ; 14 p r i n t f ( ” Capacity : %.0 f n” , c a p a c i t y ) ; 15 16 s t a r t = c l o c k () ; 17 q u i c k s o r t ( values , 0 , NUM VALS−1) ; /∗Na vers˜ao p a r a l e l a , t r o c a r a chamada por b i t o n i c s o r t ( v a l u e s )∗/ 18 stop = c l o c k () ; 19 20 idd r e s p = f r a c t i o n a r y k n a p s a c k ( values , pos , k , c a p a c i t y ) ; 21 p r i n t f ( ”Numbers of items i n the sack : %dn” , r e s p . f i r s t ) ; 22 p r i n t f ( ” Capacity reached : %.0 f n” , r e s p . second . f i r s t ) ; 23 p r i n t f ( ”Maximum v a l u e reached : %.2 f n” , r e s p . second . second ) ; 24 p r i n t e l a p s e d ( s t a r t , stop ) ; 25 26 return 0; 27 }
Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos A aplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Ambiente de Teste GPU: Tesla C2070 CPU: Core 2 Duo 2.4Ghz 448 cores, 1.15Ghz 14 SM (32 cores)
Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos A aplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Resultados Figure: Quantidade de elementos: 524.288
Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos A aplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Resultados Figure: Quantidade de elementos: 524.288 Speed up: 0.36
Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos A aplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Resultados Figure: Quantidade de elementos: 2.097.152
Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos A aplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Resultados Figure: Quantidade de elementos: 2.097.152 Speed up: 1.77
Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos A aplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Resultados Figure: Quantidade de elementos: 8.388.608
Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos A aplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Resultados Figure: Quantidade de elementos: 8.388.608 Speed up: 5.91
Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos A aplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Resultados Figure: Quantidade de elementos: 33.554.432
Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos A aplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Resultados Figure: Quantidade de elementos: 33.554.432 Speed up: 11.78
Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos A aplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Perguntas?

Mais conteúdo relacionado

PDF
kNN
porVinicius Coelho
 
PDF
09 problemas de grafos np-completos
porYuri Passos
 
PDF
Treinamento para Competições de Programacão - Single-Source Shortest Paths: D...
porMurilo Adriano Vasconcelos
 
PDF
Treinamento Para Competições de Programação - All Pairs Shortest Paths - O Al...
porMurilo Adriano Vasconcelos
 
PDF
Ita2013 1dia
porcavip
 
PDF
Redes de-petri-2
porleonamloureiro
 
PDF
Data stream mining - TDC POA 2018 (Data Science)
porAndre Nunes
 
DOC
Lista 1 - Robótica (Jim & Ronie)
porJim Naturesa
 
kNN
porVinicius Coelho
 
09 problemas de grafos np-completos
porYuri Passos
 
Treinamento para Competições de Programacão - Single-Source Shortest Paths: D...
porMurilo Adriano Vasconcelos
 
Treinamento Para Competições de Programação - All Pairs Shortest Paths - O Al...
porMurilo Adriano Vasconcelos
 
Ita2013 1dia
porcavip
 
Redes de-petri-2
porleonamloureiro
 
Data stream mining - TDC POA 2018 (Data Science)
porAndre Nunes
 
Lista 1 - Robótica (Jim & Ronie)
porJim Naturesa
 

Mais procurados

DOCX
Proxima postagem
porKaroline Tavares
 
PDF
MÉTODO DE LAGRANGE - ALGEBRA LINEAR II
porJailson Nascimento
 
PDF
Tarefa10
porLuan Gabriel
 
PDF
02 maquinas de turing modificadas
porYuri Passos
 
DOC
Análise de Sistemas II - Modelamento e identificação de sistemas
porCiro Marcus
 
PDF
Algoritmos aproximativos
porFernando Simeone
 
PDF
Algebra Linear cap 06
porAndrei Bastos
 
DOCX
Ha
porTalles Faria
 
DOC
Trigonometria fórmls exc
porWellington Moreira
 
PDF
Apostila funcao-de-segundo-grau
porPetronio Paniago
 
PPTX
Caminhos Mínimos - Algoritmo de Dijkstra
porMarcos Castro
 
PDF
Obf2007 3 fase_3serie_teorica_gabarito
porKaroline Tavares
 
PDF
Lista exercicios 2 calculo 2
pormarcio cerqueira
 
PDF
Lista1 amazonas
porPhilippe Fanaro
 
PDF
Apreçando Opções Utilizando a Função Característica
porWilson Freitas
 
PDF
Caminho Mínimo em Grafos - Algoritmo de Bellman-Ford
porGabriel Albuquerque
 
Proxima postagem
porKaroline Tavares
 
MÉTODO DE LAGRANGE - ALGEBRA LINEAR II
porJailson Nascimento
 
Tarefa10
porLuan Gabriel
 
02 maquinas de turing modificadas
porYuri Passos
 
Análise de Sistemas II - Modelamento e identificação de sistemas
porCiro Marcus
 
Algoritmos aproximativos
porFernando Simeone
 
Algebra Linear cap 06
porAndrei Bastos
 
Ha
porTalles Faria
 
Trigonometria fórmls exc
porWellington Moreira
 
Apostila funcao-de-segundo-grau
porPetronio Paniago
 
Caminhos Mínimos - Algoritmo de Dijkstra
porMarcos Castro
 
Obf2007 3 fase_3serie_teorica_gabarito
porKaroline Tavares
 
Lista exercicios 2 calculo 2
pormarcio cerqueira
 
Lista1 amazonas
porPhilippe Fanaro
 
Apreçando Opções Utilizando a Função Característica
porWilson Freitas
 
Caminho Mínimo em Grafos - Algoritmo de Bellman-Ford
porGabriel Albuquerque
 

Aplicação do k-NN utilizando Bitonic Sort

  • 1.
    Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos Aaplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho Instituto de Inform´atica Universidade Federal de Goi´as (UFG)
  • 2.
    Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos Aaplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados T´opicos 1 A aplica¸c˜ao; 2 Codifica¸c˜ao; 3 Resultados;
  • 3.
    Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos Aaplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Mochila fracion´aria Porque a mochila fracion´aria?
  • 4.
    Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos Aaplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Mochila fracion´aria Porque a mochila fracion´aria? Ela utiliza de um algoritmo guloso que visa preencher a mochila de forma a maximixar o valor. Utilizando a ordena¸c˜ao, teremos os valores j´a agrupados, onde o n-´esimo elemento possui maior valor por unidade de peso.
  • 5.
    Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos Aaplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Mochila fracion´aria Por exemplo: entre os elementos A, B e C, com respectivos valores e pesos (1020, 29), (340, 7) e (580, 13), qual a melhor escolha para preencher uma mochila de capacidade 450, de forma que maximize o valor?
  • 6.
    Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos Aaplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Mochila fracion´aria Por exemplo: entre os elementos A, B e C, com respectivos valores e pesos (1020, 29), (340, 7) e (580, 13), qual a melhor escolha para preencher uma mochila de capacidade 450, de forma que maximize o valor? Como a mochila aceita valores fracionados, a melhor escolha seria ordenar estes elementos, de forma que o de mais importˆancia ser´a o elemento com maior valor por unidade de peso. Portanto a ordem ficaria: (1020, 29), (580, 13) e (340, 7).
  • 7.
    Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos Aaplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Mochila fracion´aria Com a ideia dos k-vizinhos mais pr´oximos, o objetivo ´e: dada uma mochila de capacidade x, uma posi¸c˜ao n em um vetor e um n´umero m´aximo k de elementos adjacentes a n, qual a escolha que maximiza o valor e utiliza a maior capacidade poss´ıvel da mochila?
  • 8.
    Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos Aaplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Estrutura 1 #i n c l u d e <c s t d i o> 2 #i n c l u d e <c s t d l i b > 3 #i n c l u d e <cmath> 4 #i n c l u d e <u t i l i t y > 5 #i n c l u d e <iostream> 6 #d e f i n e THREADS 512 // 2ˆ9 7 #d e f i n e BLOCKS 32768 // 2ˆ15 8 #d e f i n e NUM VALS 2∗THREADS∗BLOCKS 9 #d e f i n e CAPACITY 67108864 10 #d e f i n e CUT 100000 11 #d e f i n e mp make pair 12 13 using namespace std ; 14 15 typedef pair<int , pair<double , double> > idd ; 16 17 s t r u c t kNN{ 18 double value , weight ; 19 kNN( double v a l u e = 0.0 , double weight = 0.0 ) : v a l u e ( v a l u e ) , weight ( weight ) {} 20 };
  • 9.
    Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos Aaplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Fun¸c˜oes 1 void p r i n t e l a p s e d ( c l o c k t s t a r t , c l o c k t stop ){ 2 double e l a p s e d = (( double ) ( stop − s t a r t ) ) / CLOCKS PER SEC ; 3 p r i n t f ( ” Elapsed time : %.3 f s n” , e l a p s e d ) ; 4 } 5 6 /∗Gera¸c˜ao a l e a t ´o r i a dos elementos que compoem o a r r a y ∗/ 7 double random (){ 8 double r = f a b s ( rand () + rand () ) /CUT; 9 i f ( r < 1.0 ) r += 1 . 0 ; 10 return r ; 11 } 12 13 void a r r a y f i l l (kNN ∗arr , i n t l e n g t h ){ 14 srand ( time (NULL) ) ; 15 f o r ( i n t i = 0; i < l e n g t h ; ++i ){ 16 a r r [ i ] . v a l u e = 2∗ c e i l ( random () ) ; 17 a r r [ i ] . weight = c e i l ( random () ) ; 18 } 19 }
  • 10.
    Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos Aaplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Fractionary Knapsack 1 idd f r a c t i o n a r y k n a p s a c k ( kNN ∗values , i n t pos , i n t k , double a t u a l c a p a c i t y ){ 2 i n t s t a r t p o s = pos + k − 1 , q t d i t e m s = 0; 3 double max value = 0.0 , cap reached = 0 . 0 ; 4 i f ( s t a r t p o s >= NUM VALS ) s t a r t p o s = NUM VALS−1; 5 f o r ( i n t i = s t a r t p o s ; i >= 0 && i >= pos ; i−− ){ 6 i f ( v a l u e s [ i ] . weight == 0.0 ) continue ; 7 i f ( a t u a l c a p a c i t y == 0.0 ) break ; 8 double aux = a t u a l c a p a c i t y − v a l u e s [ i ] . weight ; /∗Get the amount of ’ i ’ capable to f i l l the sack ∗/ 9 i f ( aux < 0.0 ){ 10 double v a l u e u s e d = ( v a l u e s [ i ] . v a l u e / v a l u e s [ i ] . weight )∗ a t u a l c a p a c i t y ; 11 cap reached += a t u a l c a p a c i t y ; 12 a t u a l c a p a c i t y = 0 . 0 ; 13 max value += v a l u e u s e d ; 14 v a l u e s [ i ] . weight −= a t u a l c a p a c i t y ; 15 q t d i t e m s++; 16 } 17 e l s e { 18 a t u a l c a p a c i t y −= v a l u e s [ i ] . weight ; 19 cap reached += v a l u e s [ i ] . weight ; 20 max value += v a l u e s [ i ] . v a l u e ; 21 v a l u e s [ i ] . weight = 0 . 0 ; 22 q t d i t e m s++; 23 } 24 } 25 return mp( qtd items , mp( cap reached , max value ) ) ; 26 }
  • 11.
    Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos Aaplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Quick Sort 1 void swap (kNN ∗a , kNN ∗b ) { 2 kNN tmp = ∗a ; 3 ∗a = ∗b ; 4 ∗b = tmp ; 5 } 6 7 i n t p a r t i t i o n (kNN ∗vec , i n t l e f t , i n t r i g h t ){ 8 i n t i , j ; 9 i = l e f t ; 10 f o r ( j = l e f t + 1; j <= r i g h t ; ++j ){ 11 i f ( vec [ j ] . v a l u e / vec [ j ] . weight > vec [ l e f t ] . v a l u e / vec [ l e f t ] . weight ) { 12 ++i ; 13 swap(&vec [ i ] , &vec [ j ] ) ; 14 } 15 } 16 swap(&vec [ l e f t ] , &vec [ i ] ) ; 17 return i ; 18 } 19 20 void q u i c k s o r t (kNN ∗vec , i n t l e f t , i n t r i g h t ) { 21 i n t r ; 22 i f ( r i g h t > l e f t ){ 23 r = p a r t i t i o n ( vec , l e f t , r i g h t ) ; 24 q u i c k s o r t ( vec , l e f t , r −1) ; 25 q u i c k s o r t ( vec , r +1, r i g h t ) ; 26 } 27 }
  • 12.
    Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos Aaplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Bitonic Sort 1 void b i t o n i c s o r t (kNN ∗ v a l u e s ){ 2 kNN ∗ d e v v a l u e s ; 3 s i z e t s i z e = NUM VALS ∗ s i z e o f (kNN) ; 4 5 cudaMalloc (( void ∗∗) &dev values , s i z e ) ; 6 cudaMemcpy( dev values , values , s i z e , cudaMemcpyHostToDevice ) ; 7 8 dim3 b l o c k s (BLOCKS, 1) ; /∗ Number of b l o c k s ∗/ 9 dim3 t h r e a d s (THREADS, 1) ; /∗ Number of t h r e a d s ∗/ 10 11 /∗ Major step ∗/ 12 f o r ( i n t k = 2; k <= NUM VALS; k <<= 1 ){ 13 /∗ Minor step ∗/ 14 f o r ( i n t j = k>>1; j > 0; j = j>>1 ){ 15 b i t o n i c s o r t s t e p<<<blocks , t h r e a d s>>>( dev values , j , k ) ; 16 } 17 } 18 cudaMemcpy( values , dev values , s i z e , cudaMemcpyDeviceToHost ) ; 19 cudaFree ( d e v v a l u e s ) ; 20 }
  • 13.
    Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos Aaplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Bitonic Step 1 g l o b a l void b i t o n i c s o r t s t e p (kNN ∗dev values , i n t j , i n t k ){ 2 unsigned i n t i , i x j ; /∗ S o r t i n g p a r t n e r s : i and i x j ∗/ 3 i = t h r e a d I d x . x + blockDim . x ∗ b l o c k I d x . x ; 4 i x j = i ˆ j ; 5 6 /∗ The t h r e a d s with the lo west i d s s o r t the a r r a y . ∗/ 7 i f ( i x j > i ){ 8 i f ( ( i & k ) == 0 ){ 9 /∗ Sort ascending ∗/ 10 i f ( d e v v a l u e s [ i ] . v a l u e / d e v v a l u e s [ i ] . weight < d e v v a l u e s [ i x j ] . v a l u e / d e v v a l u e s [ i x j ] . weight ){ 11 /∗ exchange ( i , i x j ) ; ∗/ 12 kNN temp = d e v v a l u e s [ i ] ; 13 d e v v a l u e s [ i ] = d e v v a l u e s [ i x j ] ; 14 d e v v a l u e s [ i x j ] = temp ; 15 } 16 } 17 i f ( ( i & k ) != 0 ){ 18 /∗ Sort descending ∗/ 19 i f ( d e v v a l u e s [ i ] . v a l u e / d e v v a l u e s [ i ] . weight > d e v v a l u e s [ i x j ] . v a l u e / d e v v a l u e s [ i x j ] . weight ){ 20 /∗ exchange ( i , i x j ) ; ∗/ 21 kNN temp = d e v v a l u e s [ i ] ; 22 d e v v a l u e s [ i ] = d e v v a l u e s [ i x j ] ; 23 d e v v a l u e s [ i x j ] = temp ; 24 } 25 } 26 } 27 }
  • 14.
    Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos Aaplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Main 1 i n t main (){ 2 c l o c k t s t a r t , stop ; 3 i n t k , pos ; 4 double c a p a c i t y ; 5 kNN ∗ v a l u e s = (kNN∗) malloc ( NUM VALS ∗ s i z e o f (kNN) ) ; 6 a r r a y f i l l ( values , NUM VALS) ; 7 pos = rand () % NUM VALS; 8 k = rand () % NUM VALS; 9 c a p a c i t y = rand () % CAPACITY ; 10 11 p r i n t f ( ”Number of v a l u e s : %dn” , NUM VALS) ; 12 p r i n t f ( ” P o s i t i o n : %dn” , pos ) ; 13 p r i n t f ( ”k−n e a r e s t range : %dn” , k ) ; 14 p r i n t f ( ” Capacity : %.0 f n” , c a p a c i t y ) ; 15 16 s t a r t = c l o c k () ; 17 q u i c k s o r t ( values , 0 , NUM VALS−1) ; /∗Na vers˜ao p a r a l e l a , t r o c a r a chamada por b i t o n i c s o r t ( v a l u e s )∗/ 18 stop = c l o c k () ; 19 20 idd r e s p = f r a c t i o n a r y k n a p s a c k ( values , pos , k , c a p a c i t y ) ; 21 p r i n t f ( ”Numbers of items i n the sack : %dn” , r e s p . f i r s t ) ; 22 p r i n t f ( ” Capacity reached : %.0 f n” , r e s p . second . f i r s t ) ; 23 p r i n t f ( ”Maximum v a l u e reached : %.2 f n” , r e s p . second . second ) ; 24 p r i n t e l a p s e d ( s t a r t , stop ) ; 25 26 return 0; 27 }
  • 15.
    Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos Aaplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Ambiente de Teste GPU: Tesla C2070 CPU: Core 2 Duo 2.4Ghz 448 cores, 1.15Ghz 14 SM (32 cores)
  • 16.
    Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos Aaplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Resultados Figure: Quantidade de elementos: 524.288
  • 17.
    Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos Aaplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Resultados Figure: Quantidade de elementos: 524.288 Speed up: 0.36
  • 18.
    Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos Aaplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Resultados Figure: Quantidade de elementos: 2.097.152
  • 19.
    Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos Aaplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Resultados Figure: Quantidade de elementos: 2.097.152 Speed up: 1.77
  • 20.
    Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos Aaplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Resultados Figure: Quantidade de elementos: 8.388.608
  • 21.
    Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos Aaplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Resultados Figure: Quantidade de elementos: 8.388.608 Speed up: 5.91
  • 22.
    Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos Aaplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Resultados Figure: Quantidade de elementos: 33.554.432
  • 23.
    Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos Aaplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Resultados Figure: Quantidade de elementos: 33.554.432 Speed up: 11.78
  • 24.
    Aplica¸c˜ao do k-NN utilizando Bitonic Sort Maur´ıcio Jourdan, Paulo Henrique, Pedro Braganick, Vin´ıcius Coelho T´opicos Aaplica¸c˜ao Codifica¸c˜ao Estrutura Fun¸c˜oes Fractionary Knapsack Quick Sort Bitonic Sort Bitonic Step Main do C´odigo Serial Ambiente de teste Resultados Perguntas?