Aprendizaje de maquinas -- R -- Redes Neuronales Artificiales

Notas de clase sobre aprendizaje de maquinas usando R

Juan David Velásquez Henao
jdvelasq@unal.edu.co
Universidad Nacional de Colombia, Sede Medellín
Facultad de Minas
Medellín, Colombia

[Licencia]

[Readme]

Software utilizado.

Este es un documento interactivo escrito como un notebook de Jupyter, en el cual se presenta un tutorial sobre regresión logistica usando R en el contexto de aprendizaje de maquinas. Los notebooks de Jupyter permiten incoporar simultáneamente código, texto, gráficos y ecuaciones. El código presentado en este notebook puede ejecutarse en los sistemas operativos Linux y OS X.

Haga click aquí para obtener instrucciones detalladas sobre como instalar Jupyter en Windows y Mac OS X.

Haga clic [aquí] para ver la última versión de este documento en nbviewer.

Descargue la última versión de este documento a su disco duro; luego, carguelo y ejecutelo en línea en Try Jupyter!

Haga clic aquí para ver el tutorial de visualización y gráficas.

Contenido

Bibliografía.

Material complementario.

Webinar RStudio Getting your data into R



In [ ]:

Introducción a las redes neuronales artificiales

Caracteristicas y propiedades del cerebro biológico

Contenido

Se reconoce que el cerebro humano "computa" en uan forma totalmente diferente a un computador convencional. Se caracteriza por ser altamente complejo, tener una respuesta no lineal y procesamiento en paralelo de la información.

Algunas de sus propiedades:

  • Es robusto y tolerante a fallos.
  • Es flexible (capacidad de aprendizaje en nuevas situaciones).
  • Puede manejar información difusa, probabilistica, ruidosa e inconsistente. Manejo inherente de la incertidumbre.
  • La máquina en que se ejecutan estas funciones es altamente paralela, pequeña, compacta y disipa una pequeña cantidad de energia.

Definición de una red neuronal.

Contenido

Una red neuronal es un procesador distribuido paralelamente masivo hecho de unidades simples de procesamiento el cual tiene propensión natural para almacenar conocimiento experimental y hacerlo disponible para su uso. Se asemeja al cerebro en dos aspectos:

  • El conocimiento es adquirido del ambiente a través de un algoritmo de aprendizaje.

  • Las resistencias de las conexiones interneuronales, conocidas como pesos sinápticos, son usadas para almacenar el conocimiento adquirido.

Capacidades y propiedades:

  • No linealidad.
  • Mapeo entrada-salida.
  • Adaptabilidad.
  • Respuesta evidencial.
  • Información contextual.
  • Tolerancia a los fallos.
  • Uniformidad de análisis y diseño.
  • Analogía neurobiológica.

Las redes neuronales pueden resolver problemas complejos que son intratables usando otras técnicas debido a sus capacidades de procesamiento de información:

  • Estructura distribuida masivamente paralela.
  • Capacidad de aprendizaje y generalización.

Neuronas y conexiones entre neuronas

  1. Las señales de entrada son recibidas por las dendritas.
  2. El impulso es ponderado de acuerdo a su importancia o frecuencia.
  3. A medida que el cuerpo de la celula se estimula, alcanza un umbral en el que una señal es disparada vía proceso electroquímico por el axón.
  4. En la terminal del axón, la señal eléctrica se transforma de nuevo en química para ser pasada a una neurona vecina por medio de sinapsis.

Modelos de la neurona

Contenido

Representación general

$$ u = f(x) = w_0 + \sum_{i=1}^nw_i x_i ,$$$$ a= \sigma (u) ,$$$$ y = g(a) = a $$

Modelo de la célula neuronal de McCulloch-Pitss

Contenido

Combinador Lineal Adaptativo ADALINE

Contenido

  • $w = [w_0,w_1,...,w_n]^T \in R^{n+1}$
  • $x= [x_0,x_1,...,x_n]^T \in R^{n+1}, x_0 = +1 $

Perceptrón Continuo

Contenido

El modelo suele representarse como:

  • Si $x_0 = +1$, se dice que la neurona es bias
  • Si $x_0 = -1$, se dice que la neurona es threshold

Funciones de activación

Contenido

La función de activación $\sigma(\cdot)$ mapea la entrada $[x_1,x_2,...,x_n] \in R^{n}$ al rango $[0,1]$ para señales unipolares y al rango $[-1,+1]$ para señales bipolares. Se asume que $\sigma() \in [-1,+1]$

Funciones de paso duro

Contenido

Funciones lineales y lineales por tramo

Contenido

Funciones sigmoideas

Contenido

Normalmente las funciones sigmoideas son las mas utilizadas en las redes neuronales.$\sigma(\cdot)$ es una función sigmoidal continua y diferenciable, tal que:

  • $\sigma(u)\longrightarrow \pm 1$ cuando $u \longrightarrow \pm \infty$
  • $\sigma(u) \in [-1,+1]$
  • $\sigma(u) = 0$ en un único punto $u=0$
  • $\sigma'(u) > 0$ y $\sigma'(\cdot) \longrightarrow 0$ cuando $u\longrightarrow \pm \infty $ (monótonamente creciente)
  • $\sigma'(u)$ tiene un máximo global > 0

Topología

Contenido

Tipos de arquitecturas de redes neuronales

Contenido

Número de nodos de la red

Contenido

Cuantos nodos se debe utilizar para las capas de la red:


In [2]:
## Instale y cargue las siguientes librerias

library(neuralnet)

In [3]:
## Red neuronal para calcular la raiz cuadrada de una número

## Generación números aleatorios distribuidos uniformemente entre 0 y 100
i1 <- as.data.frame(runif(50,             # 50 datos
                             min=0,       # Min = 0
                             max=100))    # Max = 100 


o1 <- sqrt(i1)                            # Raiz cuadrada de los valores de entrada

In [4]:
## Unificación de los datos en un dataframe

train <- cbind(i1,o1)
colnames(train) <- c("input","output")

head(train)


inputoutput
68.8683818.298698
28.9550325.380988
84.3718739.185416
96.5103479.823968
4.2742032.067414
48.2417406.945627

In [5]:
## Entrenamineto de la red neuronal con 'neuralnet'

arn <- neuralnet(output~input,           
                 train,                   # Conjunto de datos de entrenamiento
                 hidden=5,                # Neuronas oculta en cada capa
                 threshold=0.01)          # Criterio de parada

In [6]:
## Gráfica de la red neuronal
options(repr.plot.width=10, repr.plot.height=6)

plot(arn,                                 # Modelo neuronal
     rep="best",                          # Grafica de la repetición con menor error
     col.entry= "Red",                    # Color input
     col.hidden = "green",                # Color de las neuronas
     show.weights= T)                     # Mostrar valores de los pesos



In [7]:
## Test para la red neuronal

## Generación de datos de prueba
dtest <- as.data.frame (runif(10,0,100))

## Prueba del modelo neuronal 
test <- compute(arn,dtest)

In [8]:
## Resultados

result <- cbind(dtest,
                sqrt(dtest),
                as.data.frame(test$net.result))

colnames(result) <- c("Input","Salida Esperada","Salida red neuronal")

print(result)


          Input Salida Esperada Salida red neuronal
1   1.488598459     1.220081333         1.164920930
2  34.219848015     5.849773330         5.851089692
3   8.384445007     2.895590615         2.901704774
4  81.508395472     9.028200013         9.031682169
5  34.048752114     5.835130857         5.836570793
6  78.406556486     8.854747681         8.857126209
7  79.621955985     8.923113581         8.925946671
8  28.444179241     5.333308470         5.338686980
9  61.428571749     7.837638149         7.836899356
10 31.156185200     5.581772586         5.585388517

Ejercicio.-- Realice un modelo de red neuronal, para ajustar los siguientes datos y pruebe el modelo con los datos $x1$.

## Datos de entrada x<- c( 99.75,90.36,59.61,54.23,49.91, 77.95,14.40,23.44,95.04,99.66, 21.95,59.01,64.47,17.93,84.86, 87.02,27.05, 4.33,85.14,38.42, 90.99,52.04,32.45,72.78,78.36, 64.71,57.96,91.77,90.42, 6.15, 77.29,98.35, 0.18,84.21,82.26, 3.46,43.17,91.50, 6.31,96.03, 24.04,89.41, 5.98, 4.72,35.03, 29.87,61.96,53.36,47.50,29.76) ## Datos de salida y<- c( 7.65,7.02,4.97,4.62,4.33, 6.20,1.96,2.56,7.34,7.64, 2.46,4.93,5.30,2.20,6.66, 6.80,2.80,1.29,6.68,3.56, 7.07,4.47,3.16,5.85,6.22, 5.31,4.86,7.12,7.03,1.41, 6.15,7.56,1.01,6.61,6.48, 1.23,3.88,7.10,1.42,7.40, 2.60,6.96,1.40,1.31,3.34, 2.99,5.13,4.56,4.17,2.98)

In [ ]:

## Datos para prueba del modelo x1 <- c( 88.64,94.15,11.90,45.77,28.99, 62.48,74.07,81.69,88.32,62.38) ## Salida del modelo Input Salida esperada 88.64 6.91 94.15 7.28 11.90 1.79 45.77 4.05 28.99 2.93 62.48 5.17 74.07 5.94 81.69 6.45 88.32 6.89 62.38 5.16

In [ ]:



In [11]:
## Instale y cargue las siguientes librerías
library(quantmod) 
library(nnet)
library(caret)
library(reshape)

In [12]:
## Ajuste de una serie de tiempo con ANN

In [13]:
## Datos de la serie
y <- c( 15.81,15.34,15.20,15.40,15.93,16.01,
        15.73,15.35,15.15,15.37,15.53,15.82,
        15.83,15.80,15.60,15.33,15.37,15.47,
        15.50,15.60,15.59,15.55,15.52,15.47,
        15.44,15.50,15.71,15.58,15.51,15.52,
        15.66,15.65,15.58,15.53,15.45,15.60,
        15.79,15.80,15.74,15.58,15.30,15.24,
        15.35,15.57,15.67,15.64,15.45,15.40,
        15.43,15.74,15.89,15.79,15.54,15.51,
        15.46,15.46,15.68,15.68,15.54,15.40,
        15.39,15.50,15.68,15.69,15.52,15.55,
        15.55,15.53,15.53,15.61,15.62,15.56,
        15.43,15.41,15.52,15.58,15.65,15.47,
        15.42,15.35,15.44,15.56,15.58,15.57,
        15.35,15.47,15.48,15.50,15.45,15.43,
        15.73,15.81,15.51,15.15,15.26,15.61,
        15.8,15.64,15.28,15.13)

## Variable x
t <- 1:length(y)     # Longitud de la serie 

options(repr.plot.width=10, repr.plot.height=5)

plot(t,y,
     col = 1,         # Color de linea
     type = "o",      # o -- overplot
     lwd = 2)         # ancho de la linea

grid()                # agrega malla



In [14]:
## Ajuste de modelo

## Partición del conjunto de entrenamiento
y.fit1 <- y[1:80]

## Rezagos de tiempo de la serie
x1 <- y[2:(length(y.fit1)-1)]     # Rezago t-1 de toda la serie
x2 <- y[1:(length(y.fit1)-2)]     # Rezago t-2 de toda la serie

## Redefinición del conjunto de entrenamiento
y.fit<- y[3:length(y.fit1)]

In [15]:
## Conjunto de datos de entrenamiento

dat.fit <- data.frame( y.fit, x1, x2)   # Dataframe con datos organizados
names(dat.fit) <- c('y.fit','x1','x2')  # Nombre de columnas de dataframe

In [16]:
## Ajuste del modelo neuronal

set.seed(001)

m1 <- train(y.fit ~ x1+x2 ,       # Formula 
               dat.fit,           # Conjunto de datos de entrenamiento
               method='nnet',     # Metodología
               linout=TRUE,       # Salida lineal
               trace = FALSE)     # Optimización de rastreo

fit<- fitted.values(m1)           # Valores ajustados del modelo


Warning message in nominalTrainWorkflow(x = x, y = y, wts = weights, info = trainInfo, :
“There were missing values in resampled performance measures.”

In [17]:
## Resumen del modelo neuronal
m1


Neural Network 

78 samples
 2 predictor

No pre-processing
Resampling: Bootstrapped (25 reps) 
Summary of sample sizes: 78, 78, 78, 78, 78, 78, ... 
Resampling results across tuning parameters:

  size  decay   RMSE           Rsquared    
  1     0.0000  0.15850531956  0.1863592460
  1     0.0001  0.12361883090  0.4572314728
  1     0.1000  0.15774472850  0.1567410709
  3     0.0000  0.13940549764  0.3583164080
  3     0.0001  0.09105576367  0.6868514954
  3     0.1000  0.11002570918  0.5989627866
  5     0.0000  0.11101522458  0.5225041176
  5     0.0001  0.10362791809  0.5819168298
  5     0.1000  0.09746878355  0.6923878771

RMSE was used to select the optimal model using  the smallest value.
The final values used for the model were size = 3 and decay = 0.0001. 
# Gráfica red neuronal entrenada options(repr.plot.width=10, repr.plot.height=5) plot(m1$finalModel) ##VERIFICAR PORQUE NO SALE GRAFICA

In [19]:
## Grafica del ajuste

options(repr.plot.width=10, repr.plot.height=5)
plot(t,y,
     col = 1,                   # Color de la serie   
     type = "o",                # o -- overplot
     lwd = 2)                   # ancho de la linea

lines(t[3:(length(y.fit1))],    # eje x
      fit,                      # valores ajustados por red neuronal
      lwd=2,                    # ancho de linea
      col="red")                # color de valores ajustados

grid()                          # agrega malla



In [20]:
## Variables de prueba

x1.for <- y[length(y.fit1):(length(y)-1)]            # Rezago t-1 para test
x2.for <- y[(length(y.fit1)-1):(length(y)-2)]        # Rezago t-2 para test
t.for  <- t[(length(y.fit1)+1):(length(y))]          # eje x para prueba

## Predicción

y.for  <- predict(m1,                                # Modelo neuronal entrenado
                  data.frame(x1= x1.for, x2=x2.for)) # Datos de entrada para test (rezagos)

In [17]:
# Grafica de la predicción

options(repr.plot.width=10, repr.plot.height=5)
plot(t,y,
     col = 1,         # Color de la serie
     type = "o",      # o -- overplot
     lwd = 2)         # ancho de la linea

lines(t.for,          # eje x
      y.for,          # valores pronostico red neuronal
      lwd=2,          # ancho de linea 
      col="red")      # color valores pronosticados

grid()                # agrega malla



Ejercicio.-- Desarrolle un modelo de red neuronal para ajustar y pronosticar el siguiente conjunto de datos. Utilice el 80% de los datos para entrenar el modelo y el 20% restante para probar

## Serie de datos x <- c( 55.27,56.23,55.76,56.62,56.21,56.28, 55.87,56.80,56.26,56.09,56.04,56.05, 55.87,55.98,55.02,55.71,54.79,54.64, 55.37,55.25,54.87,54.86,54.48,54.11, 53.92,53.77,54.10,55.10,55.65,55.86, 56.62,56.21,55.76,55.42,55.77,55.93, 55.26,55.55,56.45,56.09,56.53,56.28, 55.60,56.30,57.08,56.57,56.48,56.51, 57.03,56.80,56.91,57.14,57.27,57.18, 57.23,56.99,56.54,56.56,56.13,55.86, 55.82,56.87,55.78,56.13,54.82,54.34, 53.73,53.47,54.05,54.62,54.93,54.81, 54.69,54.67,53.77,53.73,53.55,54.28, 53.93,54.36,54.60,54.80,54.12,54.81, 54.81,55.02,55.07,55.68,55.50,54.93, 55.13,55.43,56.38,56.85,56.63,55.70, 56.23,55.85,56.26,55.98) ## Variable tiempo t <- 1:length(x) # Longitud de la serie

In [ ]:


Construcción de un combinador lineal adaptativo para pronosticar una señal durante T=132 intervalos de tiempo. La señal es definida como dk = sin(k$\pi$ /8) para k <= 64 y dk = 0.5 * sin(k$\pi$/4) para 65 <= k <= 132. Adicionalmente, la señal esta contaminada con una fuente de ruido blanco cuya desviación estandar es $\sigma$= 0.01. Note que en la gráfica puede apreciarse el cambio de periodo y amplitud en la señal a partir de k > 64


In [21]:
T <- 160
d <- c( sin((1:64)*pi/8), 0.5 * sin((65:132)*pi/4)) + 0.01 * rnorm(132)

options(repr.plot.width=10, repr.plot.height=5)
plot(d,
     col = 1,         # Color de la serie
     type = "l",      # l -- lines
     lwd = 2)         # ancho de la linea

grid()



In [22]:
## Valores iniciales de las variables

L <- 5                # las entradas corresponden a los L retardos de la serie
y <- rep(0, 132)      # Vector de salida 
e <- rep(0, 132)      # Vector para el error
w <- rep(0, L+1)      # Vector para los pesos de la red
alpha <- 0.8

In [23]:
## Implementación del algoritmo de entrenamiento

for (k in (L+1):132)    #El algoritmo se ejecuta para L + 1 <= k <= 132, ya que para k <= L no hay datos 
{
    #crea el vector x. Este paso es innecesario y solo se realiza para
    #conservar la relación del ejemplo con la notación.

    x = c(1, d[(k-1):(k-L)])

    ## calcula el pronostico
    y[k] <- sum(x * w)                      # Suma de pesos w por valores x

    ## calcula la corrección
    e[k] <- d[k] - y[k]                     # Cálculo de error 
    w <- w +alpha * e[k] / sum(x^2) * x     # Corrección para los pesos de la red
}

In [24]:
## Gráfica de resultados 

options(repr.plot.width=10, repr.plot.height=5)
plot(d,
     col = 1,                         # Color de la serie
     type = "l",                      # l -- lines
     ylim = c(min(y,d), max(y,d)),    # Limite eje y 
     lwd = 2)                         # ancho de la linea

lines(y,                              # Valores ajustados
      lwd=2,                          # ancho de linea 
      col="red")                      # color valores pronosticados

grid()



Ejercicio.-- Construya un combinador lineal para ajustar el siguiente conjunto de datos. Utilice:

  • L= 5 y $\alpha$ = 0.8
  • L= 4 y $\alpha$ = 0.5
  • L= 3 y $\alpha$ = 0.4
  • L= 2 y $\alpha$ = 0.7
  • L= 1 y $\alpha$ = 0.9
x <- c( 0.18, 0.34, 0.46, 0.50, 0.47, 0.36, 0.18, 0.02,-0.18,-0.36,-0.46, -0.5, -0.46,-0.35,-0.18, 0.00, 0.18, 0.35, 0.47, 0.50, 0.45, 0.37, 0.17,-0.01, -0.18,-0.35,-0.46,-0.49,-0.45,-0.36, -0.19, 0.01, 0.20, 0.35, 0.45, 0.50, 0.45, 0.36, 0.19,-0.01,-0.17,-0.34, -0.45,-0.49,-0.46,-0.36,-0.19, 0.00, 0.18, 0.37, 0.46, 0.51, 0.47, 0.35, 0.21, 0.01,-0.19,-0.36,-0.46,-0.51, -0.46,-0.34,-0.20, 0.01, 0.70, 1.00, 0.70, 0.00,-0.70,-0.99,-0.71, 0.00, 0.71, 1.00, 0.71, 0.02,-0.71,-0.98, -0.71, 0.00, 0.72, 1.00, 0.70, 0.00, -0.69,-1.01,-0.71, 0.00, 0.72, 1.01, 0.70, 0.00,-0.70,-1.00,-0.70, 0.01, 0.72, 1.00, 0.72, 0.01,-0.70,-0.99, -0.72,-0.01, 0.70, 1.01, 0.72, 0.00, -0.68,-1.00,-0.69, 0.01, 0.71, 0.99, 0.70,-0.01,-0.71,-1.00,-0.70, 0.00, 0.72, 1.02, 0.70, 0.02,-0.69,-1.00, -0.71,-0.01, 0.71, 1.01, 0.70,-0.01)

In [ ]: