R - Guia Rápido

R é uma linguagem de programação e ambiente de software para análise estatística, representação gráfica e relatórios. R foi criado por Ross Ihaka e Robert Gentleman na University of Auckland, Nova Zelândia, e atualmente é desenvolvido pela R Development Core Team.

O núcleo de R é uma linguagem de computador interpretada que permite ramificação e loop, bem como programação modular usando funções. R permite a integração com os procedimentos escritos nas linguagens C, C ++, .Net, Python ou FORTRAN para maior eficiência.

R está disponível gratuitamente sob a GNU General Public License, e versões binárias pré-compiladas são fornecidas para vários sistemas operacionais como Linux, Windows e Mac.

R é um software livre distribuído sob uma cópia deixada no estilo GNU, e uma parte oficial do projeto GNU chamada GNU S.

Evolução de R

R foi inicialmente escrito por Ross Ihaka e Robert Gentlemanno Departamento de Estatística da Universidade de Auckland em Auckland, Nova Zelândia. R fez sua primeira aparição em 1993.

  • Um grande grupo de pessoas contribuiu para o R enviando códigos e relatórios de erros.

  • Desde meados de 1997, existe um grupo principal (o "R Core Team") que pode modificar o arquivo de código-fonte do R.

Características de R

Conforme afirmado anteriormente, R é uma linguagem de programação e ambiente de software para análise estatística, representação gráfica e relatórios. A seguir estão as características importantes do R -

  • R é uma linguagem de programação bem desenvolvida, simples e eficaz que inclui condicionais, loops, funções recursivas definidas pelo usuário e recursos de entrada e saída.

  • R tem uma facilidade de manuseio e armazenamento de dados eficaz

  • R fornece um conjunto de operadores para cálculos em matrizes, listas, vetores e matrizes.

  • R fornece uma coleção grande, coerente e integrada de ferramentas para análise de dados.

  • R fornece recursos gráficos para análise e exibição de dados diretamente no computador ou impressão nos jornais.

Como conclusão, R é a linguagem de programação de estatísticas mais amplamente usada no mundo. É a escolha número 1 de cientistas de dados e é apoiado por uma comunidade vibrante e talentosa de colaboradores. R é ensinado em universidades e implantado em aplicativos de negócios de missão crítica. Este tutorial irá ensinar a programação R junto com exemplos adequados em etapas simples e fáceis.

Configuração de ambiente local

Se você ainda deseja configurar seu ambiente para R, siga as etapas abaixo.

Instalação Windows

Você pode baixar a versão do instalador do Windows de R de R-3.2.2 para Windows (32/64 bits) e salvá-lo em um diretório local.

Por se tratar de um instalador do Windows (.exe) com o nome "R-version-win.exe". Você pode apenas clicar duas vezes e executar o instalador aceitando as configurações padrão. Se o seu Windows for de 32 bits, ele instala a versão de 32 bits. Mas se o seu Windows for de 64 bits, ele instala as versões de 32 e 64 bits.

Após a instalação, você pode localizar o ícone para executar o Programa em uma estrutura de diretório "R \ R3.2.2 \ bin \ i386 \ Rgui.exe" nos Arquivos de Programas do Windows. Clicar neste ícone exibe o R-GUI que é o console R para fazer a programação R.

Instalação Linux

R está disponível como um binário para muitas versões do Linux no local R Binaries .

A instrução para instalar o Linux varia de um tipo para outro. Essas etapas são mencionadas em cada tipo de versão do Linux no link mencionado. No entanto, se você estiver com pressa, pode usaryum comando para instalar o R ​​da seguinte forma -

$ yum install R

O comando acima instalará a funcionalidade principal da programação R junto com os pacotes padrão, mas você ainda precisa de um pacote adicional, então você pode iniciar o prompt R da seguinte maneira -

$ R
R version 3.2.0 (2015-04-16) -- "Full of  Ingredients"          
Copyright (C) 2015 The R Foundation for Statistical Computing
Platform: x86_64-redhat-linux-gnu (64-bit)

R is free software and comes with ABSOLUTELY NO WARRANTY.
You are welcome to redistribute it under certain conditions.
Type 'license()' or 'licence()' for distribution details.

R is a collaborative project with many  contributors.                    
Type 'contributors()' for more information and
'citation()' on how to cite R or R packages in publications.

Type 'demo()' for some demos, 'help()' for on-line help, or
'help.start()' for an HTML browser interface to help.
Type 'q()' to quit R.
>

Agora você pode usar o comando install no prompt R para instalar o pacote necessário. Por exemplo, o seguinte comando irá instalarplotrix pacote que é necessário para gráficos 3D.

> install.packages("plotrix")

Como convenção, começaremos a aprender programação R escrevendo um "Hello, World!" programa. Dependendo das necessidades, você pode programar no prompt de comando R ou pode usar um arquivo de script R para escrever seu programa. Vamos verificar um por um.

Prompt de Comando R

Depois de configurar o ambiente R, é fácil iniciar o prompt de comando R apenas digitando o seguinte comando no prompt de comando -

$ R

Isso iniciará o interpretador R e você receberá um prompt> onde você pode começar a digitar seu programa da seguinte maneira -

> myString <- "Hello, World!"
> print ( myString)
[1] "Hello, World!"

Aqui, a primeira instrução define uma variável de string myString, onde atribuímos uma string "Hello, World!" e a próxima instrução print () está sendo usada para imprimir o valor armazenado na variável myString.

Arquivo de script R

Normalmente, você fará sua programação escrevendo seus programas em arquivos de script e, em seguida, executará esses scripts em seu prompt de comando com a ajuda de um interpretador R chamado Rscript. Então, vamos começar escrevendo o seguinte código em um arquivo de texto chamado test.R como em -

# My first program in R Programming
myString <- "Hello, World!"

print ( myString)

Salve o código acima em um arquivo test.R e execute-o no prompt de comando do Linux conforme mostrado abaixo. Mesmo se você estiver usando o Windows ou outro sistema, a sintaxe permanecerá a mesma.

$ Rscript test.R

Quando executamos o programa acima, ele produz o seguinte resultado.

[1] "Hello, World!"

Comentários

Os comentários são como texto de ajuda em seu programa R e são ignorados pelo interpretador durante a execução de seu programa real. Um único comentário é escrito usando # no início da instrução da seguinte forma -

# My first program in R Programming

R não oferece suporte a comentários de várias linhas, mas você pode executar um truque que é o seguinte -

if(FALSE) {
   "This is a demo for multi-line comments and it should be put inside either a 
      single OR double quote"
}

myString <- "Hello, World!"
print ( myString)
[1] "Hello, World!"

Embora os comentários acima sejam executados pelo intérprete R, eles não interferirão no seu programa real. Você deve colocar esses comentários dentro, entre aspas simples ou duplas.

Geralmente, ao programar em qualquer linguagem de programação, você precisa usar várias variáveis ​​para armazenar várias informações. As variáveis ​​nada mais são do que locais de memória reservados para armazenar valores. Isso significa que, ao criar uma variável, você reserva algum espaço na memória.

Você pode gostar de armazenar informações de vários tipos de dados como caractere, caractere largo, inteiro, ponto flutuante, ponto flutuante duplo, Booleano etc. Com base no tipo de dados de uma variável, o sistema operacional aloca memória e decide o que pode ser armazenado no memória reservada.

Em contraste com outras linguagens de programação como C e java em R, as variáveis ​​não são declaradas como algum tipo de dados. As variáveis ​​são atribuídas com objetos R e o tipo de dados do objeto R torna-se o tipo de dados da variável. Existem muitos tipos de objetos-R. Os mais usados ​​são -

  • Vectors
  • Lists
  • Matrices
  • Arrays
  • Factors
  • Frames de dados

O mais simples desses objetos é o vector objecte existem seis tipos de dados desses vetores atômicos, também denominados como seis classes de vetores. Os outros objetos-R são construídos sobre os vetores atômicos.

Tipo de dados Exemplo Verificar
Lógico VERDADEIRO FALSO
v <- TRUE 
print(class(v))

produz o seguinte resultado -

[1] "logical"
Numérico 12,3, 5, 999
v <- 23.5
print(class(v))

produz o seguinte resultado -

[1] "numeric"
Inteiro 2L, 34L, 0L
v <- 2L
print(class(v))

produz o seguinte resultado -

[1] "integer"
Complexo 3 + 2i
v <- 2+5i
print(class(v))

produz o seguinte resultado -

[1] "complex"
Personagem 'a', '"bom", "VERDADEIRO", '23 .4'
v <- "TRUE"
print(class(v))

produz o seguinte resultado -

[1] "character"
Cru "Olá" é armazenado como 48 65 6c 6c 6f
v <- charToRaw("Hello")
print(class(v))

produz o seguinte resultado -

[1] "raw"

Na programação R, os tipos de dados mais básicos são os objetos R chamados vectorsque contém elementos de diferentes classes, conforme mostrado acima. Observe que em R o número de classes não se limita apenas aos seis tipos acima. Por exemplo, podemos usar muitos vetores atômicos e criar um array cuja classe se tornará array.

Vetores

Quando você deseja criar um vetor com mais de um elemento, você deve usar c() função que significa combinar os elementos em um vetor.

# Create a vector.
apple <- c('red','green',"yellow")
print(apple)

# Get the class of the vector.
print(class(apple))

Quando executamos o código acima, ele produz o seguinte resultado -

[1] "red"    "green"  "yellow"
[1] "character"

Listas

Uma lista é um objeto R que pode conter muitos tipos diferentes de elementos dentro dele, como vetores, funções e até mesmo outra lista dentro dele.

# Create a list.
list1 <- list(c(2,5,3),21.3,sin)

# Print the list.
print(list1)

Quando executamos o código acima, ele produz o seguinte resultado -

[[1]]
[1] 2 5 3

[[2]]
[1] 21.3

[[3]]
function (x)  .Primitive("sin")

Matrizes

Uma matriz é um conjunto de dados retangular bidimensional. Ele pode ser criado usando uma entrada vetorial para a função de matriz.

# Create a matrix.
M = matrix( c('a','a','b','c','b','a'), nrow = 2, ncol = 3, byrow = TRUE)
print(M)

Quando executamos o código acima, ele produz o seguinte resultado -

[,1] [,2] [,3]
[1,] "a"  "a"  "b" 
[2,] "c"  "b"  "a"

Arrays

Enquanto as matrizes estão confinadas a duas dimensões, os arrays podem ter qualquer número de dimensões. A função array tem um atributo dim que cria o número necessário de dimensões. No exemplo abaixo, criamos um array com dois elementos que são matrizes 3x3 cada.

# Create an array.
a <- array(c('green','yellow'),dim = c(3,3,2))
print(a)

Quando executamos o código acima, ele produz o seguinte resultado -

, , 1

     [,1]     [,2]     [,3]    
[1,] "green"  "yellow" "green" 
[2,] "yellow" "green"  "yellow"
[3,] "green"  "yellow" "green" 

, , 2

     [,1]     [,2]     [,3]    
[1,] "yellow" "green"  "yellow"
[2,] "green"  "yellow" "green" 
[3,] "yellow" "green"  "yellow"

Fatores

Fatores são os objetos r que são criados usando um vetor. Ele armazena o vetor junto com os valores distintos dos elementos no vetor como rótulos. Os rótulos são sempre caracteres, independentemente de serem numéricos, caracteres ou booleanos etc. no vetor de entrada. Eles são úteis na modelagem estatística.

Fatores são criados usando o factor()função. onlevels funções fornece a contagem de níveis.

# Create a vector.
apple_colors <- c('green','green','yellow','red','red','red','green')

# Create a factor object.
factor_apple <- factor(apple_colors)

# Print the factor.
print(factor_apple)
print(nlevels(factor_apple))

Quando executamos o código acima, ele produz o seguinte resultado -

[1] green  green  yellow red    red    red    green 
Levels: green red yellow
[1] 3

Frames de dados

Os quadros de dados são objetos de dados tabulares. Ao contrário de uma matriz no quadro de dados, cada coluna pode conter diferentes modos de dados. A primeira coluna pode ser numérica, enquanto a segunda coluna pode ser de caracteres e a terceira coluna pode ser lógica. É uma lista de vetores de igual comprimento.

Quadros de dados são criados usando o data.frame() função.

# Create the data frame.
BMI <- 	data.frame(
   gender = c("Male", "Male","Female"), 
   height = c(152, 171.5, 165), 
   weight = c(81,93, 78),
   Age = c(42,38,26)
)
print(BMI)

Quando executamos o código acima, ele produz o seguinte resultado -

gender height weight Age
1   Male  152.0     81  42
2   Male  171.5     93  38
3 Female  165.0     78  26

Uma variável nos fornece armazenamento nomeado que nossos programas podem manipular. Uma variável em R pode armazenar um vetor atômico, grupo de vetores atômicos ou uma combinação de muitos Robjects. Um nome de variável válido consiste em letras, números e pontos ou caracteres sublinhados. O nome da variável começa com uma letra ou o ponto não seguido por um número.

Nome variável Validade Razão
var_name2. válido Possui letras, números, ponto e sublinhado
var_name% Inválido Possui o caractere '%'. Somente ponto (.) E sublinhado são permitidos.
2var_name inválido Começa com um número

.var_name,

var.name

válido Pode começar com um ponto (.), Mas o ponto (.) Não deve ser seguido por um número.
.2var_name inválido O ponto inicial é seguido por um número que o torna inválido.
_var_name inválido Começa com _ que não é válido

Atribuição de Variável

As variáveis ​​podem receber valores atribuídos usando o operador left, right e igual a. Os valores das variáveis ​​podem ser impressos usandoprint() ou cat()função. ocat() função combina vários itens em uma saída de impressão contínua.

# Assignment using equal operator.
var.1 = c(0,1,2,3)           

# Assignment using leftward operator.
var.2 <- c("learn","R")   

# Assignment using rightward operator.   
c(TRUE,1) -> var.3           

print(var.1)
cat ("var.1 is ", var.1 ,"\n")
cat ("var.2 is ", var.2 ,"\n")
cat ("var.3 is ", var.3 ,"\n")

Quando executamos o código acima, ele produz o seguinte resultado -

[1] 0 1 2 3
var.1 is  0 1 2 3 
var.2 is  learn R 
var.3 is  1 1

Note- O vetor c (TRUE, 1) possui uma combinação de classes lógicas e numéricas. Portanto, a classe lógica é forçada a uma classe numérica, tornando TRUE como 1.

Tipo de dados de uma variável

Em R, uma variável em si não é declarada de nenhum tipo de dados, em vez disso, ela obtém o tipo de dados do objeto R atribuído a ela. Portanto, R é chamada de linguagem de tipo dinâmico, o que significa que podemos alterar o tipo de dados de uma variável da mesma variável repetidamente ao usá-la em um programa.

var_x <- "Hello"
cat("The class of var_x is ",class(var_x),"\n")

var_x <- 34.5
cat("  Now the class of var_x is ",class(var_x),"\n")

var_x <- 27L
cat("   Next the class of var_x becomes ",class(var_x),"\n")

Quando executamos o código acima, ele produz o seguinte resultado -

The class of var_x is  character 
   Now the class of var_x is  numeric 
      Next the class of var_x becomes  integer

Encontrando Variáveis

Para saber todas as variáveis ​​atualmente disponíveis na área de trabalho, usamos o ls()função. Além disso, a função ls () pode usar padrões para combinar os nomes das variáveis.

print(ls())

Quando executamos o código acima, ele produz o seguinte resultado -

[1] "my var"     "my_new_var" "my_var"     "var.1"      
[5] "var.2"      "var.3"      "var.name"   "var_name2."
[9] "var_x"      "varname"

Note - É uma saída de amostra dependendo de quais variáveis ​​são declaradas em seu ambiente.

A função ls () pode usar padrões para combinar os nomes das variáveis.

# List the variables starting with the pattern "var".
print(ls(pattern = "var"))

Quando executamos o código acima, ele produz o seguinte resultado -

[1] "my var"     "my_new_var" "my_var"     "var.1"      
[5] "var.2"      "var.3"      "var.name"   "var_name2."
[9] "var_x"      "varname"

As variáveis ​​começando com dot(.) estão ocultos, eles podem ser listados usando o argumento "all.names = TRUE" para a função ls ().

print(ls(all.name = TRUE))

Quando executamos o código acima, ele produz o seguinte resultado -

[1] ".cars"        ".Random.seed" ".var_name"    ".varname"     ".varname2"   
[6] "my var"       "my_new_var"   "my_var"       "var.1"        "var.2"        
[11]"var.3"        "var.name"     "var_name2."   "var_x"

Excluindo Variáveis

As variáveis ​​podem ser excluídas usando o rm()função. Abaixo, excluímos a variável var.3. Ao imprimir o valor do erro da variável é lançado.

rm(var.3)
print(var.3)

Quando executamos o código acima, ele produz o seguinte resultado -

[1] "var.3"
Error in print(var.3) : object 'var.3' not found

Todas as variáveis ​​podem ser excluídas usando o rm() e ls() funcionam juntos.

rm(list = ls())
print(ls())

Quando executamos o código acima, ele produz o seguinte resultado -

character(0)

Um operador é um símbolo que informa ao compilador para executar manipulações matemáticas ou lógicas específicas. A linguagem R é rica em operadores integrados e fornece os seguintes tipos de operadores.

Tipos de Operadores

Temos os seguintes tipos de operadores na programação R -

  • Operadores aritméticos
  • Operadores Relacionais
  • Operadores lógicos
  • Operadores de atribuição
  • Operadores diversos

Operadores aritméticos

A tabela a seguir mostra os operadores aritméticos suportados pela linguagem R. Os operadores atuam em cada elemento do vetor.

Operador Descrição Exemplo
+ Adiciona dois vetores
v <- c( 2,5.5,6)
t <- c(8, 3, 4)
print(v+t)

produz o seguinte resultado -

[1] 10.0  8.5  10.0
- Subtrai o segundo vetor do primeiro
v <- c( 2,5.5,6)
t <- c(8, 3, 4)
print(v-t)

produz o seguinte resultado -

[1] -6.0  2.5  2.0
* Multiplica os dois vetores
v <- c( 2,5.5,6)
t <- c(8, 3, 4)
print(v*t)

produz o seguinte resultado -

[1] 16.0 16.5 24.0
/ Divida o primeiro vetor com o segundo
v <- c( 2,5.5,6)
t <- c(8, 3, 4)
print(v/t)

Quando executamos o código acima, ele produz o seguinte resultado -

[1] 0.250000 1.833333 1.500000
%% Dê o restante do primeiro vetor com o segundo
v <- c( 2,5.5,6)
t <- c(8, 3, 4)
print(v%%t)

produz o seguinte resultado -

[1] 2.0 2.5 2.0
% /% O resultado da divisão do primeiro vetor com o segundo (quociente)
v <- c( 2,5.5,6)
t <- c(8, 3, 4)
print(v%/%t)

produz o seguinte resultado -

[1] 0 1 1
^ O primeiro vetor elevado ao expoente do segundo vetor
v <- c( 2,5.5,6)
t <- c(8, 3, 4)
print(v^t)

produz o seguinte resultado -

[1]  256.000  166.375 1296.000

Operadores Relacionais

A tabela a seguir mostra os operadores relacionais suportados pela linguagem R. Cada elemento do primeiro vetor é comparado com o elemento correspondente do segundo vetor. O resultado da comparação é um valor booleano.

Operador Descrição Exemplo
> Verifica se cada elemento do primeiro vetor é maior que o elemento correspondente do segundo vetor.
v <- c(2,5.5,6,9)
t <- c(8,2.5,14,9)
print(v>t)

produz o seguinte resultado -

[1] FALSE  TRUE FALSE FALSE
< Verifica se cada elemento do primeiro vetor é menor que o elemento correspondente do segundo vetor.
v <- c(2,5.5,6,9)
t <- c(8,2.5,14,9)
print(v < t)

produz o seguinte resultado -

[1]  TRUE FALSE  TRUE FALSE
== Verifica se cada elemento do primeiro vetor é igual ao elemento correspondente do segundo vetor.
v <- c(2,5.5,6,9)
t <- c(8,2.5,14,9)
print(v == t)

produz o seguinte resultado -

[1] FALSE FALSE FALSE  TRUE
<= Verifica se cada elemento do primeiro vetor é menor ou igual ao elemento correspondente do segundo vetor.
v <- c(2,5.5,6,9)
t <- c(8,2.5,14,9)
print(v<=t)

produz o seguinte resultado -

[1]  TRUE FALSE  TRUE  TRUE
> = Verifica se cada elemento do primeiro vetor é maior ou igual ao elemento correspondente do segundo vetor.
v <- c(2,5.5,6,9)
t <- c(8,2.5,14,9)
print(v>=t)

produz o seguinte resultado -

[1] FALSE  TRUE FALSE  TRUE
! = Verifica se cada elemento do primeiro vetor é diferente do elemento correspondente do segundo vetor.
v <- c(2,5.5,6,9)
t <- c(8,2.5,14,9)
print(v!=t)

produz o seguinte resultado -

[1]  TRUE  TRUE  TRUE FALSE

Operadores lógicos

A tabela a seguir mostra os operadores lógicos suportados pela linguagem R. É aplicável apenas a vetores do tipo lógico, numérico ou complexo. Todos os números maiores que 1 são considerados como valor lógico VERDADEIRO.

Cada elemento do primeiro vetor é comparado com o elemento correspondente do segundo vetor. O resultado da comparação é um valor booleano.

Operador Descrição Exemplo
E É chamado de operador E lógico elementar. Ele combina cada elemento do primeiro vetor com o elemento correspondente do segundo vetor e dá uma saída TRUE se ambos os elementos forem TRUE.
v <- c(3,1,TRUE,2+3i)
t <- c(4,1,FALSE,2+3i)
print(v&t)

produz o seguinte resultado -

[1]  TRUE  TRUE FALSE  TRUE
| É chamado de operador OR lógico elementar. Ele combina cada elemento do primeiro vetor com o elemento correspondente do segundo vetor e dá uma saída TRUE se um dos elementos for TRUE.
v <- c(3,0,TRUE,2+2i)
t <- c(4,0,FALSE,2+3i)
print(v|t)

produz o seguinte resultado -

[1]  TRUE FALSE  TRUE  TRUE
! É chamado de operador lógico NOT. Pega cada elemento do vetor e fornece o valor lógico oposto.
v <- c(3,0,TRUE,2+2i)
print(!v)

produz o seguinte resultado -

[1] FALSE  TRUE FALSE FALSE

O operador lógico && e || considera apenas o primeiro elemento dos vetores e fornece um vetor de elemento único como saída.

Operador Descrição Exemplo
&& Operador lógico chamado AND. Pega o primeiro elemento de ambos os vetores e dá o VERDADEIRO apenas se ambos forem VERDADEIROS.
v <- c(3,0,TRUE,2+2i)
t <- c(1,3,TRUE,2+3i)
print(v&&t)

produz o seguinte resultado -

[1] TRUE
|| Operador lógico chamado OR. Pega o primeiro elemento de ambos os vetores e dá TRUE se um deles for TRUE.
v <- c(0,0,TRUE,2+2i)
t <- c(0,3,TRUE,2+3i)
print(v||t)

produz o seguinte resultado -

[1] FALSE

Operadores de atribuição

Esses operadores são usados ​​para atribuir valores aos vetores.

Operador Descrição Exemplo

<-

ou

=

ou

<< -

Atribuição Chamada de Esquerda
v1 <- c(3,1,TRUE,2+3i)
v2 <<- c(3,1,TRUE,2+3i)
v3 = c(3,1,TRUE,2+3i)
print(v1)
print(v2)
print(v3)

produz o seguinte resultado -

[1] 3+0i 1+0i 1+0i 2+3i
[1] 3+0i 1+0i 1+0i 2+3i
[1] 3+0i 1+0i 1+0i 2+3i

->

ou

- >>

Atribuição Chamada de Direito
c(3,1,TRUE,2+3i) -> v1
c(3,1,TRUE,2+3i) ->> v2 
print(v1)
print(v2)

produz o seguinte resultado -

[1] 3+0i 1+0i 1+0i 2+3i
[1] 3+0i 1+0i 1+0i 2+3i

Operadores diversos

Esses operadores são usados ​​para fins específicos e não para cálculos matemáticos ou lógicos gerais.

Operador Descrição Exemplo
: Operador de cólon. Ele cria a série de números em sequência para um vetor.
v <- 2:8
print(v)

produz o seguinte resultado -

[1] 2 3 4 5 6 7 8
%dentro% Este operador é usado para identificar se um elemento pertence a um vetor.
v1 <- 8
v2 <- 12
t <- 1:10
print(v1 %in% t) 
print(v2 %in% t)

produz o seguinte resultado -

[1] TRUE
[1] FALSE
% *% Este operador é usado para multiplicar uma matriz com sua transposta.
M = matrix( c(2,6,5,1,10,4), nrow = 2,ncol = 3,byrow = TRUE)
t = M %*% t(M)
print(t)

produz o seguinte resultado -

[,1] [,2]
[1,]   65   82
[2,]   82  117

As estruturas de tomada de decisão requerem que o programador especifique uma ou mais condições a serem avaliadas ou testadas pelo programa, juntamente com uma instrução ou instruções a serem executadas se a condição for determinada como truee, opcionalmente, outras instruções a serem executadas se a condição for determinada como false.

A seguir está a forma geral de uma estrutura típica de tomada de decisão encontrada na maioria das linguagens de programação -

R fornece os seguintes tipos de declarações de tomada de decisão. Clique nos links a seguir para verificar seus detalhes.

Sr. Não. Declaração e descrição
1 declaração if

A if declaração consiste em uma expressão booleana seguida por uma ou mais declarações.

2 declaração if ... else

A if declaração pode ser seguida por um opcional else instrução, que é executada quando a expressão booleana é falsa.

3 declaração switch

UMA switch instrução permite que uma variável seja testada quanto à igualdade em relação a uma lista de valores.

Pode haver uma situação em que você precise executar um bloco de código várias vezes. Em geral, as instruções são executadas sequencialmente. A primeira instrução em uma função é executada primeiro, seguida pela segunda e assim por diante.

As linguagens de programação fornecem várias estruturas de controle que permitem caminhos de execução mais complicados.

Uma instrução de loop nos permite executar uma instrução ou grupo de instruções várias vezes e o seguinte é a forma geral de uma instrução de loop na maioria das linguagens de programação -

A linguagem de programação R fornece os seguintes tipos de loop para lidar com os requisitos de loop. Clique nos links a seguir para verificar seus detalhes.

Sr. Não. Tipo de Loop e Descrição
1 loop de repetição

Executa uma sequência de instruções várias vezes e abrevia o código que gerencia a variável de loop.

2 loop while

Repete uma declaração ou grupo de declarações enquanto uma determinada condição for verdadeira. Ele testa a condição antes de executar o corpo do loop.

3 para loop

Como uma instrução while, exceto que testa a condição no final do corpo do loop.

Declarações de controle de loop

As instruções de controle de loop alteram a execução de sua sequência normal. Quando a execução deixa um escopo, todos os objetos automáticos que foram criados nesse escopo são destruídos.

R suporta as seguintes instruções de controle. Clique nos links a seguir para verificar seus detalhes.

Sr. Não. Declaração de controle e descrição
1 declaração de quebra

Termina o loop instrução e transfere a execução para a instrução imediatamente após o loop.

2 Próxima declaração

o next declaração simula o comportamento de R switch.

Uma função é um conjunto de instruções organizadas em conjunto para realizar uma tarefa específica. R tem um grande número de funções embutidas e o usuário pode criar suas próprias funções.

Em R, uma função é um objeto para que o interpretador de R seja capaz de passar o controle para a função, junto com os argumentos que podem ser necessários para a função realizar as ações.

A função, por sua vez, executa sua tarefa e retorna o controle ao interpretador, bem como qualquer resultado que possa ser armazenado em outros objetos.

Definição de Função

Uma função R é criada usando a palavra-chave function. A sintaxe básica de uma definição de função R é a seguinte -

function_name <- function(arg_1, arg_2, ...) {
   Function body 
}

Componentes de Função

As diferentes partes de uma função são -

  • Function Name- Este é o nome real da função. Ele é armazenado no ambiente R como um objeto com este nome.

  • Arguments- Um argumento é um espaço reservado. Quando uma função é chamada, você passa um valor para o argumento. Os argumentos são opcionais; ou seja, uma função não pode conter argumentos. Além disso, os argumentos podem ter valores padrão.

  • Function Body - O corpo da função contém uma coleção de instruções que definem o que a função faz.

  • Return Value - O valor de retorno de uma função é a última expressão no corpo da função a ser avaliada.

R tem muitos in-builtfunções que podem ser chamadas diretamente no programa sem defini-las primeiro. Também podemos criar e usar nossas próprias funções, chamadas deuser defined funções.

Função Integrada

Exemplos simples de funções embutidas são seq(), mean(), max(), sum(x) e paste(...)etc. Eles são chamados diretamente por programas escritos pelo usuário. Você pode consultar as funções R mais utilizadas.

# Create a sequence of numbers from 32 to 44.
print(seq(32,44))

# Find mean of numbers from 25 to 82.
print(mean(25:82))

# Find sum of numbers frm 41 to 68.
print(sum(41:68))

Quando executamos o código acima, ele produz o seguinte resultado -

[1] 32 33 34 35 36 37 38 39 40 41 42 43 44
[1] 53.5
[1] 1526

Função definida pelo usuário

Podemos criar funções definidas pelo usuário em R. Elas são específicas para o que o usuário deseja e, uma vez criadas, podem ser usadas como as funções integradas. Abaixo está um exemplo de como uma função é criada e usada.

# Create a function to print squares of numbers in sequence.
new.function <- function(a) {
   for(i in 1:a) {
      b <- i^2
      print(b)
   }
}

Chamando uma função

# Create a function to print squares of numbers in sequence.
new.function <- function(a) {
   for(i in 1:a) {
      b <- i^2
      print(b)
   }
}

# Call the function new.function supplying 6 as an argument.
new.function(6)

Quando executamos o código acima, ele produz o seguinte resultado -

[1] 1
[1] 4
[1] 9
[1] 16
[1] 25
[1] 36

Chamando uma função sem um argumento

# Create a function without an argument.
new.function <- function() {
   for(i in 1:5) {
      print(i^2)
   }
}	

# Call the function without supplying an argument.
new.function()

Quando executamos o código acima, ele produz o seguinte resultado -

[1] 1
[1] 4
[1] 9
[1] 16
[1] 25

Chamando uma função com valores de argumento (por posição e por nome)

Os argumentos para uma chamada de função podem ser fornecidos na mesma sequência definida na função ou podem ser fornecidos em uma sequência diferente, mas atribuídos aos nomes dos argumentos.

# Create a function with arguments.
new.function <- function(a,b,c) {
   result <- a * b + c
   print(result)
}

# Call the function by position of arguments.
new.function(5,3,11)

# Call the function by names of the arguments.
new.function(a = 11, b = 5, c = 3)

Quando executamos o código acima, ele produz o seguinte resultado -

[1] 26
[1] 58

Chamando uma função com argumento padrão

Podemos definir o valor dos argumentos na definição da função e chamar a função sem fornecer nenhum argumento para obter o resultado padrão. Mas também podemos chamar essas funções fornecendo novos valores do argumento e obter um resultado não padrão.

# Create a function with arguments.
new.function <- function(a = 3, b = 6) {
   result <- a * b
   print(result)
}

# Call the function without giving any argument.
new.function()

# Call the function with giving new values of the argument.
new.function(9,5)

Quando executamos o código acima, ele produz o seguinte resultado -

[1] 18
[1] 45

Avaliação Preguiçosa da Função

Argumentos para funções são avaliados lentamente, o que significa que eles são avaliados apenas quando necessário para o corpo da função.

# Create a function with arguments.
new.function <- function(a, b) {
   print(a^2)
   print(a)
   print(b)
}

# Evaluate the function without supplying one of the arguments.
new.function(6)

Quando executamos o código acima, ele produz o seguinte resultado -

[1] 36
[1] 6
Error in print(b) : argument "b" is missing, with no default

Qualquer valor escrito em um par de aspas simples ou duplas em R é tratado como uma string. Internamente, R armazena cada string entre aspas duplas, mesmo quando você as cria com aspas simples.

Regras aplicadas na construção de strings

  • As aspas no início e no final de uma string devem ser aspas duplas ou aspas simples. Eles não podem ser misturados.

  • As aspas duplas podem ser inseridas em uma string começando e terminando com aspas simples.

  • As aspas simples podem ser inseridas em uma string começando e terminando com aspas duplas.

  • As aspas duplas não podem ser inseridas em uma string começando e terminando com aspas duplas.

  • As aspas simples não podem ser inseridas em uma string começando e terminando com aspas simples.

Exemplos de strings válidas

Os exemplos a seguir esclarecem as regras sobre a criação de uma string em R.

a <- 'Start and end with single quote'
print(a)

b <- "Start and end with double quotes"
print(b)

c <- "single quote ' in between double quotes"
print(c)

d <- 'Double quotes " in between single quote'
print(d)

Quando o código acima é executado, obtemos a seguinte saída -

[1] "Start and end with single quote"
[1] "Start and end with double quotes"
[1] "single quote ' in between double quote"
[1] "Double quote \" in between single quote"

Exemplos de strings inválidas

e <- 'Mixed quotes" 
print(e)

f <- 'Single quote ' inside single quote'
print(f)

g <- "Double quotes " inside double quotes"
print(g)

Quando executamos o script, ele falha dando os resultados abaixo.

Error: unexpected symbol in:
"print(e)
f <- 'Single"
Execution halted

Manipulação de Cordas

Concatenando Strings - função paste ()

Muitas strings em R são combinadas usando o paste()função. Pode levar qualquer número de argumentos para serem combinados.

Sintaxe

A sintaxe básica para a função colar é -

paste(..., sep = " ", collapse = NULL)

A seguir está a descrição dos parâmetros usados ​​-

  • ... representa qualquer número de argumentos a serem combinados.

  • seprepresenta qualquer separador entre os argumentos. Isso é opcional.

  • collapseé usado para eliminar o espaço entre duas strings. Mas não o espaço dentro de duas palavras de uma string.

Exemplo

a <- "Hello"
b <- 'How'
c <- "are you? "

print(paste(a,b,c))

print(paste(a,b,c, sep = "-"))

print(paste(a,b,c, sep = "", collapse = ""))

Quando executamos o código acima, ele produz o seguinte resultado -

[1] "Hello How are you? "
[1] "Hello-How-are you? "
[1] "HelloHoware you? "

Formatando números e strings - função format ()

Números e strings podem ser formatados para um estilo específico usando format() função.

Sintaxe

A sintaxe básica para a função de formato é -

format(x, digits, nsmall, scientific, width, justify = c("left", "right", "centre", "none"))

A seguir está a descrição dos parâmetros usados ​​-

  • x é a entrada do vetor.

  • digits é o número total de dígitos exibidos.

  • nsmall é o número mínimo de dígitos à direita da vírgula decimal.

  • scientific é definido como TRUE para exibir notação científica.

  • width indica a largura mínima a ser exibida preenchendo espaços em branco no início.

  • justify é a exibição da corda à esquerda, direita ou centro.

Exemplo

# Total number of digits displayed. Last digit rounded off.
result <- format(23.123456789, digits = 9)
print(result)

# Display numbers in scientific notation.
result <- format(c(6, 13.14521), scientific = TRUE)
print(result)

# The minimum number of digits to the right of the decimal point.
result <- format(23.47, nsmall = 5)
print(result)

# Format treats everything as a string.
result <- format(6)
print(result)

# Numbers are padded with blank in the beginning for width.
result <- format(13.7, width = 6)
print(result)

# Left justify strings.
result <- format("Hello", width = 8, justify = "l")
print(result)

# Justfy string with center.
result <- format("Hello", width = 8, justify = "c")
print(result)

Quando executamos o código acima, ele produz o seguinte resultado -

[1] "23.1234568"
[1] "6.000000e+00" "1.314521e+01"
[1] "23.47000"
[1] "6"
[1] "  13.7"
[1] "Hello   "
[1] " Hello  "

Contando o número de caracteres em uma string - função nchar ()

Esta função conta o número de caracteres, incluindo espaços em uma string.

Sintaxe

A sintaxe básica para a função nchar () é -

nchar(x)

A seguir está a descrição dos parâmetros usados ​​-

  • x é a entrada do vetor.

Exemplo

result <- nchar("Count the number of characters")
print(result)

Quando executamos o código acima, ele produz o seguinte resultado -

[1] 30

Alterando o caso - funções toupper () e tolower ()

Essas funções alteram a capitalização dos caracteres de uma string.

Sintaxe

A sintaxe básica para a função toupper () & tolower () é -

toupper(x)
tolower(x)

A seguir está a descrição dos parâmetros usados ​​-

  • x é a entrada do vetor.

Exemplo

# Changing to Upper case.
result <- toupper("Changing To Upper")
print(result)

# Changing to lower case.
result <- tolower("Changing To Lower")
print(result)

Quando executamos o código acima, ele produz o seguinte resultado -

[1] "CHANGING TO UPPER"
[1] "changing to lower"

Extraindo partes de uma função string - substring ()

Esta função extrai partes de uma String.

Sintaxe

A sintaxe básica para a função substring () é -

substring(x,first,last)

A seguir está a descrição dos parâmetros usados ​​-

  • x é a entrada do vetor de caracteres.

  • first é a posição do primeiro caractere a ser extraído.

  • last é a posição do último caractere a ser extraído.

Exemplo

# Extract characters from 5th to 7th position.
result <- substring("Extract", 5, 7)
print(result)

Quando executamos o código acima, ele produz o seguinte resultado -

[1] "act"

Vetores são os objetos de dados R mais básicos e existem seis tipos de vetores atômicos. Eles são lógicos, inteiros, duplos, complexos, de caráter e brutos.

Criação de Vetor

Vetor de elemento único

Mesmo quando você escreve apenas um valor em R, ele se torna um vetor de comprimento 1 e pertence a um dos tipos de vetor acima.

# Atomic vector of type character.
print("abc");

# Atomic vector of type double.
print(12.5)

# Atomic vector of type integer.
print(63L)

# Atomic vector of type logical.
print(TRUE)

# Atomic vector of type complex.
print(2+3i)

# Atomic vector of type raw.
print(charToRaw('hello'))

Quando executamos o código acima, ele produz o seguinte resultado -

[1] "abc"
[1] 12.5
[1] 63
[1] TRUE
[1] 2+3i
[1] 68 65 6c 6c 6f

Vetor de vários elementos

Using colon operator with numeric data

# Creating a sequence from 5 to 13.
v <- 5:13
print(v)

# Creating a sequence from 6.6 to 12.6.
v <- 6.6:12.6
print(v)

# If the final element specified does not belong to the sequence then it is discarded.
v <- 3.8:11.4
print(v)

Quando executamos o código acima, ele produz o seguinte resultado -

[1]  5  6  7  8  9 10 11 12 13
[1]  6.6  7.6  8.6  9.6 10.6 11.6 12.6
[1]  3.8  4.8  5.8  6.8  7.8  8.8  9.8 10.8

Using sequence (Seq.) operator

# Create vector with elements from 5 to 9 incrementing by 0.4.
print(seq(5, 9, by = 0.4))

Quando executamos o código acima, ele produz o seguinte resultado -

[1] 5.0 5.4 5.8 6.2 6.6 7.0 7.4 7.8 8.2 8.6 9.0

Using the c() function

Os valores que não são caracteres são forçados ao tipo de caractere se um dos elementos for um caractere.

# The logical and numeric values are converted to characters.
s <- c('apple','red',5,TRUE)
print(s)

Quando executamos o código acima, ele produz o seguinte resultado -

[1] "apple" "red"   "5"     "TRUE"

Acessando Elementos do Vetor

Os elementos de um vetor são acessados ​​por meio de indexação. o[ ] bracketssão usados ​​para indexação. A indexação começa com a posição 1. Dar um valor negativo no índice remove esse elemento do resultado.TRUE, FALSE ou 0 e 1 também pode ser usado para indexação.

# Accessing vector elements using position.
t <- c("Sun","Mon","Tue","Wed","Thurs","Fri","Sat")
u <- t[c(2,3,6)]
print(u)

# Accessing vector elements using logical indexing.
v <- t[c(TRUE,FALSE,FALSE,FALSE,FALSE,TRUE,FALSE)]
print(v)

# Accessing vector elements using negative indexing.
x <- t[c(-2,-5)]
print(x)

# Accessing vector elements using 0/1 indexing.
y <- t[c(0,0,0,0,0,0,1)]
print(y)

Quando executamos o código acima, ele produz o seguinte resultado -

[1] "Mon" "Tue" "Fri"
[1] "Sun" "Fri"
[1] "Sun" "Tue" "Wed" "Fri" "Sat"
[1] "Sun"

Manipulação de Vetor

Aritmética vetorial

Dois vetores de mesmo comprimento podem ser adicionados, subtraídos, multiplicados ou divididos, dando o resultado como uma saída de vetor.

# Create two vectors.
v1 <- c(3,8,4,5,0,11)
v2 <- c(4,11,0,8,1,2)

# Vector addition.
add.result <- v1+v2
print(add.result)

# Vector subtraction.
sub.result <- v1-v2
print(sub.result)

# Vector multiplication.
multi.result <- v1*v2
print(multi.result)

# Vector division.
divi.result <- v1/v2
print(divi.result)

Quando executamos o código acima, ele produz o seguinte resultado -

[1]  7 19  4 13  1 13
[1] -1 -3  4 -3 -1  9
[1] 12 88  0 40  0 22
[1] 0.7500000 0.7272727       Inf 0.6250000 0.0000000 5.5000000

Reciclagem de elemento vetorial

Se aplicarmos operações aritméticas a dois vetores de comprimento desigual, os elementos do vetor mais curto serão reciclados para completar as operações.

v1 <- c(3,8,4,5,0,11)
v2 <- c(4,11)
# V2 becomes c(4,11,4,11,4,11)

add.result <- v1+v2
print(add.result)

sub.result <- v1-v2
print(sub.result)

Quando executamos o código acima, ele produz o seguinte resultado -

[1]  7 19  8 16  4 22
[1] -1 -3  0 -6 -4  0

Classificação de elemento vetorial

Os elementos em um vetor podem ser classificados usando o sort() função.

v <- c(3,8,4,5,0,11, -9, 304)

# Sort the elements of the vector.
sort.result <- sort(v)
print(sort.result)

# Sort the elements in the reverse order.
revsort.result <- sort(v, decreasing = TRUE)
print(revsort.result)

# Sorting character vectors.
v <- c("Red","Blue","yellow","violet")
sort.result <- sort(v)
print(sort.result)

# Sorting character vectors in reverse order.
revsort.result <- sort(v, decreasing = TRUE)
print(revsort.result)

Quando executamos o código acima, ele produz o seguinte resultado -

[1]  -9   0   3   4   5   8  11 304
[1] 304  11   8   5   4   3   0  -9
[1] "Blue"   "Red"    "violet" "yellow"
[1] "yellow" "violet" "Red"    "Blue"

Listas são os objetos R que contêm elementos de diferentes tipos como - números, strings, vetores e outra lista dentro deles. Uma lista também pode conter uma matriz ou uma função como seus elementos. A lista é criada usandolist() função.

Criação de uma lista

A seguir está um exemplo para criar uma lista contendo strings, números, vetores e valores lógicos.

# Create a list containing strings, numbers, vectors and a logical
# values.
list_data <- list("Red", "Green", c(21,32,11), TRUE, 51.23, 119.1)
print(list_data)

Quando executamos o código acima, ele produz o seguinte resultado -

[[1]]
[1] "Red"

[[2]]
[1] "Green"

[[3]]
[1] 21 32 11

[[4]]
[1] TRUE

[[5]]
[1] 51.23

[[6]]
[1] 119.1

Elementos da lista de nomes

Os elementos da lista podem receber nomes e eles podem ser acessados ​​usando esses nomes.

# Create a list containing a vector, a matrix and a list.
list_data <- list(c("Jan","Feb","Mar"), matrix(c(3,9,5,1,-2,8), nrow = 2),
   list("green",12.3))

# Give names to the elements in the list.
names(list_data) <- c("1st Quarter", "A_Matrix", "A Inner list")

# Show the list.
print(list_data)

Quando executamos o código acima, ele produz o seguinte resultado -

$`1st_Quarter` [1] "Jan" "Feb" "Mar" $A_Matrix
     [,1] [,2] [,3]
[1,]    3    5   -2
[2,]    9    1    8

$A_Inner_list $A_Inner_list[[1]]
[1] "green"

$A_Inner_list[[2]]
[1] 12.3

Acessando Elementos da Lista

Os elementos da lista podem ser acessados ​​pelo índice do elemento na lista. No caso de listas nomeadas, também pode ser acessado usando os nomes.

Continuamos a usar a lista no exemplo acima -

# Create a list containing a vector, a matrix and a list.
list_data <- list(c("Jan","Feb","Mar"), matrix(c(3,9,5,1,-2,8), nrow = 2),
   list("green",12.3))

# Give names to the elements in the list.
names(list_data) <- c("1st Quarter", "A_Matrix", "A Inner list")

# Access the first element of the list.
print(list_data[1])

# Access the thrid element. As it is also a list, all its elements will be printed.
print(list_data[3])

# Access the list element using the name of the element.
print(list_data$A_Matrix)

Quando executamos o código acima, ele produz o seguinte resultado -

$`1st_Quarter` [1] "Jan" "Feb" "Mar" $A_Inner_list
$A_Inner_list[[1]] [1] "green" $A_Inner_list[[2]]
[1] 12.3

     [,1] [,2] [,3]
[1,]    3    5   -2
[2,]    9    1    8

Manipulando Elementos de Lista

Podemos adicionar, excluir e atualizar os elementos da lista conforme mostrado abaixo. Podemos adicionar e excluir elementos apenas no final de uma lista. Mas podemos atualizar qualquer elemento.

# Create a list containing a vector, a matrix and a list.
list_data <- list(c("Jan","Feb","Mar"), matrix(c(3,9,5,1,-2,8), nrow = 2),
   list("green",12.3))

# Give names to the elements in the list.
names(list_data) <- c("1st Quarter", "A_Matrix", "A Inner list")

# Add element at the end of the list.
list_data[4] <- "New element"
print(list_data[4])

# Remove the last element.
list_data[4] <- NULL

# Print the 4th Element.
print(list_data[4])

# Update the 3rd Element.
list_data[3] <- "updated element"
print(list_data[3])

Quando executamos o código acima, ele produz o seguinte resultado -

[[1]]
[1] "New element"

$<NA> NULL $`A Inner list`
[1] "updated element"

Mesclando Listas

Você pode mesclar muitas listas em uma lista, colocando todas as listas dentro de uma função list ().

# Create two lists.
list1 <- list(1,2,3)
list2 <- list("Sun","Mon","Tue")

# Merge the two lists.
merged.list <- c(list1,list2)

# Print the merged list.
print(merged.list)

Quando executamos o código acima, ele produz o seguinte resultado -

[[1]]
[1] 1

[[2]]
[1] 2

[[3]]
[1] 3

[[4]]
[1] "Sun"

[[5]]
[1] "Mon"

[[6]]
[1] "Tue"

Convertendo lista em vetor

Uma lista pode ser convertida em um vetor para que os elementos do vetor possam ser usados ​​para manipulação posterior. Todas as operações aritméticas em vetores podem ser aplicadas após a lista ser convertida em vetores. Para fazer essa conversão, usamos ounlist()função. Ele pega a lista como entrada e produz um vetor.

# Create lists.
list1 <- list(1:5)
print(list1)

list2 <-list(10:14)
print(list2)

# Convert the lists to vectors.
v1 <- unlist(list1)
v2 <- unlist(list2)

print(v1)
print(v2)

# Now add the vectors
result <- v1+v2
print(result)

Quando executamos o código acima, ele produz o seguinte resultado -

[[1]]
[1] 1 2 3 4 5

[[1]]
[1] 10 11 12 13 14

[1] 1 2 3 4 5
[1] 10 11 12 13 14
[1] 11 13 15 17 19

Matrizes são os objetos R nos quais os elementos são organizados em um layout retangular bidimensional. Eles contêm elementos dos mesmos tipos atômicos. Embora possamos criar uma matriz contendo apenas caracteres ou apenas valores lógicos, eles não têm muita utilidade. Usamos matrizes contendo elementos numéricos para serem usadas em cálculos matemáticos.

Uma matriz é criada usando o matrix() função.

Sintaxe

A sintaxe básica para criar uma matriz em R é -

matrix(data, nrow, ncol, byrow, dimnames)

A seguir está a descrição dos parâmetros usados ​​-

  • data é o vetor de entrada que se torna os elementos de dados da matriz.

  • nrow é o número de linhas a serem criadas.

  • ncol é o número de colunas a serem criadas.

  • byrowé uma pista lógica. Se TRUE, os elementos do vetor de entrada são organizados por linha.

  • dimname são os nomes atribuídos às linhas e colunas.

Exemplo

Crie uma matriz tendo um vetor de números como entrada.

# Elements are arranged sequentially by row.
M <- matrix(c(3:14), nrow = 4, byrow = TRUE)
print(M)

# Elements are arranged sequentially by column.
N <- matrix(c(3:14), nrow = 4, byrow = FALSE)
print(N)

# Define the column and row names.
rownames = c("row1", "row2", "row3", "row4")
colnames = c("col1", "col2", "col3")

P <- matrix(c(3:14), nrow = 4, byrow = TRUE, dimnames = list(rownames, colnames))
print(P)

Quando executamos o código acima, ele produz o seguinte resultado -

[,1] [,2] [,3]
[1,]    3    4    5
[2,]    6    7    8
[3,]    9   10   11
[4,]   12   13   14
     [,1] [,2] [,3]
[1,]    3    7   11
[2,]    4    8   12
[3,]    5    9   13
[4,]    6   10   14
     col1 col2 col3
row1    3    4    5
row2    6    7    8
row3    9   10   11
row4   12   13   14

Acessando Elementos de uma Matriz

Os elementos de uma matriz podem ser acessados ​​usando o índice de coluna e linha do elemento. Consideramos a matriz P acima para encontrar os elementos específicos abaixo.

# Define the column and row names.
rownames = c("row1", "row2", "row3", "row4")
colnames = c("col1", "col2", "col3")

# Create the matrix.
P <- matrix(c(3:14), nrow = 4, byrow = TRUE, dimnames = list(rownames, colnames))

# Access the element at 3rd column and 1st row.
print(P[1,3])

# Access the element at 2nd column and 4th row.
print(P[4,2])

# Access only the  2nd row.
print(P[2,])

# Access only the 3rd column.
print(P[,3])

Quando executamos o código acima, ele produz o seguinte resultado -

[1] 5
[1] 13
col1 col2 col3 
   6    7    8 
row1 row2 row3 row4 
   5    8   11   14

Computações Matrix

Várias operações matemáticas são realizadas nas matrizes usando os operadores R. O resultado da operação também é uma matriz.

As dimensões (número de linhas e colunas) devem ser as mesmas para as matrizes envolvidas na operação.

Adição e subtração de matriz

# Create two 2x3 matrices.
matrix1 <- matrix(c(3, 9, -1, 4, 2, 6), nrow = 2)
print(matrix1)

matrix2 <- matrix(c(5, 2, 0, 9, 3, 4), nrow = 2)
print(matrix2)

# Add the matrices.
result <- matrix1 + matrix2
cat("Result of addition","\n")
print(result)

# Subtract the matrices
result <- matrix1 - matrix2
cat("Result of subtraction","\n")
print(result)

Quando executamos o código acima, ele produz o seguinte resultado -

[,1] [,2] [,3]
[1,]    3   -1    2
[2,]    9    4    6
     [,1] [,2] [,3]
[1,]    5    0    3
[2,]    2    9    4
Result of addition 
     [,1] [,2] [,3]
[1,]    8   -1    5
[2,]   11   13   10
Result of subtraction 
     [,1] [,2] [,3]
[1,]   -2   -1   -1
[2,]    7   -5    2

Multiplicação e divisão de matriz

# Create two 2x3 matrices.
matrix1 <- matrix(c(3, 9, -1, 4, 2, 6), nrow = 2)
print(matrix1)

matrix2 <- matrix(c(5, 2, 0, 9, 3, 4), nrow = 2)
print(matrix2)

# Multiply the matrices.
result <- matrix1 * matrix2
cat("Result of multiplication","\n")
print(result)

# Divide the matrices
result <- matrix1 / matrix2
cat("Result of division","\n")
print(result)

Quando executamos o código acima, ele produz o seguinte resultado -

[,1] [,2] [,3]
[1,]    3   -1    2
[2,]    9    4    6
     [,1] [,2] [,3]
[1,]    5    0    3
[2,]    2    9    4
Result of multiplication 
     [,1] [,2] [,3]
[1,]   15    0    6
[2,]   18   36   24
Result of division 
     [,1]      [,2]      [,3]
[1,]  0.6      -Inf 0.6666667
[2,]  4.5 0.4444444 1.5000000

Arrays são objetos de dados R que podem armazenar dados em mais de duas dimensões. Por exemplo - Se criarmos uma matriz de dimensão (2, 3, 4), então ele cria 4 matrizes retangulares, cada uma com 2 linhas e 3 colunas. Os arrays podem armazenar apenas o tipo de dados.

Uma matriz é criada usando o array()função. Ele pega vetores como entrada e usa os valores nodim parâmetro para criar uma matriz.

Exemplo

O exemplo a seguir cria uma matriz de duas matrizes 3x3, cada uma com 3 linhas e 3 colunas.

# Create two vectors of different lengths.
vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)

# Take these vectors as input to the array.
result <- array(c(vector1,vector2),dim = c(3,3,2))
print(result)

Quando executamos o código acima, ele produz o seguinte resultado -

, , 1

     [,1] [,2] [,3]
[1,]    5   10   13
[2,]    9   11   14
[3,]    3   12   15

, , 2

     [,1] [,2] [,3]
[1,]    5   10   13
[2,]    9   11   14
[3,]    3   12   15

Nomeando colunas e linhas

Podemos dar nomes às linhas, colunas e matrizes da matriz usando o dimnames parâmetro.

# Create two vectors of different lengths.
vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)
column.names <- c("COL1","COL2","COL3")
row.names <- c("ROW1","ROW2","ROW3")
matrix.names <- c("Matrix1","Matrix2")

# Take these vectors as input to the array.
result <- array(c(vector1,vector2),dim = c(3,3,2),dimnames = list(row.names,column.names,
   matrix.names))
print(result)

Quando executamos o código acima, ele produz o seguinte resultado -

, , Matrix1

     COL1 COL2 COL3
ROW1    5   10   13
ROW2    9   11   14
ROW3    3   12   15

, , Matrix2

     COL1 COL2 COL3
ROW1    5   10   13
ROW2    9   11   14
ROW3    3   12   15

Acessando Elementos de Matriz

# Create two vectors of different lengths.
vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)
column.names <- c("COL1","COL2","COL3")
row.names <- c("ROW1","ROW2","ROW3")
matrix.names <- c("Matrix1","Matrix2")

# Take these vectors as input to the array.
result <- array(c(vector1,vector2),dim = c(3,3,2),dimnames = list(row.names,
   column.names, matrix.names))

# Print the third row of the second matrix of the array.
print(result[3,,2])

# Print the element in the 1st row and 3rd column of the 1st matrix.
print(result[1,3,1])

# Print the 2nd Matrix.
print(result[,,2])

Quando executamos o código acima, ele produz o seguinte resultado -

COL1 COL2 COL3 
   3   12   15 
[1] 13
     COL1 COL2 COL3
ROW1    5   10   13
ROW2    9   11   14
ROW3    3   12   15

Manipulando Elementos de Matriz

Como a matriz é composta por matrizes em múltiplas dimensões, as operações nos elementos da matriz são realizadas acessando os elementos das matrizes.

# Create two vectors of different lengths.
vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)

# Take these vectors as input to the array.
array1 <- array(c(vector1,vector2),dim = c(3,3,2))

# Create two vectors of different lengths.
vector3 <- c(9,1,0)
vector4 <- c(6,0,11,3,14,1,2,6,9)
array2 <- array(c(vector1,vector2),dim = c(3,3,2))

# create matrices from these arrays.
matrix1 <- array1[,,2]
matrix2 <- array2[,,2]

# Add the matrices.
result <- matrix1+matrix2
print(result)

Quando executamos o código acima, ele produz o seguinte resultado -

[,1] [,2] [,3]
[1,]   10   20   26
[2,]   18   22   28
[3,]    6   24   30

Cálculos entre os elementos da matriz

Podemos fazer cálculos entre os elementos em uma matriz usando o apply() função.

Sintaxe

apply(x, margin, fun)

A seguir está a descrição dos parâmetros usados ​​-

  • x é uma matriz.

  • margin é o nome do conjunto de dados usado.

  • fun é a função a ser aplicada aos elementos da matriz.

Exemplo

Usamos a função apply () abaixo para calcular a soma dos elementos nas linhas de uma matriz em todas as matrizes.

# Create two vectors of different lengths.
vector1 <- c(5,9,3)
vector2 <- c(10,11,12,13,14,15)

# Take these vectors as input to the array.
new.array <- array(c(vector1,vector2),dim = c(3,3,2))
print(new.array)

# Use apply to calculate the sum of the rows across all the matrices.
result <- apply(new.array, c(1), sum)
print(result)

Quando executamos o código acima, ele produz o seguinte resultado -

, , 1

     [,1] [,2] [,3]
[1,]    5   10   13
[2,]    9   11   14
[3,]    3   12   15

, , 2

     [,1] [,2] [,3]
[1,]    5   10   13
[2,]    9   11   14
[3,]    3   12   15

[1] 56 68 60

Fatores são os objetos de dados usados ​​para categorizar os dados e armazená-los como níveis. Eles podem armazenar strings e inteiros. Eles são úteis nas colunas que possuem um número limitado de valores únicos. Como "Masculino," Feminino "e Verdadeiro, Falso etc. Eles são úteis na análise de dados para modelagem estatística.

Fatores são criados usando o factor () função tomando um vetor como entrada.

Exemplo

# Create a vector as input.
data <- c("East","West","East","North","North","East","West","West","West","East","North")

print(data)
print(is.factor(data))

# Apply the factor function.
factor_data <- factor(data)

print(factor_data)
print(is.factor(factor_data))

Quando executamos o código acima, ele produz o seguinte resultado -

[1] "East"  "West"  "East"  "North" "North" "East"  "West"  "West"  "West"  "East" "North"
[1] FALSE
[1] East  West  East  North North East  West  West  West  East  North
Levels: East North West
[1] TRUE

Fatores no quadro de dados

Ao criar qualquer quadro de dados com uma coluna de dados de texto, R trata a coluna de texto como dados categóricos e cria fatores sobre ela.

# Create the vectors for data frame.
height <- c(132,151,162,139,166,147,122)
weight <- c(48,49,66,53,67,52,40)
gender <- c("male","male","female","female","male","female","male")

# Create the data frame.
input_data <- data.frame(height,weight,gender)
print(input_data)

# Test if the gender column is a factor.
print(is.factor(input_data$gender)) # Print the gender column so see the levels. print(input_data$gender)

Quando executamos o código acima, ele produz o seguinte resultado -

height weight gender
1    132     48   male
2    151     49   male
3    162     66 female
4    139     53 female
5    166     67   male
6    147     52 female
7    122     40   male
[1] TRUE
[1] male   male   female female male   female male  
Levels: female male

Mudando a ordem dos níveis

A ordem dos níveis em um fator pode ser alterada aplicando a função de fator novamente com a nova ordem dos níveis.

data <- c("East","West","East","North","North","East","West",
   "West","West","East","North")
# Create the factors
factor_data <- factor(data)
print(factor_data)

# Apply the factor function with required order of the level.
new_order_data <- factor(factor_data,levels = c("East","West","North"))
print(new_order_data)

Quando executamos o código acima, ele produz o seguinte resultado -

[1] East  West  East  North North East  West  West  West  East  North
Levels: East North West
 [1] East  West  East  North North East  West  West  West  East  North
Levels: East West North

Níveis de fator de geração

Podemos gerar níveis de fator usando o gl()função. Leva dois inteiros como entrada que indicam quantos níveis e quantas vezes cada nível.

Sintaxe

gl(n, k, labels)

A seguir está a descrição dos parâmetros usados ​​-

  • n é um número inteiro que fornece o número de níveis.

  • k é um número inteiro que fornece o número de replicações.

  • labels é um vetor de rótulos para os níveis de fator resultantes.

Exemplo

v <- gl(3, 4, labels = c("Tampa", "Seattle","Boston"))
print(v)

Quando executamos o código acima, ele produz o seguinte resultado -

Tampa   Tampa   Tampa   Tampa   Seattle Seattle Seattle Seattle Boston 
[10] Boston  Boston  Boston 
Levels: Tampa Seattle Boston

Um quadro de dados é uma tabela ou uma estrutura semelhante a uma matriz bidimensional em que cada coluna contém valores de uma variável e cada linha contém um conjunto de valores de cada coluna.

A seguir estão as características de um quadro de dados.

  • Os nomes das colunas não devem estar vazios.
  • Os nomes das linhas devem ser exclusivos.
  • Os dados armazenados em um quadro de dados podem ser numéricos, fator ou tipo de caractere.
  • Cada coluna deve conter o mesmo número de itens de dados.

Criar quadro de dados

# Create the data frame.
emp.data <- data.frame(
   emp_id = c (1:5), 
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25), 
   
   start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
      "2015-03-27")),
   stringsAsFactors = FALSE
)
# Print the data frame.			
print(emp.data)

Quando executamos o código acima, ele produz o seguinte resultado -

emp_id    emp_name     salary     start_date
1     1     Rick        623.30     2012-01-01
2     2     Dan         515.20     2013-09-23
3     3     Michelle    611.00     2014-11-15
4     4     Ryan        729.00     2014-05-11
5     5     Gary        843.25     2015-03-27

Obtenha a estrutura do quadro de dados

A estrutura do quadro de dados pode ser vista usando str() função.

# Create the data frame.
emp.data <- data.frame(
   emp_id = c (1:5), 
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25), 
   
   start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
      "2015-03-27")),
   stringsAsFactors = FALSE
)
# Get the structure of the data frame.
str(emp.data)

Quando executamos o código acima, ele produz o seguinte resultado -

'data.frame':   5 obs. of  4 variables:
 $ emp_id : int 1 2 3 4 5 $ emp_name  : chr  "Rick" "Dan" "Michelle" "Ryan" ...
 $ salary : num 623 515 611 729 843 $ start_date: Date, format: "2012-01-01" "2013-09-23" "2014-11-15" "2014-05-11" ...

Resumo dos dados no quadro de dados

O resumo estatístico e a natureza dos dados podem ser obtidos aplicando summary() função.

# Create the data frame.
emp.data <- data.frame(
   emp_id = c (1:5), 
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25), 
   
   start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
      "2015-03-27")),
   stringsAsFactors = FALSE
)
# Print the summary.
print(summary(emp.data))

Quando executamos o código acima, ele produz o seguinte resultado -

emp_id    emp_name             salary        start_date        
 Min.   :1   Length:5           Min.   :515.2   Min.   :2012-01-01  
 1st Qu.:2   Class :character   1st Qu.:611.0   1st Qu.:2013-09-23  
 Median :3   Mode  :character   Median :623.3   Median :2014-05-11  
 Mean   :3                      Mean   :664.4   Mean   :2014-01-14  
 3rd Qu.:4                      3rd Qu.:729.0   3rd Qu.:2014-11-15  
 Max.   :5                      Max.   :843.2   Max.   :2015-03-27

Extraia dados do quadro de dados

Extraia uma coluna específica de um quadro de dados usando o nome da coluna.

# Create the data frame.
emp.data <- data.frame(
   emp_id = c (1:5),
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25),
   
   start_date = as.Date(c("2012-01-01","2013-09-23","2014-11-15","2014-05-11",
      "2015-03-27")),
   stringsAsFactors = FALSE
)
# Extract Specific columns.
result <- data.frame(emp.data$emp_name,emp.data$salary)
print(result)

Quando executamos o código acima, ele produz o seguinte resultado -

emp.data.emp_name emp.data.salary
1              Rick          623.30
2               Dan          515.20
3          Michelle          611.00
4              Ryan          729.00
5              Gary          843.25

Extraia as duas primeiras linhas e depois todas as colunas

# Create the data frame.
emp.data <- data.frame(
   emp_id = c (1:5),
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25),
   
   start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
      "2015-03-27")),
   stringsAsFactors = FALSE
)
# Extract first two rows.
result <- emp.data[1:2,]
print(result)

Quando executamos o código acima, ele produz o seguinte resultado -

emp_id    emp_name   salary    start_date
1      1     Rick      623.3     2012-01-01
2      2     Dan       515.2     2013-09-23

Extrair 3 rd e 5 th linha com 2 nd e 4 th coluna

# Create the data frame.
emp.data <- data.frame(
   emp_id = c (1:5), 
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25), 
   
	start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
      "2015-03-27")),
   stringsAsFactors = FALSE
)

# Extract 3rd and 5th row with 2nd and 4th column.
result <- emp.data[c(3,5),c(2,4)]
print(result)

Quando executamos o código acima, ele produz o seguinte resultado -

emp_name start_date
3 Michelle 2014-11-15
5     Gary 2015-03-27

Expandir Quadro de Dados

Um quadro de dados pode ser expandido adicionando colunas e linhas.

Adicionar coluna

Basta adicionar o vetor da coluna usando um novo nome de coluna.

# Create the data frame.
emp.data <- data.frame(
   emp_id = c (1:5), 
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25), 
   
   start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
      "2015-03-27")),
   stringsAsFactors = FALSE
)

# Add the "dept" coulmn.
emp.data$dept <- c("IT","Operations","IT","HR","Finance")
v <- emp.data
print(v)

Quando executamos o código acima, ele produz o seguinte resultado -

emp_id   emp_name    salary    start_date       dept
1     1    Rick        623.30    2012-01-01       IT
2     2    Dan         515.20    2013-09-23       Operations
3     3    Michelle    611.00    2014-11-15       IT
4     4    Ryan        729.00    2014-05-11       HR
5     5    Gary        843.25    2015-03-27       Finance

Adicionar linha

Para adicionar mais linhas permanentemente a um quadro de dados existente, precisamos trazer as novas linhas na mesma estrutura do quadro de dados existente e usar o rbind() função.

No exemplo abaixo, criamos um quadro de dados com novas linhas e o fundimos com o quadro de dados existente para criar o quadro de dados final.

# Create the first data frame.
emp.data <- data.frame(
   emp_id = c (1:5), 
   emp_name = c("Rick","Dan","Michelle","Ryan","Gary"),
   salary = c(623.3,515.2,611.0,729.0,843.25), 
   
   start_date = as.Date(c("2012-01-01", "2013-09-23", "2014-11-15", "2014-05-11",
      "2015-03-27")),
   dept = c("IT","Operations","IT","HR","Finance"),
   stringsAsFactors = FALSE
)

# Create the second data frame
emp.newdata <- 	data.frame(
   emp_id = c (6:8), 
   emp_name = c("Rasmi","Pranab","Tusar"),
   salary = c(578.0,722.5,632.8), 
   start_date = as.Date(c("2013-05-21","2013-07-30","2014-06-17")),
   dept = c("IT","Operations","Fianance"),
   stringsAsFactors = FALSE
)

# Bind the two data frames.
emp.finaldata <- rbind(emp.data,emp.newdata)
print(emp.finaldata)

Quando executamos o código acima, ele produz o seguinte resultado -

emp_id     emp_name    salary     start_date       dept
1      1     Rick        623.30     2012-01-01       IT
2      2     Dan         515.20     2013-09-23       Operations
3      3     Michelle    611.00     2014-11-15       IT
4      4     Ryan        729.00     2014-05-11       HR
5      5     Gary        843.25     2015-03-27       Finance
6      6     Rasmi       578.00     2013-05-21       IT
7      7     Pranab      722.50     2013-07-30       Operations
8      8     Tusar       632.80     2014-06-17       Fianance

Os pacotes R são uma coleção de funções R, código compilado e dados de amostra. Eles são armazenados em um diretório chamado"library"no ambiente R. Por padrão, R instala um conjunto de pacotes durante a instalação. Mais pacotes são adicionados posteriormente, quando são necessários para algum propósito específico. Quando iniciamos o console R, apenas os pacotes padrão estão disponíveis por padrão. Outros pacotes que já estão instalados devem ser carregados explicitamente para serem usados ​​pelo programa R que irá usá-los.

Todos os pacotes disponíveis na linguagem R estão listados em Pacotes R.

Abaixo está uma lista de comandos a serem usados ​​para verificar, verificar e usar os pacotes R.

Verifique os pacotes R disponíveis

Obtenha localizações de bibliotecas contendo pacotes R

.libPaths()

Quando executamos o código acima, ele produz o seguinte resultado. Isso pode variar dependendo das configurações locais do seu PC.

[2] "C:/Program Files/R/R-3.2.2/library"

Obtenha a lista de todos os pacotes instalados

library()

Quando executamos o código acima, ele produz o seguinte resultado. Isso pode variar dependendo das configurações locais do seu PC.

Packages in library ‘C:/Program Files/R/R-3.2.2/library’:

base                    The R Base Package
boot                    Bootstrap Functions (Originally by Angelo Canty
                        for S)
class                   Functions for Classification
cluster                 "Finding Groups in Data": Cluster Analysis
                        Extended Rousseeuw et al.
codetools               Code Analysis Tools for R
compiler                The R Compiler Package
datasets                The R Datasets Package
foreign                 Read Data Stored by 'Minitab', 'S', 'SAS',
                        'SPSS', 'Stata', 'Systat', 'Weka', 'dBase', ...
graphics                The R Graphics Package
grDevices               The R Graphics Devices and Support for Colours
                        and Fonts
grid                    The Grid Graphics Package
KernSmooth              Functions for Kernel Smoothing Supporting Wand
                        & Jones (1995)
lattice                 Trellis Graphics for R
MASS                    Support Functions and Datasets for Venables and
                        Ripley's MASS
Matrix                  Sparse and Dense Matrix Classes and Methods
methods                 Formal Methods and Classes
mgcv                    Mixed GAM Computation Vehicle with GCV/AIC/REML
                        Smoothness Estimation
nlme                    Linear and Nonlinear Mixed Effects Models
nnet                    Feed-Forward Neural Networks and Multinomial
                        Log-Linear Models
parallel                Support for Parallel computation in R
rpart                   Recursive Partitioning and Regression Trees
spatial                 Functions for Kriging and Point Pattern
                        Analysis
splines                 Regression Spline Functions and Classes
stats                   The R Stats Package
stats4                  Statistical Functions using S4 Classes
survival                Survival Analysis
tcltk                   Tcl/Tk Interface
tools                   Tools for Package Development
utils                   The R Utils Package

Obtenha todos os pacotes carregados atualmente no ambiente R

search()

Quando executamos o código acima, ele produz o seguinte resultado. Isso pode variar dependendo das configurações locais do seu PC.

[1] ".GlobalEnv"        "package:stats"     "package:graphics" 
[4] "package:grDevices" "package:utils"     "package:datasets" 
[7] "package:methods"   "Autoloads"         "package:base"

Instale um novo pacote

Existem duas maneiras de adicionar novos pacotes R. Um é instalar diretamente do diretório CRAN e outro é baixar o pacote para seu sistema local e instalá-lo manualmente.

Instale diretamente do CRAN

O comando a seguir obtém os pacotes diretamente da página da Web do CRAN e instala o pacote no ambiente R. Você pode ser solicitado a escolher um espelho mais próximo. Escolha o apropriado para sua localização.

install.packages("Package Name")
 
# Install the package named "XML".
 install.packages("XML")

Instale o pacote manualmente

Acesse o link Pacotes R para baixar o pacote necessário. Salve o pacote como um.zip arquivo em um local adequado no sistema local.

Agora você pode executar o seguinte comando para instalar este pacote no ambiente R.

install.packages(file_name_with_path, repos = NULL, type = "source")

# Install the package named "XML"
install.packages("E:/XML_3.98-1.3.zip", repos = NULL, type = "source")

Carregar pacote na biblioteca

Antes que um pacote possa ser usado no código, ele deve ser carregado no ambiente R atual. Você também precisa carregar um pacote que já está instalado anteriormente, mas não disponível no ambiente atual.

Um pacote é carregado usando o seguinte comando -

library("package Name", lib.loc = "path to library")

# Load the package named "XML"
install.packages("E:/XML_3.98-1.3.zip", repos = NULL, type = "source")

A remodelagem de dados em R trata de alterar a maneira como os dados são organizados em linhas e colunas. Na maior parte do tempo, o processamento de dados em R é feito tomando os dados de entrada como um quadro de dados. É fácil extrair dados das linhas e colunas de um quadro de dados, mas há situações em que precisamos do quadro de dados em um formato diferente do formato em que o recebemos. R tem muitas funções para dividir, mesclar e transformar as linhas em colunas e vice-versa em um quadro de dados.

Juntando colunas e linhas em um quadro de dados

Podemos juntar vários vetores para criar um quadro de dados usando o cbind()função. Também podemos fundir dois quadros de dados usandorbind() função.

# Create vector objects.
city <- c("Tampa","Seattle","Hartford","Denver")
state <- c("FL","WA","CT","CO")
zipcode <- c(33602,98104,06161,80294)

# Combine above three vectors into one data frame.
addresses <- cbind(city,state,zipcode)

# Print a header.
cat("# # # # The First data frame\n") 

# Print the data frame.
print(addresses)

# Create another data frame with similar columns
new.address <- data.frame(
   city = c("Lowry","Charlotte"),
   state = c("CO","FL"),
   zipcode = c("80230","33949"),
   stringsAsFactors = FALSE
)

# Print a header.
cat("# # # The Second data frame\n") 

# Print the data frame.
print(new.address)

# Combine rows form both the data frames.
all.addresses <- rbind(addresses,new.address)

# Print a header.
cat("# # # The combined data frame\n") 

# Print the result.
print(all.addresses)

Quando executamos o código acima, ele produz o seguinte resultado -

# # # # The First data frame
     city       state zipcode
[1,] "Tampa"    "FL"  "33602"
[2,] "Seattle"  "WA"  "98104"
[3,] "Hartford" "CT"   "6161" 
[4,] "Denver"   "CO"  "80294"

# # # The Second data frame
       city       state   zipcode
1      Lowry      CO      80230
2      Charlotte  FL      33949

# # # The combined data frame
       city      state zipcode
1      Tampa     FL    33602
2      Seattle   WA    98104
3      Hartford  CT     6161
4      Denver    CO    80294
5      Lowry     CO    80230
6     Charlotte  FL    33949

Mesclando Quadros de Dados

Podemos fundir dois quadros de dados usando o merge()função. Os quadros de dados devem ter os mesmos nomes de coluna em que ocorre a fusão.

No exemplo abaixo, consideramos os conjuntos de dados sobre Diabetes em Mulheres Indígenas Pima disponíveis nos nomes de biblioteca "MASSA". mesclamos os dois conjuntos de dados com base nos valores da pressão arterial ("bp") e índice de massa corporal ("bmi"). Ao escolher essas duas colunas para fusão, os registros onde os valores dessas duas variáveis ​​correspondem em ambos os conjuntos de dados são combinados para formar um único quadro de dados.

library(MASS)
merged.Pima <- merge(x = Pima.te, y = Pima.tr,
   by.x = c("bp", "bmi"),
   by.y = c("bp", "bmi")
)
print(merged.Pima)
nrow(merged.Pima)

Quando executamos o código acima, ele produz o seguinte resultado -

bp  bmi npreg.x glu.x skin.x ped.x age.x type.x npreg.y glu.y skin.y ped.y
1  60 33.8       1   117     23 0.466    27     No       2   125     20 0.088
2  64 29.7       2    75     24 0.370    33     No       2   100     23 0.368
3  64 31.2       5   189     33 0.583    29    Yes       3   158     13 0.295
4  64 33.2       4   117     27 0.230    24     No       1    96     27 0.289
5  66 38.1       3   115     39 0.150    28     No       1   114     36 0.289
6  68 38.5       2   100     25 0.324    26     No       7   129     49 0.439
7  70 27.4       1   116     28 0.204    21     No       0   124     20 0.254
8  70 33.1       4    91     32 0.446    22     No       9   123     44 0.374
9  70 35.4       9   124     33 0.282    34     No       6   134     23 0.542
10 72 25.6       1   157     21 0.123    24     No       4    99     17 0.294
11 72 37.7       5    95     33 0.370    27     No       6   103     32 0.324
12 74 25.9       9   134     33 0.460    81     No       8   126     38 0.162
13 74 25.9       1    95     21 0.673    36     No       8   126     38 0.162
14 78 27.6       5    88     30 0.258    37     No       6   125     31 0.565
15 78 27.6      10   122     31 0.512    45     No       6   125     31 0.565
16 78 39.4       2   112     50 0.175    24     No       4   112     40 0.236
17 88 34.5       1   117     24 0.403    40    Yes       4   127     11 0.598
   age.y type.y
1     31     No
2     21     No
3     24     No
4     21     No
5     21     No
6     43    Yes
7     36    Yes
8     40     No
9     29    Yes
10    28     No
11    55     No
12    39     No
13    39     No
14    49    Yes
15    49    Yes
16    38     No
17    28     No
[1] 17

Derretimento e Fundição

Um dos aspectos mais interessantes da programação R é sobre como alterar a forma dos dados em várias etapas para obter a forma desejada. As funções usadas para fazer isso são chamadasmelt() e cast().

Consideramos o conjunto de dados denominado navios presente na biblioteca denominada "MASSA".

library(MASS)
print(ships)

Quando executamos o código acima, ele produz o seguinte resultado -

type year   period   service   incidents
1     A   60     60        127         0
2     A   60     75         63         0
3     A   65     60       1095         3
4     A   65     75       1095         4
5     A   70     60       1512         6
.............
.............
8     A   75     75       2244         11
9     B   60     60      44882         39
10    B   60     75      17176         29
11    B   65     60      28609         58
............
............
17    C   60     60      1179          1
18    C   60     75       552          1
19    C   65     60       781          0
............
............

Derreta os dados

Agora, fundimos os dados para organizá-los, convertendo todas as colunas, exceto tipo e ano, em várias linhas.

molten.ships <- melt(ships, id = c("type","year"))
print(molten.ships)

Quando executamos o código acima, ele produz o seguinte resultado -

type year  variable  value
1      A   60    period      60
2      A   60    period      75
3      A   65    period      60
4      A   65    period      75
............
............
9      B   60    period      60
10     B   60    period      75
11     B   65    period      60
12     B   65    period      75
13     B   70    period      60
...........
...........
41     A   60    service    127
42     A   60    service     63
43     A   65    service   1095
...........
...........
70     D   70    service   1208
71     D   75    service      0
72     D   75    service   2051
73     E   60    service     45
74     E   60    service      0
75     E   65    service    789
...........
...........
101    C   70    incidents    6
102    C   70    incidents    2
103    C   75    incidents    0
104    C   75    incidents    1
105    D   60    incidents    0
106    D   60    incidents    0
...........
...........

Lance os dados fundidos

Podemos lançar os dados fundidos em uma nova forma, onde o agregado de cada tipo de navio para cada ano é criado. Isso é feito usando ocast() função.

recasted.ship <- cast(molten.ships, type+year~variable,sum)
print(recasted.ship)

Quando executamos o código acima, ele produz o seguinte resultado -

type year  period  service  incidents
1     A   60    135       190      0
2     A   65    135      2190      7
3     A   70    135      4865     24
4     A   75    135      2244     11
5     B   60    135     62058     68
6     B   65    135     48979    111
7     B   70    135     20163     56
8     B   75    135      7117     18
9     C   60    135      1731      2
10    C   65    135      1457      1
11    C   70    135      2731      8
12    C   75    135       274      1
13    D   60    135       356      0
14    D   65    135       480      0
15    D   70    135      1557     13
16    D   75    135      2051      4
17    E   60    135        45      0
18    E   65    135      1226     14
19    E   70    135      3318     17
20    E   75    135       542      1

Em R, podemos ler dados de arquivos armazenados fora do ambiente R. Também podemos gravar dados em arquivos que serão armazenados e acessados ​​pelo sistema operacional. R pode ler e gravar em vários formatos de arquivo como csv, excel, xml etc.

Neste capítulo, aprenderemos a ler dados de um arquivo csv e, a seguir, gravar dados em um arquivo csv. O arquivo deve estar presente no diretório de trabalho atual para que R possa lê-lo. Claro que também podemos definir nosso próprio diretório e ler os arquivos a partir dele.

Obtendo e configurando o diretório de trabalho

Você pode verificar para qual diretório o espaço de trabalho R está apontando usando o getwd()função. Você também pode definir um novo diretório de trabalho usandosetwd()função.

# Get and print current working directory.
print(getwd())

# Set current working directory.
setwd("/web/com")

# Get and print current working directory.
print(getwd())

Quando executamos o código acima, ele produz o seguinte resultado -

[1] "/web/com/1441086124_2016"
[1] "/web/com"

Este resultado depende do seu sistema operacional e do diretório atual onde você está trabalhando.

Entrada como arquivo CSV

O arquivo csv é um arquivo de texto no qual os valores nas colunas são separados por uma vírgula. Vamos considerar os seguintes dados presentes no arquivo chamadoinput.csv.

Você pode criar esse arquivo usando o bloco de notas do Windows, copiando e colando esses dados. Salve o arquivo comoinput.csv usando a opção salvar como todos os arquivos (*. *) no bloco de notas.

id,name,salary,start_date,dept
1,Rick,623.3,2012-01-01,IT
2,Dan,515.2,2013-09-23,Operations
3,Michelle,611,2014-11-15,IT
4,Ryan,729,2014-05-11,HR
5,Gary,843.25,2015-03-27,Finance
6,Nina,578,2013-05-21,IT
7,Simon,632.8,2013-07-30,Operations
8,Guru,722.5,2014-06-17,Finance

Ler um arquivo CSV

A seguir está um exemplo simples de read.csv() função para ler um arquivo CSV disponível em seu diretório de trabalho atual -

data <- read.csv("input.csv")
print(data)

Quando executamos o código acima, ele produz o seguinte resultado -

id,   name,    salary,   start_date,     dept
1      1    Rick     623.30    2012-01-01      IT
2      2    Dan      515.20    2013-09-23      Operations
3      3    Michelle 611.00    2014-11-15      IT
4      4    Ryan     729.00    2014-05-11      HR
5     NA    Gary     843.25    2015-03-27      Finance
6      6    Nina     578.00    2013-05-21      IT
7      7    Simon    632.80    2013-07-30      Operations
8      8    Guru     722.50    2014-06-17      Finance

Analisando o arquivo CSV

Por padrão, o read.csv()função fornece a saída como um quadro de dados. Isso pode ser facilmente verificado da seguinte maneira. Também podemos verificar o número de colunas e linhas.

data <- read.csv("input.csv")

print(is.data.frame(data))
print(ncol(data))
print(nrow(data))

Quando executamos o código acima, ele produz o seguinte resultado -

[1] TRUE
[1] 5
[1] 8

Depois de ler os dados em um quadro de dados, podemos aplicar todas as funções aplicáveis ​​aos quadros de dados, conforme explicado na seção subsequente.

Obtenha o salário máximo

# Create a data frame.
data <- read.csv("input.csv")

# Get the max salary from data frame.
sal <- max(data$salary)
print(sal)

Quando executamos o código acima, ele produz o seguinte resultado -

[1] 843.25

Obtenha os detalhes da pessoa com salário máximo

Podemos buscar linhas que atendam a critérios de filtro específicos semelhantes a uma cláusula where do SQL.

# Create a data frame.
data <- read.csv("input.csv")

# Get the max salary from data frame.
sal <- max(data$salary)

# Get the person detail having max salary.
retval <- subset(data, salary == max(salary))
print(retval)

Quando executamos o código acima, ele produz o seguinte resultado -

id    name  salary  start_date    dept
5     NA    Gary  843.25  2015-03-27    Finance

Faça com que todas as pessoas trabalhem no departamento de TI

# Create a data frame.
data <- read.csv("input.csv")

retval <- subset( data, dept == "IT")
print(retval)

Quando executamos o código acima, ele produz o seguinte resultado -

id   name      salary   start_date   dept
1      1    Rick      623.3    2012-01-01   IT
3      3    Michelle  611.0    2014-11-15   IT
6      6    Nina      578.0    2013-05-21   IT

Obtenha as pessoas no departamento de TI cujo salário é superior a 600

# Create a data frame.
data <- read.csv("input.csv")

info <- subset(data, salary > 600 & dept == "IT")
print(info)

Quando executamos o código acima, ele produz o seguinte resultado -

id   name      salary   start_date   dept
1      1    Rick      623.3    2012-01-01   IT
3      3    Michelle  611.0    2014-11-15   IT

Obtenha as pessoas que aderiram em ou depois de 2014

# Create a data frame.
data <- read.csv("input.csv")

retval <- subset(data, as.Date(start_date) > as.Date("2014-01-01"))
print(retval)

Quando executamos o código acima, ele produz o seguinte resultado -

id   name     salary   start_date    dept
3      3    Michelle 611.00   2014-11-15    IT
4      4    Ryan     729.00   2014-05-11    HR
5     NA    Gary     843.25   2015-03-27    Finance
8      8    Guru     722.50   2014-06-17    Finance

Gravando em um arquivo CSV

R pode criar um arquivo csv a partir de um quadro de dados existente. owrite.csv()função é usada para criar o arquivo csv. Este arquivo é criado no diretório de trabalho.

# Create a data frame.
data <- read.csv("input.csv")
retval <- subset(data, as.Date(start_date) > as.Date("2014-01-01"))

# Write filtered data into a new file.
write.csv(retval,"output.csv")
newdata <- read.csv("output.csv")
print(newdata)

Quando executamos o código acima, ele produz o seguinte resultado -

X      id   name      salary   start_date    dept
1 3      3    Michelle  611.00   2014-11-15    IT
2 4      4    Ryan      729.00   2014-05-11    HR
3 5     NA    Gary      843.25   2015-03-27    Finance
4 8      8    Guru      722.50   2014-06-17    Finance

Aqui, a coluna X vem do conjunto de dados newper. Isso pode ser eliminado usando parâmetros adicionais durante a gravação do arquivo.

# Create a data frame.
data <- read.csv("input.csv")
retval <- subset(data, as.Date(start_date) > as.Date("2014-01-01"))

# Write filtered data into a new file.
write.csv(retval,"output.csv", row.names = FALSE)
newdata <- read.csv("output.csv")
print(newdata)

Quando executamos o código acima, ele produz o seguinte resultado -

id    name      salary   start_date    dept
1      3    Michelle  611.00   2014-11-15    IT
2      4    Ryan      729.00   2014-05-11    HR
3     NA    Gary      843.25   2015-03-27    Finance
4      8    Guru      722.50   2014-06-17    Finance

O Microsoft Excel é o programa de planilhas mais amplamente usado que armazena dados no formato .xls ou .xlsx. R pode ler diretamente desses arquivos usando alguns pacotes específicos do Excel. Poucos pacotes são - XLConnect, xlsx, gdata etc. Estaremos usando o pacote xlsx. R também pode escrever em arquivo excel usando este pacote.

Instale o pacote xlsx

Você pode usar o seguinte comando no console R para instalar o pacote "xlsx". Pode ser necessário instalar alguns pacotes adicionais dos quais este pacote depende. Siga o mesmo comando com o nome do pacote necessário para instalar os pacotes adicionais.

install.packages("xlsx")

Verifique e carregue o pacote "xlsx"

Use o seguinte comando para verificar e carregar o pacote "xlsx".

# Verify the package is installed.
any(grepl("xlsx",installed.packages()))

# Load the library into R workspace.
library("xlsx")

Quando o script é executado, obtemos a seguinte saída.

[1] TRUE
Loading required package: rJava
Loading required package: methods
Loading required package: xlsxjars

Entrada como arquivo xlsx

Abra o Microsoft Excel. Copie e cole os seguintes dados na planilha chamada planilha1.

id	name      salary    start_date	dept
1	Rick	    623.3	  1/1/2012	   IT
2	Dan       515.2     9/23/2013    Operations
3	Michelle  611	     11/15/2014	IT
4	Ryan	    729	     5/11/2014	   HR
5	Gary	    43.25     3/27/2015  	Finance
6	Nina	    578       5/21/2013	   IT
7	Simon	    632.8	  7/30/2013	   Operations
8	Guru	    722.5	  6/17/2014	   Finance

Além disso, copie e cole os seguintes dados em outra planilha e renomeie esta planilha para "cidade".

name	    city
Rick	    Seattle
Dan       Tampa
Michelle  Chicago
Ryan	    Seattle
Gary	    Houston
Nina	    Boston
Simon	    Mumbai
Guru	    Dallas

Salve o arquivo Excel como "input.xlsx". Você deve salvá-lo no diretório de trabalho atual da área de trabalho R.

Lendo o arquivo Excel

O input.xlsx é lido usando o read.xlsx()função conforme mostrado abaixo. O resultado é armazenado como um quadro de dados no ambiente R.

# Read the first worksheet in the file input.xlsx.
data <- read.xlsx("input.xlsx", sheetIndex = 1)
print(data)

Quando executamos o código acima, ele produz o seguinte resultado -

id,   name,     salary,   start_date,   dept
1      1    Rick      623.30    2012-01-01    IT
2      2    Dan       515.20    2013-09-23    Operations
3      3    Michelle  611.00    2014-11-15    IT
4      4    Ryan      729.00    2014-05-11    HR
5     NA    Gary      843.25    2015-03-27    Finance
6      6    Nina      578.00    2013-05-21    IT
7      7    Simon     632.80    2013-07-30    Operations
8      8    Guru      722.50    2014-06-17    Finance

Um arquivo binário é um arquivo que contém informações armazenadas apenas na forma de bits e bytes (0's e 1's). Eles não são legíveis por humanos, pois os bytes neles se traduzem em caracteres e símbolos que contêm muitos outros caracteres não imprimíveis. A tentativa de ler um arquivo binário usando qualquer editor de texto mostrará caracteres como Ø e ð.

O arquivo binário deve ser lido por programas específicos para ser utilizável. Por exemplo, o arquivo binário de um programa Microsoft Word pode ser lido em um formato legível apenas pelo programa Word. O que indica que, além do texto legível por humanos, há muito mais informações como formatação de caracteres e números de página, etc., que também são armazenados junto com caracteres alfanuméricos. E, finalmente, um arquivo binário é uma sequência contínua de bytes. A quebra de linha que vemos em um arquivo de texto é um caractere que une a primeira linha à próxima.

Às vezes, os dados gerados por outros programas precisam ser processados ​​por R como um arquivo binário. Além disso, R é necessário para criar arquivos binários que podem ser compartilhados com outros programas.

R tem duas funções WriteBin() e readBin() para criar e ler arquivos binários.

Sintaxe

writeBin(object, con)
readBin(con, what, n )

A seguir está a descrição dos parâmetros usados ​​-

  • con é o objeto de conexão para ler ou gravar o arquivo binário.

  • object é o arquivo binário a ser gravado.

  • what é o modo como caractere, inteiro etc. que representa os bytes a serem lidos.

  • n é o número de bytes a serem lidos do arquivo binário.

Exemplo

Consideramos os dados embutidos de R como "mtcars". Primeiro, criamos um arquivo csv a partir dele e o convertemos em um arquivo binário e o armazenamos como um arquivo do sistema operacional. Em seguida, lemos este arquivo binário criado em R.

Escrevendo o arquivo binário

Lemos o quadro de dados "mtcars" como um arquivo csv e depois o gravamos como um arquivo binário no sistema operacional.

# Read the "mtcars" data frame as a csv file and store only the columns 
   "cyl", "am" and "gear".
write.table(mtcars, file = "mtcars.csv",row.names = FALSE, na = "", 
   col.names = TRUE, sep = ",")

# Store 5 records from the csv file as a new data frame.
new.mtcars <- read.table("mtcars.csv",sep = ",",header = TRUE,nrows = 5)

# Create a connection object to write the binary file using mode "wb".
write.filename = file("/web/com/binmtcars.dat", "wb")

# Write the column names of the data frame to the connection object.
writeBin(colnames(new.mtcars), write.filename)

# Write the records in each of the column to the file.
writeBin(c(new.mtcars$cyl,new.mtcars$am,new.mtcars$gear), write.filename)

# Close the file for writing so that it can be read by other program.
close(write.filename)

Lendo o arquivo binário

O arquivo binário criado acima armazena todos os dados como bytes contínuos. Portanto, vamos lê-lo escolhendo os valores apropriados dos nomes das colunas, bem como os valores das colunas.

# Create a connection object to read the file in binary mode using "rb".
read.filename <- file("/web/com/binmtcars.dat", "rb")

# First read the column names. n = 3 as we have 3 columns.
column.names <- readBin(read.filename, character(),  n = 3)

# Next read the column values. n = 18 as we have 3 column names and 15 values.
read.filename <- file("/web/com/binmtcars.dat", "rb")
bindata <- readBin(read.filename, integer(),  n = 18)

# Print the data.
print(bindata)

# Read the values from 4th byte to 8th byte which represents "cyl".
cyldata = bindata[4:8]
print(cyldata)

# Read the values form 9th byte to 13th byte which represents "am".
amdata = bindata[9:13]
print(amdata)

# Read the values form 9th byte to 13th byte which represents "gear".
geardata = bindata[14:18]
print(geardata)

# Combine all the read values to a dat frame.
finaldata = cbind(cyldata, amdata, geardata)
colnames(finaldata) = column.names
print(finaldata)

Quando executamos o código acima, ele produz o seguinte resultado e gráfico -

[1]    7108963 1728081249    7496037          6          6          4
 [7]          6          8          1          1          1          0
[13]          0          4          4          4          3          3

[1] 6 6 4 6 8

[1] 1 1 1 0 0

[1] 4 4 4 3 3

     cyl am gear
[1,]   6  1    4
[2,]   6  1    4
[3,]   4  1    4
[4,]   6  0    3
[5,]   8  0    3

Como podemos ver, recuperamos os dados originais lendo o arquivo binário em R.

XML é um formato de arquivo que compartilha o formato de arquivo e os dados na World Wide Web, intranets e em outros lugares usando texto ASCII padrão. Significa Extensible Markup Language (XML). Semelhante ao HTML, ele contém tags de marcação. Mas, ao contrário do HTML, onde a tag de marcação descreve a estrutura da página, em xml as tags de marcação descrevem o significado dos dados contidos no arquivo.

Você pode ler um arquivo xml em R usando o pacote "XML". Este pacote pode ser instalado usando o seguinte comando.

install.packages("XML")

Dados de entrada

Crie um arquivo XMl copiando os dados abaixo em um editor de texto como o bloco de notas. Salve o arquivo com um.xml extensão e escolher o tipo de arquivo como all files(*.*).

<RECORDS>
   <EMPLOYEE>
      <ID>1</ID>
      <NAME>Rick</NAME>
      <SALARY>623.3</SALARY>
      <STARTDATE>1/1/2012</STARTDATE>
      <DEPT>IT</DEPT>
   </EMPLOYEE>
	
   <EMPLOYEE>
      <ID>2</ID>
      <NAME>Dan</NAME>
      <SALARY>515.2</SALARY>
      <STARTDATE>9/23/2013</STARTDATE>
      <DEPT>Operations</DEPT>
   </EMPLOYEE>
   
   <EMPLOYEE>
      <ID>3</ID>
      <NAME>Michelle</NAME>
      <SALARY>611</SALARY>
      <STARTDATE>11/15/2014</STARTDATE>
      <DEPT>IT</DEPT>
   </EMPLOYEE>
   
   <EMPLOYEE>
      <ID>4</ID>
      <NAME>Ryan</NAME>
      <SALARY>729</SALARY>
      <STARTDATE>5/11/2014</STARTDATE>
      <DEPT>HR</DEPT>
   </EMPLOYEE>
   
   <EMPLOYEE>
      <ID>5</ID>
      <NAME>Gary</NAME>
      <SALARY>843.25</SALARY>
      <STARTDATE>3/27/2015</STARTDATE>
      <DEPT>Finance</DEPT>
   </EMPLOYEE>
   
   <EMPLOYEE>
      <ID>6</ID>
      <NAME>Nina</NAME>
      <SALARY>578</SALARY>
      <STARTDATE>5/21/2013</STARTDATE>
      <DEPT>IT</DEPT>
   </EMPLOYEE>
   
   <EMPLOYEE>
      <ID>7</ID>
      <NAME>Simon</NAME>
      <SALARY>632.8</SALARY>
      <STARTDATE>7/30/2013</STARTDATE>
      <DEPT>Operations</DEPT>
   </EMPLOYEE>
   
   <EMPLOYEE>
      <ID>8</ID>
      <NAME>Guru</NAME>
      <SALARY>722.5</SALARY>
      <STARTDATE>6/17/2014</STARTDATE>
      <DEPT>Finance</DEPT>
   </EMPLOYEE>
	
</RECORDS>

Lendo Arquivo XML

O arquivo xml é lido por R usando a função xmlParse(). Ele é armazenado como uma lista em R.

# Load the package required to read XML files.
library("XML")

# Also load the other required package.
library("methods")

# Give the input file name to the function.
result <- xmlParse(file = "input.xml")

# Print the result.
print(result)

Quando executamos o código acima, ele produz o seguinte resultado -

1
Rick
623.3
1/1/2012
IT

2
Dan
515.2
9/23/2013
Operations

3
Michelle
611
11/15/2014
IT

4
Ryan
729
5/11/2014
HR

5
Gary
843.25
3/27/2015
Finance

6
Nina
578
5/21/2013
IT

7
Simon
632.8
7/30/2013
Operations

8
Guru
722.5
6/17/2014
Finance

Obtenha o número de nós presentes no arquivo XML

# Load the packages required to read XML files.
library("XML")
library("methods")

# Give the input file name to the function.
result <- xmlParse(file = "input.xml")

# Exract the root node form the xml file.
rootnode <- xmlRoot(result)

# Find number of nodes in the root.
rootsize <- xmlSize(rootnode)

# Print the result.
print(rootsize)

Quando executamos o código acima, ele produz o seguinte resultado -

output
[1] 8

Detalhes do primeiro nó

Vejamos o primeiro registro do arquivo analisado. Isso nos dará uma ideia dos vários elementos presentes no nó de nível superior.

# Load the packages required to read XML files.
library("XML")
library("methods")

# Give the input file name to the function.
result <- xmlParse(file = "input.xml")

# Exract the root node form the xml file.
rootnode <- xmlRoot(result)

# Print the result.
print(rootnode[1])

Quando executamos o código acima, ele produz o seguinte resultado -

$EMPLOYEE
   1
   Rick
   623.3
   1/1/2012
   IT
 

attr(,"class")
[1] "XMLInternalNodeList" "XMLNodeList"

Obtenha diferentes elementos de um nó

# Load the packages required to read XML files.
library("XML")
library("methods")

# Give the input file name to the function.
result <- xmlParse(file = "input.xml")

# Exract the root node form the xml file.
rootnode <- xmlRoot(result)

# Get the first element of the first node.
print(rootnode[[1]][[1]])

# Get the fifth element of the first node.
print(rootnode[[1]][[5]])

# Get the second element of the third node.
print(rootnode[[3]][[2]])

Quando executamos o código acima, ele produz o seguinte resultado -

1 
IT 
Michelle

XML para quadro de dados

Para lidar com os dados de forma eficaz em arquivos grandes, lemos os dados no arquivo xml como um quadro de dados. Em seguida, processe o quadro de dados para análise de dados.

# Load the packages required to read XML files.
library("XML")
library("methods")

# Convert the input xml file to a data frame.
xmldataframe <- xmlToDataFrame("input.xml")
print(xmldataframe)

Quando executamos o código acima, ele produz o seguinte resultado -

ID    NAME     SALARY    STARTDATE       DEPT 
1      1    Rick     623.30    2012-01-01      IT
2      2    Dan      515.20    2013-09-23      Operations
3      3    Michelle 611.00    2014-11-15      IT
4      4    Ryan     729.00    2014-05-11      HR
5     NA    Gary     843.25    2015-03-27      Finance
6      6    Nina     578.00    2013-05-21      IT
7      7    Simon    632.80    2013-07-30      Operations
8      8    Guru     722.50    2014-06-17      Finance

Como os dados agora estão disponíveis como um quadro de dados, podemos usar a função relacionada ao quadro de dados para ler e manipular o arquivo.

O arquivo JSON armazena dados como texto em formato legível por humanos. Json significa JavaScript Object Notation. R pode ler arquivos JSON usando o pacote rjson.

Instale o pacote rjson

No console R, você pode emitir o seguinte comando para instalar o pacote rjson.

install.packages("rjson")

Dados de entrada

Crie um arquivo JSON copiando os dados abaixo em um editor de texto como o bloco de notas. Salve o arquivo com um.json extensão e escolher o tipo de arquivo como all files(*.*).

{ 
   "ID":["1","2","3","4","5","6","7","8" ],
   "Name":["Rick","Dan","Michelle","Ryan","Gary","Nina","Simon","Guru" ],
   "Salary":["623.3","515.2","611","729","843.25","578","632.8","722.5" ],
   
   "StartDate":[ "1/1/2012","9/23/2013","11/15/2014","5/11/2014","3/27/2015","5/21/2013",
      "7/30/2013","6/17/2014"],
   "Dept":[ "IT","Operations","IT","HR","Finance","IT","Operations","Finance"]
}

Leia o arquivo JSON

O arquivo JSON é lido por R usando a função de JSON(). Ele é armazenado como uma lista em R.

# Load the package required to read JSON files.
library("rjson")

# Give the input file name to the function.
result <- fromJSON(file = "input.json")

# Print the result.
print(result)

Quando executamos o código acima, ele produz o seguinte resultado -

$ID
[1] "1"   "2"   "3"   "4"   "5"   "6"   "7"   "8"

$Name [1] "Rick" "Dan" "Michelle" "Ryan" "Gary" "Nina" "Simon" "Guru" $Salary
[1] "623.3"  "515.2"  "611"    "729"    "843.25" "578"    "632.8"  "722.5"

$StartDate [1] "1/1/2012" "9/23/2013" "11/15/2014" "5/11/2014" "3/27/2015" "5/21/2013" "7/30/2013" "6/17/2014" $Dept
[1] "IT"         "Operations" "IT"         "HR"         "Finance"    "IT"
   "Operations" "Finance"

Converter JSON em um quadro de dados

Podemos converter os dados extraídos acima para um quadro de dados R para análise posterior usando o as.data.frame() função.

# Load the package required to read JSON files.
library("rjson")

# Give the input file name to the function.
result <- fromJSON(file = "input.json")

# Convert JSON file to a data frame.
json_data_frame <- as.data.frame(result)

print(json_data_frame)

Quando executamos o código acima, ele produz o seguinte resultado -

id,   name,    salary,   start_date,     dept
1      1    Rick     623.30    2012-01-01      IT
2      2    Dan      515.20    2013-09-23      Operations
3      3    Michelle 611.00    2014-11-15      IT
4      4    Ryan     729.00    2014-05-11      HR
5     NA    Gary     843.25    2015-03-27      Finance
6      6    Nina     578.00    2013-05-21      IT
7      7    Simon    632.80    2013-07-30      Operations
8      8    Guru     722.50    2014-06-17      Finance

Muitos sites fornecem dados para consumo por seus usuários. Por exemplo, a Organização Mundial da Saúde (OMS) fornece relatórios sobre informações médicas e de saúde na forma de arquivos CSV, txt e XML. Usando programas R, podemos extrair programaticamente dados específicos de tais sites. Alguns pacotes em R que são usados ​​para sucatear dados da web são - "RCurl", XML "e" stringr ". Eles são usados ​​para se conectar aos URLs, identificar os links necessários para os arquivos e baixá-los para o ambiente local.

Instale pacotes R

Os pacotes a seguir são necessários para o processamento de URLs e links para os arquivos. Se eles não estiverem disponíveis em seu ambiente R, você pode instalá-los usando os seguintes comandos.

install.packages("RCurl")
install.packages("XML")
install.packages("stringr")
install.packages("plyr")

Dados de entrada

Iremos visitar os dados meteorológicos do URL e baixar os arquivos CSV usando R para o ano de 2015.

Exemplo

Vamos usar a função getHTMLLinks()para reunir os URLs dos arquivos. Então usaremos a funçãodownload.file()para salvar os arquivos no sistema local. Como aplicaremos o mesmo código repetidamente para vários arquivos, criaremos uma função a ser chamada várias vezes. Os nomes dos arquivos são passados ​​como parâmetros na forma de um objeto de lista R para esta função.

# Read the URL.
url <- "http://www.geos.ed.ac.uk/~weather/jcmb_ws/"

# Gather the html links present in the webpage.
links <- getHTMLLinks(url)

# Identify only the links which point to the JCMB 2015 files. 
filenames <- links[str_detect(links, "JCMB_2015")]

# Store the file names as a list.
filenames_list <- as.list(filenames)

# Create a function to download the files by passing the URL and filename list.
downloadcsv <- function (mainurl,filename) {
   filedetails <- str_c(mainurl,filename)
   download.file(filedetails,filename)
}

# Now apply the l_ply function and save the files into the current R working directory.
l_ply(filenames,downloadcsv,mainurl = "http://www.geos.ed.ac.uk/~weather/jcmb_ws/")

Verifique o download do arquivo

Após executar o código acima, você pode localizar os seguintes arquivos no diretório de trabalho R atual.

"JCMB_2015.csv" "JCMB_2015_Apr.csv" "JCMB_2015_Feb.csv" "JCMB_2015_Jan.csv"
   "JCMB_2015_Mar.csv"

Os dados são sistemas de banco de dados relacional são armazenados em um formato normalizado. Portanto, para realizar computação estatística, precisaremos de consultas SQL muito avançadas e complexas. Mas R pode se conectar facilmente a muitos bancos de dados relacionais como MySql, Oracle, servidor Sql etc. e buscar registros deles como um quadro de dados. Uma vez que os dados estão disponíveis no ambiente R, eles se tornam um conjunto de dados R normal e podem ser manipulados ou analisados ​​usando todos os pacotes e funções poderosos.

Neste tutorial, usaremos MySql como nosso banco de dados de referência para conexão com R.

Pacote RMySQL

R tem um pacote integrado denominado "RMySQL" que fornece conectividade nativa entre com o banco de dados MySql. Você pode instalar este pacote no ambiente R usando o seguinte comando.

install.packages("RMySQL")

Conectando R ao MySql

Uma vez que o pacote é instalado, criamos um objeto de conexão em R para conectar ao banco de dados. Leva o nome de usuário, senha, nome do banco de dados e nome do host como entrada.

# Create a connection Object to MySQL database.
# We will connect to the sampel database named "sakila" that comes with MySql installation.
mysqlconnection = dbConnect(MySQL(), user = 'root', password = '', dbname = 'sakila',
   host = 'localhost')

# List the tables available in this database.
 dbListTables(mysqlconnection)

Quando executamos o código acima, ele produz o seguinte resultado -

[1] "actor"                      "actor_info"                
 [3] "address"                    "category"                  
 [5] "city"                       "country"                   
 [7] "customer"                   "customer_list"             
 [9] "film"                       "film_actor"                
[11] "film_category"              "film_list"                 
[13] "film_text"                  "inventory"                 
[15] "language"                   "nicer_but_slower_film_list"
[17] "payment"                    "rental"                    
[19] "sales_by_film_category"     "sales_by_store"            
[21] "staff"                      "staff_list"                
[23] "store"

Consultando as tabelas

Podemos consultar as tabelas do banco de dados no MySql usando a função dbSendQuery(). A consulta é executada no MySql e o conjunto de resultados é retornado usando o Rfetch()função. Finalmente, ele é armazenado como um quadro de dados em R.

# Query the "actor" tables to get all the rows.
result = dbSendQuery(mysqlconnection, "select * from actor")

# Store the result in a R data frame object. n = 5 is used to fetch first 5 rows.
data.frame = fetch(result, n = 5)
print(data.fame)

Quando executamos o código acima, ele produz o seguinte resultado -

actor_id   first_name    last_name         last_update
1        1         PENELOPE      GUINESS           2006-02-15 04:34:33
2        2         NICK          WAHLBERG          2006-02-15 04:34:33
3        3         ED            CHASE             2006-02-15 04:34:33
4        4         JENNIFER      DAVIS             2006-02-15 04:34:33
5        5         JOHNNY        LOLLOBRIGIDA      2006-02-15 04:34:33

Consulta com cláusula de filtro

Podemos passar qualquer consulta de seleção válida para obter o resultado.

result = dbSendQuery(mysqlconnection, "select * from actor where last_name = 'TORN'")

# Fetch all the records(with n = -1) and store it as a data frame.
data.frame = fetch(result, n = -1)
print(data)

Quando executamos o código acima, ele produz o seguinte resultado -

actor_id    first_name     last_name         last_update
1        18         DAN            TORN              2006-02-15 04:34:33
2        94         KENNETH        TORN              2006-02-15 04:34:33
3       102         WALTER         TORN              2006-02-15 04:34:33

Atualizando linhas nas tabelas

Podemos atualizar as linhas em uma tabela Mysql passando a consulta de atualização para a função dbSendQuery ().

dbSendQuery(mysqlconnection, "update mtcars set disp = 168.5 where hp = 110")

Após executar o código acima podemos ver a tabela atualizada no ambiente MySql.

Inserindo Dados nas Tabelas

dbSendQuery(mysqlconnection,
   "insert into mtcars(row_names, mpg, cyl, disp, hp, drat, wt, qsec, vs, am, gear, carb)
   values('New Mazda RX4 Wag', 21, 6, 168.5, 110, 3.9, 2.875, 17.02, 0, 1, 4, 4)"
)

Após executar o código acima, podemos ver a linha inserida na tabela no ambiente MySql.

Criação de tabelas no MySql

Podemos criar tabelas no MySql usando a função dbWriteTable(). Ele sobrescreve a tabela se ela já existir e leva um quadro de dados como entrada.

# Create the connection object to the database where we want to create the table.
mysqlconnection = dbConnect(MySQL(), user = 'root', password = '', dbname = 'sakila', 
   host = 'localhost')

# Use the R data frame "mtcars" to create the table in MySql.
# All the rows of mtcars are taken inot MySql.
dbWriteTable(mysqlconnection, "mtcars", mtcars[, ], overwrite = TRUE)

Após executar o código acima, podemos ver a tabela criada no ambiente MySql.

Eliminando tabelas no MySql

Podemos eliminar as tabelas no banco de dados MySql passando a instrução drop table em dbSendQuery () da mesma forma que usamos para consultar dados de tabelas.

dbSendQuery(mysqlconnection, 'drop table if exists mtcars')

Depois de executar o código acima, podemos ver que a tabela foi descartada no ambiente MySql.

A linguagem de programação R possui inúmeras bibliotecas para criar tabelas e gráficos. Um gráfico de pizza é uma representação de valores como fatias de um círculo com cores diferentes. As fatias são rotuladas e os números correspondentes a cada fatia também são representados no gráfico.

Em R, o gráfico de pizza é criado usando o pie()função que recebe números positivos como uma entrada vetorial. Os parâmetros adicionais são usados ​​para controlar rótulos, cor, título, etc.

Sintaxe

A sintaxe básica para criar um gráfico de pizza usando o R é -

pie(x, labels, radius, main, col, clockwise)

A seguir está a descrição dos parâmetros usados ​​-

  • x é um vetor que contém os valores numéricos usados ​​no gráfico de pizza.

  • labels é usado para descrever as fatias.

  • radius indica o raio do círculo do gráfico de pizza. (valor entre -1 e +1).

  • main indica o título do gráfico.

  • col indica a paleta de cores.

  • clockwise é um valor lógico que indica se as fatias são desenhadas no sentido horário ou anti-horário.

Exemplo

Um gráfico de pizza muito simples é criado usando apenas o vetor de entrada e os rótulos. O script a seguir criará e salvará o gráfico de pizza no diretório de trabalho R atual.

# Create data for the graph.
x <- c(21, 62, 10, 53)
labels <- c("London", "New York", "Singapore", "Mumbai")

# Give the chart file a name.
png(file = "city.png")

# Plot the chart.
pie(x,labels)

# Save the file.
dev.off()

Quando executamos o código acima, ele produz o seguinte resultado -

Título e cores do gráfico de pizza

Podemos expandir os recursos do gráfico adicionando mais parâmetros à função. Usaremos parâmetromain adicionar um título ao gráfico e outro parâmetro é colque fará uso da paleta de cores do arco-íris ao desenhar o gráfico. O comprimento do palete deve ser igual ao número de valores que temos para o gráfico. Portanto, usamos comprimento (x).

Exemplo

O script a seguir criará e salvará o gráfico de pizza no diretório de trabalho R atual.

# Create data for the graph.
x <- c(21, 62, 10, 53)
labels <- c("London", "New York", "Singapore", "Mumbai")

# Give the chart file a name.
png(file = "city_title_colours.jpg")

# Plot the chart with title and rainbow color pallet.
pie(x, labels, main = "City pie chart", col = rainbow(length(x)))

# Save the file.
dev.off()

Quando executamos o código acima, ele produz o seguinte resultado -

Porcentagens da fatia e legenda do gráfico

Podemos adicionar a porcentagem da fatia e uma legenda do gráfico criando variáveis ​​de gráfico adicionais.

# Create data for the graph.
x <-  c(21, 62, 10,53)
labels <-  c("London","New York","Singapore","Mumbai")

piepercent<- round(100*x/sum(x), 1)

# Give the chart file a name.
png(file = "city_percentage_legends.jpg")

# Plot the chart.
pie(x, labels = piepercent, main = "City pie chart",col = rainbow(length(x)))
legend("topright", c("London","New York","Singapore","Mumbai"), cex = 0.8,
   fill = rainbow(length(x)))

# Save the file.
dev.off()

Quando executamos o código acima, ele produz o seguinte resultado -

Gráfico Circular 3D

Um gráfico de pizza com 3 dimensões pode ser desenhado usando pacotes adicionais. O pacoteplotrix tem uma função chamada pie3D() que é usado para isso.

# Get the library.
library(plotrix)

# Create data for the graph.
x <-  c(21, 62, 10,53)
lbl <-  c("London","New York","Singapore","Mumbai")

# Give the chart file a name.
png(file = "3d_pie_chart.jpg")

# Plot the chart.
pie3D(x,labels = lbl,explode = 0.1, main = "Pie Chart of Countries ")

# Save the file.
dev.off()

Quando executamos o código acima, ele produz o seguinte resultado -

Um gráfico de barras representa os dados em barras retangulares com comprimento da barra proporcional ao valor da variável. R usa a funçãobarplot()para criar gráficos de barras. R pode desenhar barras verticais e horizontais no gráfico de barras. No gráfico de barras, cada uma das barras pode receber cores diferentes.

Sintaxe

A sintaxe básica para criar um gráfico de barras em R é -

barplot(H,xlab,ylab,main, names.arg,col)

A seguir está a descrição dos parâmetros usados ​​-

  • H é um vetor ou matriz que contém valores numéricos usados ​​no gráfico de barras.
  • xlab é o rótulo do eixo x.
  • ylab é o rótulo do eixo y.
  • main é o título do gráfico de barras.
  • names.arg é um vetor de nomes que aparecem em cada barra.
  • col é usado para dar cores às barras do gráfico.

Exemplo

Um gráfico de barras simples é criado usando apenas o vetor de entrada e o nome de cada barra.

O script a seguir criará e salvará o gráfico de barras no diretório de trabalho R atual.

# Create the data for the chart
H <- c(7,12,28,3,41)

# Give the chart file a name
png(file = "barchart.png")

# Plot the bar chart 
barplot(H)

# Save the file
dev.off()

Quando executamos o código acima, ele produz o seguinte resultado -

Etiquetas, título e cores do gráfico de barras

Os recursos do gráfico de barras podem ser expandidos adicionando mais parâmetros. omain parâmetro é usado para adicionar title. ocolparâmetro é usado para adicionar cores às barras. oargs.name é um vetor com o mesmo número de valores que o vetor de entrada para descrever o significado de cada barra.

Exemplo

O script a seguir criará e salvará o gráfico de barras no diretório de trabalho R atual.

# Create the data for the chart
H <- c(7,12,28,3,41)
M <- c("Mar","Apr","May","Jun","Jul")

# Give the chart file a name
png(file = "barchart_months_revenue.png")

# Plot the bar chart 
barplot(H,names.arg=M,xlab="Month",ylab="Revenue",col="blue",
main="Revenue chart",border="red")

# Save the file
dev.off()

Quando executamos o código acima, ele produz o seguinte resultado -

Gráfico de barras de grupo e gráfico de barras empilhadas

Podemos criar gráfico de barras com grupos de barras e pilhas em cada barra usando uma matriz como valores de entrada.

Mais de duas variáveis ​​são representadas como uma matriz que é usada para criar o gráfico de barras do grupo e o gráfico de barras empilhadas.

# Create the input vectors.
colors = c("green","orange","brown")
months <- c("Mar","Apr","May","Jun","Jul")
regions <- c("East","West","North")

# Create the matrix of the values.
Values <- matrix(c(2,9,3,11,9,4,8,7,3,12,5,2,8,10,11), nrow = 3, ncol = 5, byrow = TRUE)

# Give the chart file a name
png(file = "barchart_stacked.png")

# Create the bar chart
barplot(Values, main = "total revenue", names.arg = months, xlab = "month", ylab = "revenue", col = colors)

# Add the legend to the chart
legend("topleft", regions, cex = 1.3, fill = colors)

# Save the file
dev.off()

Os boxplots são uma medida de quão bem distribuídos estão os dados em um conjunto de dados. Ele divide o conjunto de dados em três quartis. Este gráfico representa o mínimo, máximo, mediana, primeiro quartil e terceiro quartil no conjunto de dados. Também é útil para comparar a distribuição de dados entre conjuntos de dados desenhando boxplots para cada um deles.

Boxplots são criados em R usando o boxplot() função.

Sintaxe

A sintaxe básica para criar um boxplot em R é -

boxplot(x, data, notch, varwidth, names, main)

A seguir está a descrição dos parâmetros usados ​​-

  • x é um vetor ou uma fórmula.

  • data é o quadro de dados.

  • notché um valor lógico. Defina como TRUE para desenhar um entalhe.

  • varwidthé um valor lógico. Defina como verdadeiro para desenhar a largura da caixa proporcional ao tamanho da amostra.

  • names são as etiquetas de grupo que serão impressas em cada boxplot.

  • main é usado para dar um título ao gráfico.

Exemplo

Usamos o conjunto de dados "mtcars" disponível no ambiente R para criar um boxplot básico. Vejamos as colunas "mpg" e "cyl" nos mtcars.

input <- mtcars[,c('mpg','cyl')]
print(head(input))

Quando executamos o código acima, ele produz o seguinte resultado -

mpg  cyl
Mazda RX4         21.0   6
Mazda RX4 Wag     21.0   6
Datsun 710        22.8   4
Hornet 4 Drive    21.4   6
Hornet Sportabout 18.7   8
Valiant           18.1   6

Criação do Boxplot

O script a seguir criará um gráfico de boxplot para a relação entre mpg (milhas por galão) e cyl (número de cilindros).

# Give the chart file a name.
png(file = "boxplot.png")

# Plot the chart.
boxplot(mpg ~ cyl, data = mtcars, xlab = "Number of Cylinders",
   ylab = "Miles Per Gallon", main = "Mileage Data")

# Save the file.
dev.off()

Quando executamos o código acima, ele produz o seguinte resultado -

Boxplot com Notch

Podemos desenhar boxplot com entalhe para descobrir como as medianas de diferentes grupos de dados correspondem umas às outras.

O script a seguir criará um gráfico de boxplot com entalhe para cada grupo de dados.

# Give the chart file a name.
png(file = "boxplot_with_notch.png")

# Plot the chart.
boxplot(mpg ~ cyl, data = mtcars, 
   xlab = "Number of Cylinders",
   ylab = "Miles Per Gallon", 
   main = "Mileage Data",
   notch = TRUE, 
   varwidth = TRUE, 
   col = c("green","yellow","purple"),
   names = c("High","Medium","Low")
)
# Save the file.
dev.off()

Quando executamos o código acima, ele produz o seguinte resultado -

Um histograma representa as frequências dos valores de uma variável dividida em intervalos. O histograma é semelhante ao chat de barra, mas a diferença é que agrupa os valores em intervalos contínuos. Cada barra do histograma representa a altura do número de valores presentes naquele intervalo.

R cria histograma usando hist()função. Esta função recebe um vetor como entrada e usa mais alguns parâmetros para traçar histogramas.

Sintaxe

A sintaxe básica para criar um histograma usando R é -

hist(v,main,xlab,xlim,ylim,breaks,col,border)

A seguir está a descrição dos parâmetros usados ​​-

  • v é um vetor que contém valores numéricos usados ​​no histograma.

  • main indica o título do gráfico.

  • col é usado para definir a cor das barras.

  • border é usado para definir a cor da borda de cada barra.

  • xlab é usado para dar a descrição do eixo x.

  • xlim é usado para especificar o intervalo de valores no eixo x.

  • ylim é usado para especificar o intervalo de valores no eixo y.

  • breaks é usado para mencionar a largura de cada barra.

Exemplo

Um histograma simples é criado usando parâmetros de vetor, rótulo, col e borda de entrada.

O script fornecido a seguir criará e salvará o histograma no diretório de trabalho R atual.

# Create data for the graph.
v <-  c(9,13,21,8,36,22,12,41,31,33,19)

# Give the chart file a name.
png(file = "histogram.png")

# Create the histogram.
hist(v,xlab = "Weight",col = "yellow",border = "blue")

# Save the file.
dev.off()

Quando executamos o código acima, ele produz o seguinte resultado -

Faixa de valores X e Y

Para especificar a faixa de valores permitidos nos eixos X e Y, podemos usar os parâmetros xlim e ylim.

A largura de cada barra pode ser decidida usando quebras.

# Create data for the graph.
v <- c(9,13,21,8,36,22,12,41,31,33,19)

# Give the chart file a name.
png(file = "histogram_lim_breaks.png")

# Create the histogram.
hist(v,xlab = "Weight",col = "green",border = "red", xlim = c(0,40), ylim = c(0,5),
   breaks = 5)

# Save the file.
dev.off()

Quando executamos o código acima, ele produz o seguinte resultado -

Um gráfico de linha é um gráfico que conecta uma série de pontos desenhando segmentos de linha entre eles. Esses pontos são ordenados em um de seus valores de coordenada (geralmente a coordenada x). Os gráficos de linha são geralmente usados ​​para identificar as tendências nos dados.

o plot() função em R é usada para criar o gráfico de linha.

Sintaxe

A sintaxe básica para criar um gráfico de linha em R é -

plot(v,type,col,xlab,ylab)

A seguir está a descrição dos parâmetros usados ​​-

  • v é um vetor que contém os valores numéricos.

  • type usa o valor "p" para desenhar apenas os pontos, "l" para desenhar apenas as linhas e "o" para desenhar tanto os pontos quanto as linhas.

  • xlab é o rótulo do eixo x.

  • ylab é o rótulo do eixo y.

  • main é o título do gráfico.

  • col é usado para dar cores aos pontos e às linhas.

Exemplo

Um gráfico de linha simples é criado usando o vetor de entrada e o parâmetro de tipo como "O". O script a seguir criará e salvará um gráfico de linha no diretório de trabalho R atual.

# Create the data for the chart.
v <- c(7,12,28,3,41)

# Give the chart file a name.
png(file = "line_chart.jpg")

# Plot the bar chart. 
plot(v,type = "o")

# Save the file.
dev.off()

Quando executamos o código acima, ele produz o seguinte resultado -

Título, cor e rótulos do gráfico de linha

Os recursos do gráfico de linha podem ser expandidos usando parâmetros adicionais. Adicionamos cor aos pontos e linhas, damos um título ao gráfico e adicionamos rótulos aos eixos.

Exemplo

# Create the data for the chart.
v <- c(7,12,28,3,41)

# Give the chart file a name.
png(file = "line_chart_label_colored.jpg")

# Plot the bar chart.
plot(v,type = "o", col = "red", xlab = "Month", ylab = "Rain fall",
   main = "Rain fall chart")

# Save the file.
dev.off()

Quando executamos o código acima, ele produz o seguinte resultado -

Várias linhas em um gráfico de linha

Mais de uma linha pode ser desenhada no mesmo gráfico usando o lines()função.

Depois que a primeira linha é plotada, a função lines () pode usar um vetor adicional como entrada para desenhar a segunda linha no gráfico,

# Create the data for the chart.
v <- c(7,12,28,3,41)
t <- c(14,7,6,19,3)

# Give the chart file a name.
png(file = "line_chart_2_lines.jpg")

# Plot the bar chart.
plot(v,type = "o",col = "red", xlab = "Month", ylab = "Rain fall", 
   main = "Rain fall chart")

lines(t, type = "o", col = "blue")

# Save the file.
dev.off()

Quando executamos o código acima, ele produz o seguinte resultado -

Os gráficos de dispersão mostram muitos pontos plotados no plano cartesiano. Cada ponto representa os valores de duas variáveis. Uma variável é escolhida no eixo horizontal e outra no eixo vertical.

O gráfico de dispersão simples é criado usando o plot() função.

Sintaxe

A sintaxe básica para a criação de gráfico de dispersão em R é -

plot(x, y, main, xlab, ylab, xlim, ylim, axes)

A seguir está a descrição dos parâmetros usados ​​-

  • x é o conjunto de dados cujos valores são as coordenadas horizontais.

  • y é o conjunto de dados cujos valores são as coordenadas verticais.

  • main é o bloco do gráfico.

  • xlab é o rótulo no eixo horizontal.

  • ylab é o rótulo no eixo vertical.

  • xlim são os limites dos valores de x usados ​​para plotagem.

  • ylim são os limites dos valores de y usados ​​para plotagem.

  • axes indica se ambos os eixos devem ser desenhados no gráfico.

Exemplo

Usamos o conjunto de dados "mtcars"disponível no ambiente R para criar um gráfico de dispersão básico. Vamos usar as colunas "wt" e "mpg" em mtcars.

input <- mtcars[,c('wt','mpg')]
print(head(input))

Quando executamos o código acima, ele produz o seguinte resultado -

wt      mpg
Mazda RX4           2.620   21.0
Mazda RX4 Wag       2.875   21.0
Datsun 710          2.320   22.8
Hornet 4 Drive      3.215   21.4
Hornet Sportabout   3.440   18.7
Valiant             3.460   18.1

Criação do gráfico de dispersão

O script a seguir criará um gráfico de dispersão para a relação entre peso (peso) e mpg (milhas por galão).

# Get the input values.
input <- mtcars[,c('wt','mpg')]

# Give the chart file a name.
png(file = "scatterplot.png")

# Plot the chart for cars with weight between 2.5 to 5 and mileage between 15 and 30.
plot(x = input$wt,y = input$mpg,
   xlab = "Weight",
   ylab = "Milage",
   xlim = c(2.5,5),
   ylim = c(15,30),		 
   main = "Weight vs Milage"
)
	 
# Save the file.
dev.off()

Quando executamos o código acima, ele produz o seguinte resultado -

Matrizes de gráfico de dispersão

Quando temos mais de duas variáveis ​​e queremos encontrar a correlação entre uma variável e as restantes, usamos a matriz de gráfico de dispersão. Nós usamospairs() função para criar matrizes de gráficos de dispersão.

Sintaxe

A sintaxe básica para a criação de matrizes de gráfico de dispersão em R é -

pairs(formula, data)

A seguir está a descrição dos parâmetros usados ​​-

  • formula representa a série de variáveis ​​usadas em pares.

  • data representa o conjunto de dados do qual as variáveis ​​serão obtidas.

Exemplo

Cada variável é pareada com cada uma das variáveis ​​restantes. Um gráfico de dispersão é traçado para cada par.

# Give the chart file a name.
png(file = "scatterplot_matrices.png")

# Plot the matrices between 4 variables giving 12 plots.

# One variable with 3 others and total 4 variables.

pairs(~wt+mpg+disp+cyl,data = mtcars,
   main = "Scatterplot Matrix")

# Save the file.
dev.off()

Quando o código acima é executado, obtemos a seguinte saída.

A análise estatística em R é realizada usando muitas funções embutidas. A maioria dessas funções faz parte do pacote R base. Essas funções tomam o vetor R como uma entrada junto com os argumentos e fornecem o resultado.

As funções que estamos discutindo neste capítulo são média, mediana e modo.

Significar

É calculado pegando a soma dos valores e dividindo com o número de valores em uma série de dados.

A função mean() é usado para calcular isso em R.

Sintaxe

A sintaxe básica para calcular a média em R é -

mean(x, trim = 0, na.rm = FALSE, ...)

A seguir está a descrição dos parâmetros usados ​​-

  • x é o vetor de entrada.

  • trim é usado para eliminar algumas observações de ambas as extremidades do vetor classificado.

  • na.rm é usado para remover os valores ausentes do vetor de entrada.

Exemplo

# Create a vector. 
x <- c(12,7,3,4.2,18,2,54,-21,8,-5)

# Find Mean.
result.mean <- mean(x)
print(result.mean)

Quando executamos o código acima, ele produz o seguinte resultado -

[1] 8.22

Aplicando Opção de Corte

Quando o parâmetro trim é fornecido, os valores no vetor são classificados e, em seguida, os números necessários de observações são eliminados do cálculo da média.

Quando trim = 0,3, 3 valores de cada extremidade serão retirados dos cálculos para encontrar a média.

Neste caso, o vetor classificado é (−21, −5, 2, 3, 4,2, 7, 8, 12, 18, 54) e os valores removidos do vetor para calcular a média são (−21, −5,2) da esquerda e (12,18,54) da direita.

# Create a vector.
x <- c(12,7,3,4.2,18,2,54,-21,8,-5)

# Find Mean.
result.mean <-  mean(x,trim = 0.3)
print(result.mean)

Quando executamos o código acima, ele produz o seguinte resultado -

[1] 5.55

Aplicando a Opção NA

Se houver valores ausentes, a função média retornará NA.

Para eliminar os valores ausentes do cálculo, use na.rm = TRUE. o que significa remover os valores NA.

# Create a vector. 
x <- c(12,7,3,4.2,18,2,54,-21,8,-5,NA)

# Find mean.
result.mean <-  mean(x)
print(result.mean)

# Find mean dropping NA values.
result.mean <-  mean(x,na.rm = TRUE)
print(result.mean)

Quando executamos o código acima, ele produz o seguinte resultado -

[1] NA
[1] 8.22

Mediana

O valor mais intermediário em uma série de dados é chamado de mediana. omedian() função é usada em R para calcular este valor.

Sintaxe

A sintaxe básica para calcular a mediana em R é -

median(x, na.rm = FALSE)

A seguir está a descrição dos parâmetros usados ​​-

  • x é o vetor de entrada.

  • na.rm é usado para remover os valores ausentes do vetor de entrada.

Exemplo

# Create the vector.
x <- c(12,7,3,4.2,18,2,54,-21,8,-5)

# Find the median.
median.result <- median(x)
print(median.result)

Quando executamos o código acima, ele produz o seguinte resultado -

[1] 5.6

Modo

O modo é o valor que possui o maior número de ocorrências em um conjunto de dados. Ao contrário da média e da mediana, o modo pode ter dados numéricos e de caracteres.

R não tem uma função embutida padrão para calcular o modo. Portanto, criamos uma função de usuário para calcular o modo de um conjunto de dados em R. Essa função recebe o vetor como entrada e fornece o valor do modo como saída.

Exemplo

# Create the function.
getmode <- function(v) {
   uniqv <- unique(v)
   uniqv[which.max(tabulate(match(v, uniqv)))]
}

# Create the vector with numbers.
v <- c(2,1,2,3,1,2,3,4,1,5,5,3,2,3)

# Calculate the mode using the user function.
result <- getmode(v)
print(result)

# Create the vector with characters.
charv <- c("o","it","the","it","it")

# Calculate the mode using the user function.
result <- getmode(charv)
print(result)

Quando executamos o código acima, ele produz o seguinte resultado -

[1] 2
[1] "it"

A análise de regressão é uma ferramenta estatística amplamente utilizada para estabelecer um modelo de relacionamento entre duas variáveis. Uma dessas variáveis ​​é chamada de variável preditora, cujo valor é obtido por meio de experimentos. A outra variável é chamada de variável de resposta, cujo valor é derivado da variável preditora.

Na regressão linear, essas duas variáveis ​​são relacionadas por meio de uma equação, onde o expoente (potência) de ambas as variáveis ​​é 1. Matematicamente, uma relação linear representa uma linha reta quando plotada como um gráfico. Uma relação não linear em que o expoente de qualquer variável não é igual a 1 cria uma curva.

A equação matemática geral para uma regressão linear é -

y = ax + b

A seguir está a descrição dos parâmetros usados ​​-

  • y é a variável de resposta.

  • x é a variável preditora.

  • a e b são constantes que são chamadas de coeficientes.

Passos para estabelecer uma regressão

Um exemplo simples de regressão é prever o peso de uma pessoa quando sua altura é conhecida. Para fazer isso, precisamos ter a relação entre altura e peso de uma pessoa.

As etapas para criar o relacionamento são -

  • Faça o experimento de coleta de uma amostra dos valores observados de altura e peso correspondente.

  • Crie um modelo de relacionamento usando o lm() funções em R.

  • Encontre os coeficientes do modelo criado e crie a equação matemática usando estes

  • Obtenha um resumo do modelo de relacionamento para saber o erro médio na previsão. Também chamadoresiduals.

  • Para prever o peso de novas pessoas, use o predict() função em R.

Dados de entrada

Abaixo estão os dados de amostra que representam as observações -

# Values of height
151, 174, 138, 186, 128, 136, 179, 163, 152, 131

# Values of weight.
63, 81, 56, 91, 47, 57, 76, 72, 62, 48

Função lm ()

Esta função cria o modelo de relacionamento entre o preditor e a variável de resposta.

Sintaxe

A sintaxe básica para lm() função na regressão linear é -

lm(formula,data)

A seguir está a descrição dos parâmetros usados ​​-

  • formula é um símbolo que apresenta a relação entre x e y.

  • data é o vetor no qual a fórmula será aplicada.

Crie um modelo de relacionamento e obtenha os coeficientes

x <- c(151, 174, 138, 186, 128, 136, 179, 163, 152, 131)
y <- c(63, 81, 56, 91, 47, 57, 76, 72, 62, 48)

# Apply the lm() function.
relation <- lm(y~x)

print(relation)

Quando executamos o código acima, ele produz o seguinte resultado -

Call:
lm(formula = y ~ x)

Coefficients:
(Intercept)            x  
   -38.4551          0.6746

Obtenha o Resumo do Relacionamento

x <- c(151, 174, 138, 186, 128, 136, 179, 163, 152, 131)
y <- c(63, 81, 56, 91, 47, 57, 76, 72, 62, 48)

# Apply the lm() function.
relation <- lm(y~x)

print(summary(relation))

Quando executamos o código acima, ele produz o seguinte resultado -

Call:
lm(formula = y ~ x)

Residuals:
    Min      1Q     Median      3Q     Max 
-6.3002    -1.6629  0.0412    1.8944  3.9775 

Coefficients:
             Estimate Std. Error t value Pr(>|t|)    
(Intercept) -38.45509    8.04901  -4.778  0.00139 ** 
x             0.67461    0.05191  12.997 1.16e-06 ***
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1

Residual standard error: 3.253 on 8 degrees of freedom
Multiple R-squared:  0.9548,    Adjusted R-squared:  0.9491 
F-statistic: 168.9 on 1 and 8 DF,  p-value: 1.164e-06

Função Predict ()

Sintaxe

A sintaxe básica para predizer () em regressão linear é -

predict(object, newdata)

A seguir está a descrição dos parâmetros usados ​​-

  • object é a fórmula que já foi criada usando a função lm ().

  • newdata é o vetor que contém o novo valor da variável preditora.

Preveja o peso de novas pessoas

# The predictor vector.
x <- c(151, 174, 138, 186, 128, 136, 179, 163, 152, 131)

# The resposne vector.
y <- c(63, 81, 56, 91, 47, 57, 76, 72, 62, 48)

# Apply the lm() function.
relation <- lm(y~x)

# Find weight of a person with height 170.
a <- data.frame(x = 170)
result <-  predict(relation,a)
print(result)

Quando executamos o código acima, ele produz o seguinte resultado -

1 
76.22869

Visualize a regressão graficamente

# Create the predictor and response variable.
x <- c(151, 174, 138, 186, 128, 136, 179, 163, 152, 131)
y <- c(63, 81, 56, 91, 47, 57, 76, 72, 62, 48)
relation <- lm(y~x)

# Give the chart file a name.
png(file = "linearregression.png")

# Plot the chart.
plot(y,x,col = "blue",main = "Height & Weight Regression",
abline(lm(x~y)),cex = 1.3,pch = 16,xlab = "Weight in Kg",ylab = "Height in cm")

# Save the file.
dev.off()

Quando executamos o código acima, ele produz o seguinte resultado -

A regressão múltipla é uma extensão da regressão linear no relacionamento entre mais de duas variáveis. Na relação linear simples, temos um preditor e uma variável de resposta, mas na regressão múltipla temos mais de uma variável preditora e uma variável de resposta.

A equação matemática geral para regressão múltipla é -

y = a + b1x1 + b2x2 +...bnxn

A seguir está a descrição dos parâmetros usados ​​-

  • y é a variável de resposta.

  • a, b1, b2...bn são os coeficientes.

  • x1, x2, ...xn são as variáveis ​​preditoras.

Criamos o modelo de regressão usando o lm()em R. O modelo determina o valor dos coeficientes usando os dados de entrada. Em seguida, podemos prever o valor da variável de resposta para um determinado conjunto de variáveis ​​preditoras usando esses coeficientes.

Função lm ()

Esta função cria o modelo de relacionamento entre o preditor e a variável de resposta.

Sintaxe

A sintaxe básica para lm() função em regressão múltipla é -

lm(y ~ x1+x2+x3...,data)

A seguir está a descrição dos parâmetros usados ​​-

  • formula é um símbolo que apresenta a relação entre a variável de resposta e as variáveis ​​preditoras.

  • data é o vetor no qual a fórmula será aplicada.

Exemplo

Dados de entrada

Considere o conjunto de dados "mtcars" disponível no ambiente R. Ele fornece uma comparação entre diferentes modelos de carros em termos de quilometragem por galão (mpg), deslocamento do cilindro ("disp"), cavalos de força ("hp"), peso do carro ("wt") e mais alguns parâmetros.

O objetivo do modelo é estabelecer a relação entre "mpg" como uma variável de resposta com "disp", "hp" e "wt" como variáveis ​​preditoras. Criamos um subconjunto dessas variáveis ​​a partir do conjunto de dados mtcars para esse propósito.

input <- mtcars[,c("mpg","disp","hp","wt")]
print(head(input))

Quando executamos o código acima, ele produz o seguinte resultado -

mpg   disp   hp    wt
Mazda RX4          21.0  160    110   2.620
Mazda RX4 Wag      21.0  160    110   2.875
Datsun 710         22.8  108     93   2.320
Hornet 4 Drive     21.4  258    110   3.215
Hornet Sportabout  18.7  360    175   3.440
Valiant            18.1  225    105   3.460

Crie um modelo de relacionamento e obtenha os coeficientes

input <- mtcars[,c("mpg","disp","hp","wt")]

# Create the relationship model.
model <- lm(mpg~disp+hp+wt, data = input)

# Show the model.
print(model)

# Get the Intercept and coefficients as vector elements.
cat("# # # # The Coefficient Values # # # ","\n")

a <- coef(model)[1]
print(a)

Xdisp <- coef(model)[2]
Xhp <- coef(model)[3]
Xwt <- coef(model)[4]

print(Xdisp)
print(Xhp)
print(Xwt)

Quando executamos o código acima, ele produz o seguinte resultado -

Call:
lm(formula = mpg ~ disp + hp + wt, data = input)

Coefficients:
(Intercept)         disp           hp           wt  
  37.105505      -0.000937        -0.031157    -3.800891  

# # # # The Coefficient Values # # # 
(Intercept) 
   37.10551 
         disp 
-0.0009370091 
         hp 
-0.03115655 
       wt 
-3.800891

Criar Equação para Modelo de Regressão

Com base nos valores de interceptação e coeficiente acima, criamos a equação matemática.

Y = a+Xdisp.x1+Xhp.x2+Xwt.x3
or
Y = 37.15+(-0.000937)*x1+(-0.0311)*x2+(-3.8008)*x3

Aplicar equação para prever novos valores

Podemos usar a equação de regressão criada acima para prever a quilometragem quando um novo conjunto de valores para deslocamento, cavalos de potência e peso é fornecido.

Para um carro com disp = 221, hp = 102 e wt = 2,91, a quilometragem prevista é -

Y = 37.15+(-0.000937)*221+(-0.0311)*102+(-3.8008)*2.91 = 22.7104

A Regressão Logística é um modelo de regressão no qual a variável de resposta (variável dependente) possui valores categóricos, como Verdadeiro / Falso ou 0/1. Na verdade, mede a probabilidade de uma resposta binária como o valor da variável de resposta com base na equação matemática relacionando-a com as variáveis ​​preditoras.

A equação matemática geral para regressão logística é -

y = 1/(1+e^-(a+b1x1+b2x2+b3x3+...))

A seguir está a descrição dos parâmetros usados ​​-

  • y é a variável de resposta.

  • x é a variável preditora.

  • a e b são os coeficientes que são constantes numéricas.

A função usada para criar o modelo de regressão é o glm() função.

Sintaxe

A sintaxe básica para glm() função na regressão logística é -

glm(formula,data,family)

A seguir está a descrição dos parâmetros usados ​​-

  • formula é o símbolo que apresenta a relação entre as variáveis.

  • data é o conjunto de dados que fornece os valores dessas variáveis.

  • familyé o objeto R para especificar os detalhes do modelo. Seu valor é binomial para regressão logística.

Exemplo

O conjunto de dados integrado "mtcars" descreve diferentes modelos de um carro com suas várias especificações de motor. No conjunto de dados "mtcars", o modo de transmissão (automático ou manual) é descrito pela coluna am, que é um valor binário (0 ou 1). Podemos criar um modelo de regressão logística entre as colunas "am" e 3 outras colunas - hp, wt e cyl.

# Select some columns form mtcars.
input <- mtcars[,c("am","cyl","hp","wt")]

print(head(input))

Quando executamos o código acima, ele produz o seguinte resultado -

am   cyl  hp    wt
Mazda RX4          1   6    110   2.620
Mazda RX4 Wag      1   6    110   2.875
Datsun 710         1   4     93   2.320
Hornet 4 Drive     0   6    110   3.215
Hornet Sportabout  0   8    175   3.440
Valiant            0   6    105   3.460

Criar modelo de regressão

Nós usamos o glm() função para criar o modelo de regressão e obter seu resumo para análise.

input <- mtcars[,c("am","cyl","hp","wt")]

am.data = glm(formula = am ~ cyl + hp + wt, data = input, family = binomial)

print(summary(am.data))

Quando executamos o código acima, ele produz o seguinte resultado -

Call:
glm(formula = am ~ cyl + hp + wt, family = binomial, data = input)

Deviance Residuals: 
     Min        1Q      Median        3Q       Max  
-2.17272     -0.14907  -0.01464     0.14116   1.27641  

Coefficients:
            Estimate Std. Error z value Pr(>|z|)  
(Intercept) 19.70288    8.11637   2.428   0.0152 *
cyl          0.48760    1.07162   0.455   0.6491  
hp           0.03259    0.01886   1.728   0.0840 .
wt          -9.14947    4.15332  -2.203   0.0276 *
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1

(Dispersion parameter for binomial family taken to be 1)

    Null deviance: 43.2297  on 31  degrees of freedom
Residual deviance:  9.8415  on 28  degrees of freedom
AIC: 17.841

Number of Fisher Scoring iterations: 8

Conclusão

No resumo, como o valor de p na última coluna é maior que 0,05 para as variáveis ​​"cil" e "hp", consideramos que são insignificantes na contribuição para o valor da variável "am". Apenas o peso (peso) impacta o valor "am" neste modelo de regressão.

Em uma coleta aleatória de dados de fontes independentes, geralmente observa-se que a distribuição dos dados é normal. Ou seja, ao traçar um gráfico com o valor da variável no eixo horizontal e a contagem dos valores no eixo vertical, obtemos uma curva em forma de sino. O centro da curva representa a média do conjunto de dados. No gráfico, cinquenta por cento dos valores ficam à esquerda da média e os outros cinquenta por cento ficam à direita do gráfico. Isso é conhecido como distribuição normal nas estatísticas.

R tem quatro funções integradas para gerar distribuição normal. Eles são descritos a seguir.

dnorm(x, mean, sd)
pnorm(x, mean, sd)
qnorm(p, mean, sd)
rnorm(n, mean, sd)

A seguir está a descrição dos parâmetros usados ​​nas funções acima -

  • x é um vetor de números.

  • p é um vetor de probabilidades.

  • n é o número de observações (tamanho da amostra).

  • meané o valor médio dos dados da amostra. Seu valor padrão é zero.

  • sdé o desvio padrão. Seu valor padrão é 1.

dnorm ()

Esta função fornece a altura da distribuição de probabilidade em cada ponto para uma determinada média e desvio padrão.

# Create a sequence of numbers between -10 and 10 incrementing by 0.1.
x <- seq(-10, 10, by = .1)

# Choose the mean as 2.5 and standard deviation as 0.5.
y <- dnorm(x, mean = 2.5, sd = 0.5)

# Give the chart file a name.
png(file = "dnorm.png")

plot(x,y)

# Save the file.
dev.off()

Quando executamos o código acima, ele produz o seguinte resultado -

pnorm ()

Essa função fornece a probabilidade de um número aleatório normalmente distribuído ser menor que o valor de um determinado número. Também é chamada de "Função de distribuição cumulativa".

# Create a sequence of numbers between -10 and 10 incrementing by 0.2.
x <- seq(-10,10,by = .2)
 
# Choose the mean as 2.5 and standard deviation as 2. 
y <- pnorm(x, mean = 2.5, sd = 2)

# Give the chart file a name.
png(file = "pnorm.png")

# Plot the graph.
plot(x,y)

# Save the file.
dev.off()

Quando executamos o código acima, ele produz o seguinte resultado -

qnorm ()

Esta função obtém o valor da probabilidade e fornece um número cujo valor cumulativo corresponde ao valor da probabilidade.

# Create a sequence of probability values incrementing by 0.02.
x <- seq(0, 1, by = 0.02)

# Choose the mean as 2 and standard deviation as 3.
y <- qnorm(x, mean = 2, sd = 1)

# Give the chart file a name.
png(file = "qnorm.png")

# Plot the graph.
plot(x,y)

# Save the file.
dev.off()

Quando executamos o código acima, ele produz o seguinte resultado -

rnorm ()

Esta função é usada para gerar números aleatórios cuja distribuição é normal. Ele pega o tamanho da amostra como entrada e gera muitos números aleatórios. Desenhamos um histograma para mostrar a distribuição dos números gerados.

# Create a sample of 50 numbers which are normally distributed.
y <- rnorm(50)

# Give the chart file a name.
png(file = "rnorm.png")

# Plot the histogram for this sample.
hist(y, main = "Normal DIstribution")

# Save the file.
dev.off()

Quando executamos o código acima, ele produz o seguinte resultado -

O modelo de distribuição binomial trata de encontrar a probabilidade de sucesso de um evento que tem apenas dois resultados possíveis em uma série de experimentos. Por exemplo, o lançamento de uma moeda sempre dá cara ou coroa. A probabilidade de encontrar exatamente 3 caras ao jogar uma moeda repetidamente por 10 vezes é estimada durante a distribuição binomial.

R tem quatro funções embutidas para gerar distribuição binomial. Eles são descritos a seguir.

dbinom(x, size, prob)
pbinom(x, size, prob)
qbinom(p, size, prob)
rbinom(n, size, prob)

A seguir está a descrição dos parâmetros usados ​​-

  • x é um vetor de números.

  • p é um vetor de probabilidades.

  • n é o número de observações.

  • size é o número de tentativas.

  • prob é a probabilidade de sucesso de cada tentativa.

dbinom ()

Esta função fornece a distribuição de densidade de probabilidade em cada ponto.

# Create a sample of 50 numbers which are incremented by 1.
x <- seq(0,50,by = 1)

# Create the binomial distribution.
y <- dbinom(x,50,0.5)

# Give the chart file a name.
png(file = "dbinom.png")

# Plot the graph for this sample.
plot(x,y)

# Save the file.
dev.off()

Quando executamos o código acima, ele produz o seguinte resultado -

pbinom ()

Esta função fornece a probabilidade cumulativa de um evento. É um único valor que representa a probabilidade.

# Probability of getting 26 or less heads from a 51 tosses of a coin.
x <- pbinom(26,51,0.5)

print(x)

Quando executamos o código acima, ele produz o seguinte resultado -

[1] 0.610116

qbinom ()

Esta função obtém o valor da probabilidade e fornece um número cujo valor cumulativo corresponde ao valor da probabilidade.

# How many heads will have a probability of 0.25 will come out when a coin
# is tossed 51 times.
x <- qbinom(0.25,51,1/2)

print(x)

Quando executamos o código acima, ele produz o seguinte resultado -

[1] 23

rbinom ()

Essa função gera o número necessário de valores aleatórios de determinada probabilidade de uma determinada amostra.

# Find 8 random values from a sample of 150 with probability of 0.4.
x <- rbinom(8,150,.4)

print(x)

Quando executamos o código acima, ele produz o seguinte resultado -

[1] 58 61 59 66 55 60 61 67

A regressão de Poisson envolve modelos de regressão nos quais a variável de resposta está na forma de contagens e não de números fracionários. Por exemplo, a contagem do número de nascimentos ou de vitórias em uma série de partidas de futebol. Além disso, os valores das variáveis ​​de resposta seguem uma distribuição de Poisson.

A equação matemática geral para regressão de Poisson é -

log(y) = a + b1x1 + b2x2 + bnxn.....

A seguir está a descrição dos parâmetros usados ​​-

  • y é a variável de resposta.

  • a e b são os coeficientes numéricos.

  • x é a variável preditora.

A função usada para criar o modelo de regressão de Poisson é o glm() função.

Sintaxe

A sintaxe básica para glm() função na regressão de Poisson é -

glm(formula,data,family)

A seguir está a descrição dos parâmetros usados ​​nas funções acima -

  • formula é o símbolo que apresenta a relação entre as variáveis.

  • data é o conjunto de dados que fornece os valores dessas variáveis.

  • familyé o objeto R para especificar os detalhes do modelo. Seu valor é 'Poisson' para Regressão Logística.

Exemplo

Temos o conjunto de dados embutido "quebra de urdidura" que descreve o efeito do tipo de lã (A ou B) e tensão (baixa, média ou alta) no número de quebras de urdidura por tear. Vamos considerar "quebras" como a variável de resposta que é uma contagem do número de quebras. O "tipo" e a "tensão" da lã são considerados variáveis ​​de previsão.

Input Data

input <- warpbreaks
print(head(input))

Quando executamos o código acima, ele produz o seguinte resultado -

breaks   wool  tension
1     26       A     L
2     30       A     L
3     54       A     L
4     25       A     L
5     70       A     L
6     52       A     L

Criar modelo de regressão

output <-glm(formula = breaks ~ wool+tension, data = warpbreaks,
   family = poisson)
print(summary(output))

Quando executamos o código acima, ele produz o seguinte resultado -

Call:
glm(formula = breaks ~ wool + tension, family = poisson, data = warpbreaks)

Deviance Residuals: 
    Min       1Q     Median       3Q      Max  
  -3.6871  -1.6503  -0.4269     1.1902   4.2616  

Coefficients:
            Estimate Std. Error z value Pr(>|z|)    
(Intercept)  3.69196    0.04541  81.302  < 2e-16 ***
woolB       -0.20599    0.05157  -3.994 6.49e-05 ***
tensionM    -0.32132    0.06027  -5.332 9.73e-08 ***
tensionH    -0.51849    0.06396  -8.107 5.21e-16 ***
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1

(Dispersion parameter for poisson family taken to be 1)

    Null deviance: 297.37  on 53  degrees of freedom
Residual deviance: 210.39  on 50  degrees of freedom
AIC: 493.06

Number of Fisher Scoring iterations: 4

No resumo, procuramos que o valor p na última coluna seja inferior a 0,05 para considerar um impacto da variável preditora na variável de resposta. Como visto, o tipo lã B com tensão do tipo M e H tem impacto na contagem de quebras.

Usamos a análise de regressão para criar modelos que descrevem o efeito da variação nas variáveis ​​preditoras na variável de resposta. Às vezes, se tivermos uma variável categórica com valores como Sim / Não ou Masculino / Feminino etc. A análise de regressão simples fornece vários resultados para cada valor da variável categórica. Nesse cenário, podemos estudar o efeito da variável categórica usando-a junto com a variável preditora e comparando as linhas de regressão para cada nível da variável categórica. Essa análise é denominada comoAnalysis of Covariance também chamado de ANCOVA.

Exemplo

Considere o R construído em mtcars de conjunto de dados. Nele observamos que o campo "am" representa o tipo de transmissão (automática ou manual). É uma variável categórica com valores 0 e 1. O valor de milhas por galão (mpg) de um carro também pode depender dele além do valor dos cavalos de força ("hp").

Estudamos o efeito do valor de "am" na regressão entre "mpg" e "hp". Isso é feito usando oaov() função seguida por anova() função para comparar as regressões múltiplas.

Dados de entrada

Crie um quadro de dados contendo os campos "mpg", "hp" e "am" do conjunto de dados mtcars. Aqui, consideramos "mpg" como a variável de resposta, "hp" como a variável preditora e "am" como a variável categórica.

input <- mtcars[,c("am","mpg","hp")]
print(head(input))

Quando executamos o código acima, ele produz o seguinte resultado -

am   mpg   hp
Mazda RX4          1    21.0  110
Mazda RX4 Wag      1    21.0  110
Datsun 710         1    22.8   93
Hornet 4 Drive     0    21.4  110
Hornet Sportabout  0    18.7  175
Valiant            0    18.1  105

Análise ANCOVA

Criamos um modelo de regressão tendo "hp" como variável preditora e "mpg" como variável de resposta levando em consideração a interação entre "am" e "hp".

Modelo com interação entre variável categórica e variável preditora

# Get the dataset.
input <- mtcars

# Create the regression model.
result <- aov(mpg~hp*am,data = input)
print(summary(result))

Quando executamos o código acima, ele produz o seguinte resultado -

Df Sum Sq Mean Sq F value   Pr(>F)    
hp           1  678.4   678.4  77.391 1.50e-09 ***
am           1  202.2   202.2  23.072 4.75e-05 ***
hp:am        1    0.0     0.0   0.001    0.981    
Residuals   28  245.4     8.8                     
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1

Este resultado mostra que os cavalos de potência e o tipo de transmissão têm efeito significativo nas milhas por galão, pois o valor de p em ambos os casos é inferior a 0,05. Mas a interação entre essas duas variáveis ​​não é significativa, pois o valor p é maior que 0,05.

Modelo sem interação entre variável categórica e variável preditora

# Get the dataset.
input <- mtcars

# Create the regression model.
result <- aov(mpg~hp+am,data = input)
print(summary(result))

Quando executamos o código acima, ele produz o seguinte resultado -

Df  Sum Sq  Mean Sq   F value   Pr(>F)    
hp           1  678.4   678.4   80.15 7.63e-10 ***
am           1  202.2   202.2   23.89 3.46e-05 ***
Residuals   29  245.4     8.5                     
---
Signif. codes:  0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ’ 1

Este resultado mostra que os cavalos de potência e o tipo de transmissão têm efeito significativo nas milhas por galão, pois o valor de p em ambos os casos é inferior a 0,05.

Comparando Dois Modelos

Agora podemos comparar os dois modelos para concluir se a interação das variáveis ​​é realmente in-significativa. Para isso usamos oanova() função.

# Get the dataset.
input <- mtcars

# Create the regression models.
result1 <- aov(mpg~hp*am,data = input)
result2 <- aov(mpg~hp+am,data = input)

# Compare the two models.
print(anova(result1,result2))

Quando executamos o código acima, ele produz o seguinte resultado -

Model 1: mpg ~ hp * am
Model 2: mpg ~ hp + am
  Res.Df    RSS Df  Sum of Sq     F Pr(>F)
1     28 245.43                           
2     29 245.44 -1 -0.0052515 6e-04 0.9806

Como o valor p é maior que 0,05, concluímos que a interação entre os cavalos de potência e o tipo de transmissão não é significativa. Portanto, a quilometragem por galão dependerá de maneira semelhante dos cavalos de potência do carro, tanto no modo de transmissão automática quanto manual.

A série temporal é uma série de pontos de dados em que cada ponto de dados está associado a um carimbo de data / hora. Um exemplo simples é o preço de uma ação no mercado de ações em diferentes pontos do tempo em um determinado dia. Outro exemplo é a quantidade de chuvas em uma região em diferentes meses do ano. A linguagem R usa muitas funções para criar, manipular e plotar os dados da série temporal. Os dados da série temporal são armazenados em um objeto R chamadotime-series object. Também é um objeto de dados R como um vetor ou quadro de dados.

O objeto de série temporal é criado usando o ts() função.

Sintaxe

A sintaxe básica para ts() função na análise de série temporal é -

timeseries.object.name <-  ts(data, start, end, frequency)

A seguir está a descrição dos parâmetros usados ​​-

  • data é um vetor ou matriz que contém os valores usados ​​na série temporal.

  • start especifica a hora de início da primeira observação na série temporal.

  • end especifica a hora de término da última observação na série temporal.

  • frequency especifica o número de observações por unidade de tempo.

Exceto o parâmetro "dados", todos os outros parâmetros são opcionais.

Exemplo

Considere os detalhes da precipitação anual em um local a partir de janeiro de 2012. Criamos um objeto de série temporal R por um período de 12 meses e o plotamos.

# Get the data points in form of a R vector.
rainfall <- c(799,1174.8,865.1,1334.6,635.4,918.5,685.5,998.6,784.2,985,882.8,1071)

# Convert it to a time series object.
rainfall.timeseries <- ts(rainfall,start = c(2012,1),frequency = 12)

# Print the timeseries data.
print(rainfall.timeseries)

# Give the chart file a name.
png(file = "rainfall.png")

# Plot a graph of the time series.
plot(rainfall.timeseries)

# Save the file.
dev.off()

Quando executamos o código acima, ele produz o seguinte resultado e gráfico -

Jan    Feb    Mar    Apr    May     Jun    Jul    Aug    Sep
2012  799.0  1174.8  865.1  1334.6  635.4  918.5  685.5  998.6  784.2
        Oct    Nov    Dec
2012  985.0  882.8 1071.0

O gráfico de série temporal -

Diferentes intervalos de tempo

O valor do frequencyparâmetro na função ts () decide os intervalos de tempo nos quais os pontos de dados são medidos. Um valor de 12 indica que a série temporal é de 12 meses. Outros valores e seu significado são os seguintes -

  • frequency = 12 rastreia os pontos de dados para cada mês do ano.

  • frequency = 4 rastreia os pontos de dados para cada trimestre de um ano.

  • frequency = 6 rastreia os pontos de dados a cada 10 minutos de uma hora.

  • frequency = 24*6 rastreia os pontos de dados a cada 10 minutos de um dia.

Várias Séries Temporais

Podemos plotar várias séries temporais em um gráfico, combinando ambas as séries em uma matriz.

# Get the data points in form of a R vector.
rainfall1 <- c(799,1174.8,865.1,1334.6,635.4,918.5,685.5,998.6,784.2,985,882.8,1071)
rainfall2 <- 
           c(655,1306.9,1323.4,1172.2,562.2,824,822.4,1265.5,799.6,1105.6,1106.7,1337.8)

# Convert them to a matrix.
combined.rainfall <-  matrix(c(rainfall1,rainfall2),nrow = 12)

# Convert it to a time series object.
rainfall.timeseries <- ts(combined.rainfall,start = c(2012,1),frequency = 12)

# Print the timeseries data.
print(rainfall.timeseries)

# Give the chart file a name.
png(file = "rainfall_combined.png")

# Plot a graph of the time series.
plot(rainfall.timeseries, main = "Multiple Time Series")

# Save the file.
dev.off()

Quando executamos o código acima, ele produz o seguinte resultado e gráfico -

Series 1  Series 2
Jan 2012    799.0    655.0
Feb 2012   1174.8   1306.9
Mar 2012    865.1   1323.4
Apr 2012   1334.6   1172.2
May 2012    635.4    562.2
Jun 2012    918.5    824.0
Jul 2012    685.5    822.4
Aug 2012    998.6   1265.5
Sep 2012    784.2    799.6
Oct 2012    985.0   1105.6
Nov 2012    882.8   1106.7
Dec 2012   1071.0   1337.8

O gráfico de várias séries temporais -

Ao modelar dados do mundo real para análise de regressão, observamos que raramente é o caso em que a equação do modelo é uma equação linear fornecendo um gráfico linear. Na maioria das vezes, a equação do modelo de dados do mundo real envolve funções matemáticas de alto grau, como um expoente de 3 ou uma função de pecado. Nesse cenário, o gráfico do modelo fornece uma curva em vez de uma linha. O objetivo da regressão linear e não linear é ajustar os valores dos parâmetros do modelo para encontrar a linha ou curva que mais se aproxima de seus dados. Ao encontrar esses valores, seremos capazes de estimar a variável de resposta com boa precisão.

Na regressão de Mínimos Quadrados, estabelecemos um modelo de regressão no qual a soma dos quadrados das distâncias verticais de diferentes pontos da curva de regressão é minimizada. Geralmente começamos com um modelo definido e assumimos alguns valores para os coeficientes. Em seguida, aplicamos onls() função de R para obter os valores mais precisos junto com os intervalos de confiança.

Sintaxe

A sintaxe básica para criar um teste de mínimos quadrados não linear em R é -

nls(formula, data, start)

A seguir está a descrição dos parâmetros usados ​​-

  • formula é uma fórmula de modelo não linear que inclui variáveis ​​e parâmetros.

  • data é um quadro de dados usado para avaliar as variáveis ​​na fórmula.

  • start é uma lista nomeada ou vetor numérico nomeado de estimativas iniciais.

Exemplo

Vamos considerar um modelo não linear com suposição de valores iniciais de seus coeficientes. A seguir, veremos quais são os intervalos de confiança desses valores assumidos para que possamos avaliar o quão bem esses valores se encaixam no modelo.

Então, vamos considerar a equação abaixo para este propósito -

a = b1*x^2+b2

Vamos supor que os coeficientes iniciais sejam 1 e 3 e ajustar esses valores na função nls ().

xvalues <- c(1.6,2.1,2,2.23,3.71,3.25,3.4,3.86,1.19,2.21)
yvalues <- c(5.19,7.43,6.94,8.11,18.75,14.88,16.06,19.12,3.21,7.58)

# Give the chart file a name.
png(file = "nls.png")


# Plot these values.
plot(xvalues,yvalues)


# Take the assumed values and fit into the model.
model <- nls(yvalues ~ b1*xvalues^2+b2,start = list(b1 = 1,b2 = 3))

# Plot the chart with new data by fitting it to a prediction from 100 data points.
new.data <- data.frame(xvalues = seq(min(xvalues),max(xvalues),len = 100))
lines(new.data$xvalues,predict(model,newdata = new.data))

# Save the file.
dev.off()

# Get the sum of the squared residuals.
print(sum(resid(model)^2))

# Get the confidence intervals on the chosen values of the coefficients.
print(confint(model))

Quando executamos o código acima, ele produz o seguinte resultado -

[1] 1.081935
Waiting for profiling to be done...
       2.5%    97.5%
b1 1.137708 1.253135
b2 1.497364 2.496484

Podemos concluir que o valor de b1 está mais próximo de 1 enquanto o valor de b2 está mais próximo de 2 e não de 3.

A árvore de decisão é um gráfico que representa as escolhas e seus resultados na forma de uma árvore. Os nós no gráfico representam um evento ou escolha e as arestas do gráfico representam as regras ou condições de decisão. É usado principalmente em aplicativos de aprendizado de máquina e mineração de dados usando R.

Exemplos de uso de tress de decisão são - prever um email como spam ou não spam, prever que um tumor é canceroso ou prever um empréstimo como um risco de crédito bom ou ruim com base nos fatores de cada um deles. Geralmente, um modelo é criado com dados observados, também chamados de dados de treinamento. Em seguida, um conjunto de dados de validação é usado para verificar e melhorar o modelo. R tem pacotes que são usados ​​para criar e visualizar árvores de decisão. Para um novo conjunto de variável preditora, usamos este modelo para chegar a uma decisão sobre a categoria (sim / Não, spam / não spam) dos dados.

O pacote R "party" é usado para criar árvores de decisão.

Instale o pacote R

Use o comando abaixo no console R para instalar o pacote. Você também deve instalar os pacotes dependentes, se houver.

install.packages("party")

O pacote "festa" tem a função ctree() que é usado para criar e analisar a árvore de decisão.

Sintaxe

A sintaxe básica para criar uma árvore de decisão em R é -

ctree(formula, data)

A seguir está a descrição dos parâmetros usados ​​-

  • formula é uma fórmula que descreve o preditor e as variáveis ​​de resposta.

  • data é o nome do conjunto de dados usado.

Dados de entrada

Usaremos o conjunto de dados embutido do R denominado readingSkillspara criar uma árvore de decisão. Descreve a pontuação das habilidades de leitura de alguém se conhecermos as variáveis ​​"idade", "tamanho do calçado", "pontuação" e se a pessoa é falante nativo ou não.

Aqui estão os dados de amostra.

# Load the party package. It will automatically load other
# dependent packages.
library(party)

# Print some records from data set readingSkills.
print(head(readingSkills))

Quando executamos o código acima, ele produz o seguinte resultado e gráfico -

nativeSpeaker   age   shoeSize      score
1           yes     5   24.83189   32.29385
2           yes     6   25.95238   36.63105
3            no    11   30.42170   49.60593
4           yes     7   28.66450   40.28456
5           yes    11   31.88207   55.46085
6           yes    10   30.07843   52.83124
Loading required package: methods
Loading required package: grid
...............................
...............................

Exemplo

Vamos usar o ctree() função para criar a árvore de decisão e ver seu gráfico.

# Load the party package. It will automatically load other
# dependent packages.
library(party)

# Create the input data frame.
input.dat <- readingSkills[c(1:105),]

# Give the chart file a name.
png(file = "decision_tree.png")

# Create the tree.
  output.tree <- ctree(
  nativeSpeaker ~ age + shoeSize + score, 
  data = input.dat)

# Plot the tree.
plot(output.tree)

# Save the file.
dev.off()

Quando executamos o código acima, ele produz o seguinte resultado -

null device 
          1 
Loading required package: methods
Loading required package: grid
Loading required package: mvtnorm
Loading required package: modeltools
Loading required package: stats4
Loading required package: strucchange
Loading required package: zoo

Attaching package: ‘zoo’

The following objects are masked from ‘package:base’:

   as.Date, as.Date.numeric

Loading required package: sandwich

Conclusão

A partir da árvore de decisão mostrada acima, podemos concluir que qualquer pessoa cuja pontuação em habilidades de leitura seja inferior a 38,3 e a idade seja superior a 6 não é um falante nativo.

Na abordagem de floresta aleatória, um grande número de árvores de decisão é criado. Cada observação é inserida em cada árvore de decisão. O resultado mais comum para cada observação é usado como resultado final. Uma nova observação é inserida em todas as árvores e obtendo uma votação majoritária para cada modelo de classificação.

Uma estimativa de erro é feita para os casos que não foram usados ​​durante a construção da árvore. Isso é chamado deOOB (Out-of-bag) estimativa de erro que é mencionada como uma porcentagem.

O pacote R "randomForest" é usado para criar florestas aleatórias.

Instale o pacote R

Use o comando abaixo no console R para instalar o pacote. Você também deve instalar os pacotes dependentes, se houver.

install.packages("randomForest)

O pacote "randomForest" tem a função randomForest() que é usado para criar e analisar florestas aleatórias.

Sintaxe

A sintaxe básica para criar uma floresta aleatória em R é -

randomForest(formula, data)

A seguir está a descrição dos parâmetros usados ​​-

  • formula é uma fórmula que descreve o preditor e as variáveis ​​de resposta.

  • data é o nome do conjunto de dados usado.

Dados de entrada

Usaremos o conjunto de dados embutido do R denominado readingSkills para criar uma árvore de decisão. Descreve a pontuação das habilidades de leitura de alguém se conhecermos as variáveis ​​"idade", "tamanho do calçado", "pontuação" e se a pessoa é falante nativo.

Aqui estão os dados de amostra.

# Load the party package. It will automatically load other
# required packages.
library(party)

# Print some records from data set readingSkills.
print(head(readingSkills))

Quando executamos o código acima, ele produz o seguinte resultado e gráfico -

nativeSpeaker   age   shoeSize      score
1           yes     5   24.83189   32.29385
2           yes     6   25.95238   36.63105
3            no    11   30.42170   49.60593
4           yes     7   28.66450   40.28456
5           yes    11   31.88207   55.46085
6           yes    10   30.07843   52.83124
Loading required package: methods
Loading required package: grid
...............................
...............................

Exemplo

Vamos usar o randomForest() função para criar a árvore de decisão e ver seu gráfico.

# Load the party package. It will automatically load other
# required packages.
library(party)
library(randomForest)

# Create the forest.
output.forest <- randomForest(nativeSpeaker ~ age + shoeSize + score, 
           data = readingSkills)

# View the forest results.
print(output.forest) 

# Importance of each predictor.
print(importance(fit,type = 2))

Quando executamos o código acima, ele produz o seguinte resultado -

Call:
 randomForest(formula = nativeSpeaker ~ age + shoeSize + score,     
                 data = readingSkills)
               Type of random forest: classification
                     Number of trees: 500
No. of variables tried at each split: 1

        OOB estimate of  error rate: 1%
Confusion matrix:
    no yes class.error
no  99   1        0.01
yes  1  99        0.01
         MeanDecreaseGini
age              13.95406
shoeSize         18.91006
score            56.73051

Conclusão

Da floresta aleatória mostrada acima, podemos concluir que o tamanho do calçado e a pontuação são os fatores importantes para decidir se alguém é falante nativo ou não. Além disso, o modelo tem apenas 1% de erro, o que significa que podemos prever com 99% de precisão.

A análise de sobrevivência trata de prever o momento em que um evento específico irá ocorrer. Também é conhecido como análise do tempo de falha ou análise do tempo até a morte. Por exemplo, prever o número de dias que uma pessoa com câncer sobreviverá ou quando um sistema mecânico irá falhar.

O pacote R denominado survivalé usado para realizar análises de sobrevivência. Este pacote contém a funçãoSurv()que pega os dados de entrada como uma fórmula R e cria um objeto de sobrevivência entre as variáveis ​​escolhidas para análise. Então usamos a funçãosurvfit() para criar um gráfico para a análise.

Pacote de instalação

install.packages("survival")

Sintaxe

A sintaxe básica para a criação de análise de sobrevivência em R é -

Surv(time,event)
survfit(formula)

A seguir está a descrição dos parâmetros usados ​​-

  • time é o tempo de acompanhamento até que o evento ocorra.

  • event indica o status de ocorrência do evento esperado.

  • formula é a relação entre as variáveis ​​preditoras.

Exemplo

Vamos considerar o conjunto de dados denominado "pbc" presente nos pacotes de sobrevivência instalados acima. Ele descreve os pontos de dados de sobrevivência sobre pessoas afetadas com cirrose biliar primária (PBC) do fígado. Entre as muitas colunas presentes no conjunto de dados, estamos principalmente preocupados com os campos "hora" e "status". O tempo representa o número de dias entre o registro do paciente e antes do evento entre o paciente que recebe um transplante de fígado ou a morte do paciente.

# Load the library.
library("survival")

# Print first few rows.
print(head(pbc))

Quando executamos o código acima, ele produz o seguinte resultado e gráfico -

id time status trt      age sex ascites hepato spiders edema bili chol
1  1  400      2   1 58.76523   f       1      1       1   1.0 14.5  261
2  2 4500      0   1 56.44627   f       0      1       1   0.0  1.1  302
3  3 1012      2   1 70.07255   m       0      0       0   0.5  1.4  176
4  4 1925      2   1 54.74059   f       0      1       1   0.5  1.8  244
5  5 1504      1   2 38.10541   f       0      1       1   0.0  3.4  279
6  6 2503      2   2 66.25873   f       0      1       0   0.0  0.8  248
  albumin copper alk.phos    ast trig platelet protime stage
1    2.60    156   1718.0 137.95  172      190    12.2     4
2    4.14     54   7394.8 113.52   88      221    10.6     3
3    3.48    210    516.0  96.10   55      151    12.0     4
4    2.54     64   6121.8  60.63   92      183    10.3     4
5    3.53    143    671.0 113.15   72      136    10.9     3
6    3.98     50    944.0  93.00   63       NA    11.0     3

Com base nos dados acima, estamos considerando o tempo e o status de nossa análise.

Aplicando as funções Surv () e survfit ()

Agora passamos a aplicar o Surv() função para o conjunto de dados acima e crie um gráfico que mostrará a tendência.

# Load the library.
library("survival")

# Create the survival object. 
survfit(Surv(pbc$time,pbc$status == 2)~1) # Give the chart file a name. png(file = "survival.png") # Plot the graph. plot(survfit(Surv(pbc$time,pbc$status == 2)~1))

# Save the file.
dev.off()

Quando executamos o código acima, ele produz o seguinte resultado e gráfico -

Call: survfit(formula = Surv(pbc$time, pbc$status == 2) ~ 1)

      n  events  median 0.95LCL 0.95UCL 
    418     161    3395    3090    3853

A tendência no gráfico acima nos ajuda a prever a probabilidade de sobrevivência ao final de um determinado número de dias.

Chi-Square testé um método estatístico para determinar se duas variáveis ​​categóricas têm uma correlação significativa entre elas. Ambas as variáveis ​​devem ser da mesma população e devem ser categóricas, como - Sim / Não, Masculino / Feminino, Vermelho / Verde etc.

Por exemplo, podemos construir um conjunto de dados com observações sobre o padrão de compra de sorvete das pessoas e tentar correlacionar o gênero de uma pessoa com o sabor do sorvete de sua preferência. Se uma correlação for encontrada, podemos planejar um estoque apropriado de sabores, sabendo o número de gênero das pessoas que os visitam.

Sintaxe

A função usada para realizar o teste qui-quadrado é chisq.test().

A sintaxe básica para criar um teste qui-quadrado em R é -

chisq.test(data)

A seguir está a descrição dos parâmetros usados ​​-

  • data são os dados em forma de tabela contendo o valor de contagem das variáveis ​​da observação.

Exemplo

Levaremos os dados do Cars93 na biblioteca "MASSA" que representa as vendas de diferentes modelos de automóveis no ano de 1993.

library("MASS")
print(str(Cars93))

Quando executamos o código acima, ele produz o seguinte resultado -

'data.frame':   93 obs. of  27 variables: 
 $ Manufacturer      : Factor w/ 32 levels "Acura","Audi",..: 1 1 2 2 3 4 4 4 4 5 ... 
 $ Model : Factor w/ 93 levels "100","190E","240",..: 49 56 9 1 6 24 54 74 73 35 ... $ Type              : Factor w/ 6 levels "Compact","Large",..: 4 3 1 3 3 3 2 2 3 2 ... 
 $ Min.Price : num 12.9 29.2 25.9 30.8 23.7 14.2 19.9 22.6 26.3 33 ... $ Price             : num  15.9 33.9 29.1 37.7 30 15.7 20.8 23.7 26.3 34.7 ... 
 $ Max.Price : num 18.8 38.7 32.3 44.6 36.2 17.3 21.7 24.9 26.3 36.3 ... $ MPG.city          : int  25 18 20 19 22 22 19 16 19 16 ... 
 $ MPG.highway : int 31 25 26 26 30 31 28 25 27 25 ... $ AirBags           : Factor w/ 3 levels "Driver & Passenger",..: 3 1 2 1 2 2 2 2 2 2 ... 
 $ DriveTrain : Factor w/ 3 levels "4WD","Front",..: 2 2 2 2 3 2 2 3 2 2 ... $ Cylinders         : Factor w/ 6 levels "3","4","5","6",..: 2 4 4 4 2 2 4 4 4 5 ... 
 $ EngineSize : num 1.8 3.2 2.8 2.8 3.5 2.2 3.8 5.7 3.8 4.9 ... $ Horsepower        : int  140 200 172 172 208 110 170 180 170 200 ... 
 $ RPM : int 6300 5500 5500 5500 5700 5200 4800 4000 4800 4100 ... $ Rev.per.mile      : int  2890 2335 2280 2535 2545 2565 1570 1320 1690 1510 ... 
 $ Man.trans.avail : Factor w/ 2 levels "No","Yes": 2 2 2 2 2 1 1 1 1 1 ... $ Fuel.tank.capacity: num  13.2 18 16.9 21.1 21.1 16.4 18 23 18.8 18 ... 
 $ Passengers : int 5 5 5 6 4 6 6 6 5 6 ... $ Length            : int  177 195 180 193 186 189 200 216 198 206 ... 
 $ Wheelbase : int 102 115 102 106 109 105 111 116 108 114 ... $ Width             : int  68 71 67 70 69 69 74 78 73 73 ... 
 $ Turn.circle : int 37 38 37 37 39 41 42 45 41 43 ... $ Rear.seat.room    : num  26.5 30 28 31 27 28 30.5 30.5 26.5 35 ... 
 $ Luggage.room : int 11 15 14 17 13 16 17 21 14 18 ... $ Weight            : int  2705 3560 3375 3405 3640 2880 3470 4105 3495 3620 ... 
 $ Origin : Factor w/ 2 levels "USA","non-USA": 2 2 2 2 2 1 1 1 1 1 ... $ Make              : Factor w/ 93 levels "Acura Integra",..: 1 2 4 3 5 6 7 9 8 10 ...

O resultado acima mostra que o conjunto de dados tem muitas variáveis ​​de fator que podem ser consideradas como variáveis ​​categóricas. Para o nosso modelo, consideraremos as variáveis ​​"AirBags" e "Tipo". Pretendemos aqui descobrir qualquer correlação significativa entre os tipos de carro vendidos e o tipo de airbag que possui. Se a correlação for observada, podemos estimar quais tipos de carros podem vender melhor com quais tipos de air bag.

# Load the library.
library("MASS")

# Create a data frame from the main data set.
car.data <- data.frame(Cars93$AirBags, Cars93$Type)

# Create a table with the needed variables.
car.data = table(Cars93$AirBags, Cars93$Type) 
print(car.data)

# Perform the Chi-Square test.
print(chisq.test(car.data))

Quando executamos o código acima, ele produz o seguinte resultado -

Compact Large Midsize Small Sporty Van
  Driver & Passenger       2     4       7     0      3   0
  Driver only              9     7      11     5      8   3
  None                     5     0       4    16      3   6

         Pearson's Chi-squared test

data:  car.data
X-squared = 33.001, df = 10, p-value = 0.0002723

Warning message:
In chisq.test(car.data) : Chi-squared approximation may be incorrect

Conclusão

O resultado mostra o valor p inferior a 0,05, o que indica uma correlação de string.