Classificação em R - Funções e tipos de classificação em R com códigos de amostra

• Introdução à classificação em R

Introdução à classificação em R

A classificação é um dos aspectos cruciais da análise de dados. É uma técnica na qual os dados são organizados ou segregados em uma ordem específica. Os dados são classificados para extrair as informações necessárias do conjunto de dados. Por exemplo, organizando os dados em ordem crescente com base na chave de data, aqui os critérios foram especificados para classificação. Esta operação pode ser realizada facilmente usando o idioma R. Na linguagem R, existem várias funções de classificação, como classificação de bolhas e classificação. Neste artigo, veremos a importância de diferentes funções de classificação e explicaremos cada uma delas com exemplos.

Classificação realizada em R

Existem várias maneiras pelas quais os dados podem ser classificados em R. Cabe ao analista de dados considerar o método mais adequado com base na estrutura dos dados. A linguagem R possui várias funções e maneiras de classificar os dados, como pacote sort (), order () e dplyrI ().

Itens a serem lembrados antes de classificar os dados.

1. Ordem na qual os dados precisam ser classificados em ordem crescente ou decrescente.
2. Critérios de classificação de várias colunas.
3. Contabilização de valores ausentes e duplicados durante a classificação. Cabe ao analista decidir o que deve ser feito com os valores ausentes e duplicados. Antes de remover ou substituir valores nulos, o impacto geral nos dados deve ser considerado.

Função Sort () em R

A função de classificação em R é usada para classificar um vetor. Por padrão, o valor é organizado em ordem crescente. Vamos dar um exemplo da coluna da marca de todos os alunos em uma sala de aula.

A sintaxe para classificar o vetor é

“sort (x, decreasing = FALSE)”

Aqui x refere-se ao vetor e a redução deve ser substituída para TRUE quando a classificação precisar ser feita em ordem decrescente. A função de classificação é usada para organizar o vetor numérico ou de caracteres na ordem desejada. A principal limitação da função de classificação é que ela não pode ser usada para classificar um quadro de dados. Para superar essa limitação, a função Order () é usada.

Um exemplo básico de classificação usando a função sort ()

set.seed(1)
x <- sample(1:100, 10)
x

Resultado
(1) 68 39 1 34 87 43 14 82 59 51

ordenar (x)

Resultado

(1) 1 14 34 39 43 51 59 68 82 87

A classificação dos quadros de dados pode ser realizada com a ajuda da função order (). As variáveis ​​podem ser facilmente classificadas em ordem crescente ou decrescente; no entanto, a função de ordem classifica a variável em ordem crescente por padrão.

> df <- data.frame("Serial_number" = 1:5, "Age" = c(20, 21, 17, 18, 19), "Name" = c("Johnny", "Dorian", "Linda", "Cathy", "Rick"))
>
> # Sort by age ascending order
> newdataAsc newdataAsc

# sorting is descending order
> newdataDsc> newdataDsc newdataAsc

Observe que o sinal negativo é usado na frente da coluna Idade (-df $ Age) para classificar a Idade em ordem decrescente. Como alternativa, o argumento descendente pode ser usado nessa posição. A função Order é usada para se referir ao índice da coluna em vez do nome da coluna. Por exemplo, no lugar da idade, a referência de índice do quadro de dados que seria "1". Tendo em mente os valores do índice começam um "0".

Em alguns casos, pode ser necessário classificar os dados com vários critérios; isso pode ser alcançado em R com a ajuda do uso de nomes de variáveis ​​ou números de índice. No exemplo abaixo, usei o conjunto de dados mtcars, disponível no R studio.

df <- mtcars
> df
> # sort the dataframe by key disp
> df(with(df, order(mpg, disp)), )
> # Sort by column index values
> df(order( df(, 1), df(, 3) ), )

No R, uma maneira alternativa de classificar os dados é usando o pacote dplyr. Este pacote é muito fácil de usar e confiável, com instruções precisas disponíveis.

> install.packages("dplyr")
> library(dplyr)
> df <- mtcars
>
> # sort the dataframe by key disp
> arrange(mydata, disp)

Tipos de classificação em R

R está equipado com vários algoritmos para realizar a classificação nos dados. Abaixo estão os diferentes tipos de função de classificação. Para ilustrar os diferentes tipos de classificação, é usada uma amostra de 10 números aleatórios de uma matriz.

1. Classificação por bolhas

Nesse algoritmo, dois valores são comparados lado a lado e os elementos trocam de posição quando os critérios são atendidos. Pode ser crescente ou decrescente. Na bolha, os pares de classificação são formados para os elementos disponíveis na variável e os elementos são comparados entre si, quando um elemento é maior que o outro eles trocam. O processo é repetido até o último elemento.

> bubble_sort <- function (x, ascending = TRUE) (
+ n <- length(x)
+ if (ascending) (
+ for(i in 1:(n-1))(
+ for(j in 1:(ni)) (
+ if(x(j+1) < x(j)) (
+ tmp <- x (j) + x(j) <- x( j+ 1) + x(j+1) <- tmp
+ )
+ )
+ )
+ )
+ else (
+ for(i in 1:(n-1))(
+ for(j in 1:(ni)) (
+ if(x(j+1) > x(j)) (
+ tmp <- x (j) + x(j) <- x( j+ 1) + x(j+1) <- tmp
+ )
+ )
+ )
+ )
+ x
+ )
>
> x <-sample(1:100, 10)
> example <- bubble_sort(x)
> example

Resultado

2. Classificação de Inserção

No algoritmo de classificação por inserção, os elementos classificados e não classificados são comparados e o elemento não classificado é colocado em um local adequado após cada iteração.

Neste algoritmo, assume-se que o primeiro elemento seja classificado e o segundo elemento é armazenado separadamente como um elemento-chave. O elemento classificado é então comparado com a chave. Se o elemento classificado for maior que o elemento chave, os locais serão trocados e o elemento chave será o primeiro elemento.

> insertion_sort <- function(A)(
+ for (j in 2:length(A)) (
+ key = A(j) + i = j - 1
+ while (i > 0 && A(i) > key) (
+ A((i + 1)) = A(i) + i = i - 1
+ )
+ A((i + 1)) = key
+ )
+ A
+ )
>
>
> # testing the insertion function
> x <-sample(1:100, 10)
> example <- insertion_sort(x)
> example

Resultado

3. Seleção da Seleção

A função de classificação de seleção é um algoritmo de classificação amplamente usado na linguagem R. Nesse tipo de classificação, o menor elemento da lista não classificada é enviado para o início da lista. No algoritmo de classificação de seleção, o menor elemento da matriz da lista não classificada é selecionado e colocado no início da lista não classificada a cada iteração. Por exemplo, em uma linha de números organizados em uma sequência aleatória, o elemento ou número inicial é selecionado no mínimo. Na próxima etapa, o número mínimo selecionado é comparado com o próximo elemento ou número. Caso o elemento comparado seja menor que o mínimo selecionado, o segundo elemento se tornará o mínimo. Esse processo é iterado até o último elemento.

> selection_sort <- function (x, ascending = TRUE) (
+ max <- length(x)
+ if (ascending) (
+ for (j in 1:(max-1))(
+ m <- x(j) + p <- j
+ for(k in (j+1):max) (
+ if(x(k) < m) (
+ m <- x(k) + p <- k
+ ) ## end if
+ ) ## end for k
+ x(p) <- x(j) + x(j) <- m
+ ) ## end for j
+ ) ## end ascending if
+ else (
+ for (j in 1:(max-1))(
+ m <- x(j) + p <- j
+ for(k in (j+1):max) (
+ if(x(k) > m) (
+ m <- x(k) + p <- k
+ ) ## end if
+ ) ## end for k
+ x(p) <- x(j) + x(j) <- m
+ ) ## end for j
+ ) ## end ascending else
+ x
+ )
>
>
> # testing the selectionsort function
> x <-sample(1:100, 10)
>
> example <- selection_sort(x)
> example


Resultado

4. Classificação Rápida

O algoritmo Quicksort funciona como dividir e governar. O elemento aleatório é selecionado como um pivô em uma matriz e, em seguida, todos os outros elementos, exceto o pivô, são divididos em duas partições. Na próxima etapa, todos os elementos menores e maiores que o pivô são divididos em duas partições diferentes. Finalmente, os elementos são classificados usando recursão.

> # Quick sort algorithm:
> quickSort <- function(arr) (
+ # Pick a number at random.
+ mid <- sample(arr, 1)
+
+ # Place-holders for left and right values.
+ left <- c()
+ right <- c()
+
+ # Move all the smaller values to the left, bigger values to the right.
+ lapply(arr(arr != mid), function(d) (
+ if (d < mid) (
+ left <<- c(left, d)
+ )
+ else (
+ right <<- c(right, d)
+ )
+ ))
+
+ if (length(left) > 1) (
+ left <- quickSort(left)
+ )
+
+ if (length(right) > 1) (
+ right <- quickSort(right)
+ )
+
+ # Finally, return the sorted values.
+ c(left, mid, right)
+ )
>
> x <-sample(1:100, 10)
>
> RES <- quickSort(x)
> RES

Resultado

5. Mesclar Classificação

A classificação de mesclagem é muito semelhante à quicksort, no entanto, aqui a matriz é dividida em duas metades iguais. O algoritmo de classificação de mesclagem foi dividido em duas partes: uma função de mesclagem e uma de classificação. Na classificação por mesclagem, uma lista é dividida em várias sub-listas até que cada sub-lista consista em um elemento individual. Mesclar os resultados das sub-listas é uma lista classificada.

> mmerge<-function(a, b) (
+ r<-numeric(length(a)+length(b))
+ ai<-1; bi<-1; j<-1;
+ for(j in 1:length(r)) (
+ if((ai<=length(a) && a(ai)length(b)) (
+ r(j) <- a(ai) + ai <- ai+1
+ ) else (
+ r(j) <- b(bi) + bi <- bi+1
+ )
+ )
+ r
+ )
> mmergesort<-function(A) (
+ if(length(A)>1) (
+ q <- ceiling(length(A)/2)
+ a <- mmergesort(A(1:q))
+ b <- mmergesort(A((q+1):length(A)))
+ mmerge(a, b)
+ ) else (
+ A
+ )
+ )
>
> x <-sample(1:100, 10)
>
> RES <- mmergesort(x)
> RES

Resultado

6. HeapSort

A técnica de classificação de heap é muito semelhante à classificação de seleção, na qual o menor elemento de uma lista não classificada é selecionado em cada iteração e é colocado no início da lista. No entanto, a técnica heapsort usa conceitos de árvore.

> heap.structure<-function(vect)
+ (
+ le=length(vect)
+ heap=vec
+ for (k in le:1)
+ (
+ heap=modify_heap(heap, k)
+ )
+ return(heap)
+ )
>
>
> modify_heap<-function(heap, rooti)
+ (
+ le=length(heap)
+ flag=0
+
+ while (rooti*2 <= le && flag==1)
+ (
+ left.i=rooti*2
+ right.i=rooti*2+2
+ flag=1
+ child=c(heap(left.i), heap(right.i))
+ child=child(!is.na(child)) + min.ind=which.min(child)
+ if (heap(rooti)>child(min.ind))
+ (
+ flag=1
+ heap.ind=c(left.i, right.i)(min.ind) +
+ tmp1=heap(heap.ind) + heap(heap.ind)=heap(rooti) + heap(rooti)=tmp1
+
+ rooti=heap.ind
+ )
+ )
+ return(heap)
+ )
>
> heap_sort<-function(heap)
+ (
+ sorted.heap=NULL
+ le=length(heap)
+ while(le>0)
+ (
+ sorted.heap=c(sorted.heap, heap(1))
+ le=length(heap)
+ heap(1)=heap(le) + heap=heap(1:(le-1)) + heap=modify_heap(heap, rooti=1)
+ le=le-1
+ )
+ return(sorted.heap)
+ )
>
>
> x <- sample(1:100, 10)
> heap=heap.building(x)
> heap_sort=heap_sort(heap)
> heap_sort

Resultado

Conclusão

Neste artigo, vimos maneiras diferentes de classificar os dados usando R. Como vimos como o comando de classificação e ordem é usado para classificar um quadro de dados, outras limitações da função de classificação sobre a função de ordem foram mostradas no artigo. Uma explicação detalhada de diferentes algoritmos de classificação, como classificação por bolha, classificação e seleção por mesclagem, foi discutida minuciosamente. A classificação sendo uma das etapas mais importantes da análise de dados, possui funções diferentes para várias necessidades. É de inteira responsabilidade do engenheiro de dados escolher o método mais apropriado para a classificação com base nos dados disponíveis.

Artigos recomendados

Este foi um guia para Classificar em R. Aqui discutimos o que é classificação em R, recursos e tipos de classificação em R. Você também pode consultar nossos outros artigos sugeridos para saber mais -

1. Idiomas de ciência de dados
2. Banco de dados em SQL
3. Tipos de dados em C
4. Tipos de dados PostgreSQL
5. Introdução à classificação no Tableau
6. Inserção Ordenar em JavaScript
7. Guia completo para classificação em c # com exemplos
8. Função de classificação em Python com exemplos