REDES NEURONALES

ARTIFICIALES
MIGUEL CAON Y NATHALY TRIVIO
Las redes neuronales artificiales son un campo importante de la Inteligencia
Artificial muy importante que utiliza el conocimiento experimental para razonar y
resolver problemas especficos. Es inspirada en el comportamiento del celebro
humano para darle solucin a los problemas con tcnicas algortmicas
convencionales.
Estas redes estn dirigidas a modelar la forma de procesamiento de la informacin
en sistemas nerviosos biolgicos. Especialmente, por la forma de funcionamiento
del cerebro humano (sistema complejo, no p-lineal y paralelo), que es distinta al
funcionamiento de un computador convencional. La red neuronal es en pocas
palabras es un procesador de informacin, de distribucin altamente paralela,
constituido por unidades sencillas o complejas. Se puede caracterizar por adquirir
conocimiento a travs de la experiencia, tener plasticidad y adaptabilidad, adems
posee un alto nivel de tolerancia a las fallas y se destaca en ser altamente no-lineal
(M Maneta, 2003).
Haciendo una analoga entre las redes neuronales biolgicas y las redes neuronales
artificiales, las redes biolgicas haciendo referencia a las neuronas interconectadas
entre si formando circuitos que desarrollan funciones especficas de los seres
humanos, cambiando informacin de forma fugaz, para realizar actividades, pero
para llegar a tomar una decisin el ser humano se demora 0.01 segundos en
reconocer la respuesta. Por otro lado de forma simplificada, las redes neuronales
artificiales reciben la informacin, la procesan en las matrices de pesos, donde son
evaluados los impulsos, combinndose con una funcin objetivo, el cual nos dar la
respuesta potencial de la neurona.
La relacin entre estas dos se puede definir inicialmente que los valores de entrada
son equivalentes a las seales que sern enviadas hacia otras neuronas. La matriz
de los pesos equivale a al neuronas biolgicas a los mecanismos que existen en la
sinapsis para transmitir la seal. As que cuando se unan estos valores se comienza
el entrenamiento de los datos, logrando obtener una tendencia del comportamiento
de la seal. Estos valores obtenidos son la entrada de la funcin (suma ponderada
de la entrada por el peso) de la red, lo que equivaldra a total de las seales que
llegan a la neurona por las dendritas (Ballesteros, s.f.)
La salida de funcin de ponderacin llega a la funcin de activacin que transforma
este valor en otro en el dominio que trabajen las salidas de las neuronas. El valor de
salida cumplira la funcin de la tasa de disparo en las neuronas biolgicas.

Neurona Biolgica

Neurona Artificial

Conexiones sinpticas

Conexiones ponderadas

Efectividad de la sinapsis

Peso de las conexiones

Efecto
excitador
inhibidor
de
conexin

o
una

Signo del peso de una

conexin

Efecto combinado de la
sinapsis

Funcin de propagacin o
de red

Para el desarrollo de este tema, se tienen datos de una tormenta en Bogot, la cual
ser interpolada para tener cada 15 min en toda el rea influyente de la tormenta.
Inicialmente se realiza la ubicacin de las estaciones que se tienen, con ello se
puede observar en la Figura 1, que la densidad de las estaciones es mayor
aproximadamente en las coordenadas 1010.000 Norte y 1000.000 Este.

Figura 1: Ubicacin espacial de las estaciones. Fuente: Autores

El
mtodo de
interpolacin usada es IDW (Ponderacin por distancia), realiza la interpolacin del
punto problema asignando pesos a los datos del entorno en funcin inversa de la
distancia que separa a los puntos. Esta familia de mtodos permite la generacin

del MDE de una forma rpida y simple. Sin embargo, se trata esencialmente de una
media ponderada y, por tanto, el resultado se encuentra siempre incluido dentro del
rango de variacin de los datos. Por este motivo, el correcto tratamiento de las
formas cncavas y convexas depende estrechamente de la distribucin de los
puntos originales y la presencia de datos auxiliares se hace muy conveniente
(Universidad de Oviedo, 2015).
A continuacin en la Figura 2, se muestran las interpolaciones obtenidas, en t=4,
t=11, t=23, t=42, t=55 y t=61.

Figura 2: Interpolacin IDW. Fuente: Autores

De las Figura 2 se puede observar que el evento comienza en la zona nororiente del
rea de estudio con una precipitacin mxima de 0.10 mm, posteriormente en
evento comienza a moverse hacia el este distribuyndose en toda la zona, a las 10
horas (t=4), el evento est totalmente difundido en la zona de estudio, finalmente
el evento se acenta en la zona sureste, disminuyendo considerablemente la
intensidad.

La interpolacin de los datos fue realizada con la ayuda de un algoritmo el cual

realiza el mtodo de interpolacin IDW (ver Anexo 1), posterior a esto se extraen los
datos, los cuales deben ser escalados para realizar la construccin de la red
neuronal. Para lograr esto, se comienza a realizar el entrenamiento de los datos,
para esto es necesario primero hacer el re-escalamiento de los datos entre 0.05 y
0.95, teniendo en cuenta que al final se volver a escalar los resultados para tener
los datos de precipitacin correctos. Con estos valores se logra tener los parmetros
de entrenamiento de la red que se va a construir. A continuacin, se muestra el
esquema representativo de la forma que se realiz el escalamiento de datos (ver
Figura 3).

Figura 3: Representacin esquemtica de la escalada de los datos. Fuente: Autores

Posterior al entrenamiento de datos se realiza la construccin del algoritmo, para la
construccin de la red neuronal, en una primera instancia se realiza sin capa oculta
la construccin a partir de los datos obtenidos del entrenamiento y con ellos
tambin se construye la red sin capa oculta. Se tiene en cuenta que la matriz inicial
de pesos, se inicializa con valores aleatorios, los cuales tienen que converger
cuando el error disminuya con respecto a la respuesta de la red.

De forma esquemtica se representa el proceso que se llev a cabo para la

construccin de la red (Ver Figura 4). Se puede observar que se inicia a partir de los
datos que ya han sido escalados anteriormente, posterior a esto, se realiza la

Figura 4: Esquema de la construccin de la red. Fuente: Autores

construccin de la red.

La matriz de pesos fue definida segn el nmero de entradas y salidas, en este caso
se tienen XX entradas y XX salidas, entonces se hace una matriz llenada de forma
aleatoria de XX * XX. En el Anexo 2 se puede observar el algoritmo realizado para la
evaluacin de la red. Los resultados obtenidos se pueden observar en la Figura 5, la
dispersin de lo obtenido, con esto
ACA COMENTAR LA GRAFICA DE LOS RESULTADOS.

Anexo 1: Algoritmo interpolacin IDW

import numpy as np
import pandas as pd
from osgeo import gdal
import osr
from pylab import *
import
matplotlib.pyplot as
plt
from matplotlib import
colors, ticker, cm
import
matplotlib.animation
as animation

def
pixel(xmax,xmin,ymax,y
min,nx,ny):
pixelWidth=abs(xmi
n-xmax)/nx
pixelHeight=abs(ym
in-ymax)/ny
return
pixelWidth,pixelHeight
def
array2raster(newRaster
fn, array,pixelWidth,
pixelHeight,cols,rows,
xorg,yorg):
originX = xorg
originY = yorg
driver =
gdal.GetDriverByName('
GTiff')
outRaster =
driver.Create(newRaste
rfn, cols, rows, 1,
gdal.GDT_Float64)
outRaster.SetGeoTr
ansform((originX,
pixelWidth, 0,
originY, 0,
pixelHeight))
outband =
outRaster.GetRasterBan
d(1)
outband.WriteArray
(array)

outRasterSRS =
osr.SpatialReference()
outRasterSRS.Impor
tFromEPSG(3116)
outRaster.SetProje
ction(outRasterSRS.Exp
ortToWkt())
outband.FlushCache
()
def IDW
(x,y,z,nx,ny,xmax,xmin
,ymax,ymin,power=2):
def distancia(x,
y, xi, yi):
#genera la
distancia euclidea
entre dos puntos
obs =
np.vstack((x, y)).T
interpolar =
np.vstack((xi, yi)).T
d0 =
np.subtract.outer(obs[
:,0], interpolar[:,0])
d1 =
np.subtract.outer(obs[
:,1], interpolar[:,1])
Md=np.hypot(d0
, d1)
return Md
def
malla(xmax,xmin,ymax,y
min,nx,ny):
#genera la
malla de puntos
desconocidos los
cuales se van a
interpolar
xi=np.linspac
e(xmin,xmax,nx)
yi=np.linspac
e(ymin,ymax,ny)
xi,
yi=np.meshgrid(xi,yi)

xi, yi =
xi.flatten(),
yi.flatten()
return xi,yi
# divisiones de la
malla
xi,yi=malla(xmax,x
min,ymax,ymin,nx,ny)
# Generamos las
disntacias entre los
puntos conocidos y
desconocidos
dist =
distancia(x,y, xi,yi)
# W pesos
W = 1.0 /
dist**power
W /= W.sum(axis=0)
# multiplica los
pesos por los valores
observados z
zi = np.dot(W.T,
z)
# se genera una
matrix con el tamano
de las celdas en x y y
zi=zi.reshape(nx,n
y)
return xi,yi,zi
def jackknife(df):
# Funciones para
las metricas
def ME(obs,sim):
A=np.mean(obssim)
return A
def MARE(obs,sim):
A=np.mean(abs(
obs-sim)/obs)
return A

def distancia(x,
y, xi, yi):
#genera la
distancia euclidea
entre dos puntos
obs =
np.vstack((x, y)).T
interpolar =
np.vstack((xi, yi)).T
d0 =
np.subtract.outer(obs[
:,0], interpolar[:,0])
d1 =
np.subtract.outer(obs[
:,1], interpolar[:,1])
Md=np.hypot(d0
, d1)
return Md
#Matriz de
almacenamiento
errores=np.zeros([
np.size(df,axis=0),2])
#CICLO QUE RECORRA
TODOS LOS DATOS
for i in range
(np.size(df,axis=0)):
##Separar
valores del data frame
original
observados=df[
i:i+1]
id=
observados.index
data =
df.drop(id,axis=0)
# matriz N-1
x=data['Este']
y=data['Norte'
]
z=data['z']
# datos
Extraidos
xi=observados[
'Este']
yi=observados[
'Norte']
obs=observados
['z']
# METODO idw

dist=distancia
(x, y, xi, yi)
W = 1.0 /
dist**2
W /=
W.sum(axis=0)
sim =
np.dot(W.T, z)
# Metricas
errores[i,0:]=
ME(obs,sim)
errores[i,1:]=
MARE(obs,sim)
E=pd.DataFrame
(errores)
E.columns=['Me
an error','Mean
Absolute relative
error']
E.to_excel('Er
rores_jacknife.xlsx','
Errores')
E.hist()
plt.savefig('Histo
grama Errores.png',
fmt='png', dpi=300)
plt.show()
return E
fn='datos.xlsx'
df =
pd.read_excel(fn,'Lluv
ia',index_col=0)
#print df.head()
nx=100 # numero de
Celdas en X
ny=100 # numero de
Celdas en Y
x=df['Este']
y=df['Norte']
xmax=np.max(x)#873346.
050446
xmin=np.min(x)#708428.
281178
ymax=np.max(y)#838345.
286362
ymin=np.min(y)#652604.
566429
fig, ax = subplots()

ax.scatter(df.Este,
df.Norte, c=df.t_1,
cmap='gray')
ax.set_aspect(1)
xlabel('Este [m]')
ylabel('Norte [m]')
title('Precipitacion
[mm]')
plt.show()
filas=['t_1','t_2','t_
3','t_4','t_5','t_6','
t_7','t_8','t_9','t_10
','t_11','t_12','t_13'
,'t_14','t_15','t_16',
't_17','t_18','t_19','
t_20','t_21','t_22','t
_23','t_24','t_25','t_
26','t_27','t_28','t_2
9','t_30','t_31','t_32
','t_33','t_34','t_35'
,'t_36','t_37','t_38',
't_39','t_40','t_41','
t_42','t_43','t_44','t
_45','t_46','t_47','t_
48','t_49','t_50','t_5
1','t_52','t_53','t_54
','t_55','t_56','t_57'
,'t_58','t_59','t_60',
't_61']
wr='interpolaciones.xl
sx'
libro_excel =
pd.ExcelWriter(wr)
for f in filas[0:]:
z=df[f]
xi,yi,zi=IDW(x,y,z
,nx,ny,xmax,xmin,ymax,
ymin)
#print zi,f
##################
###########
print f
###############
Ph =
plt.imshow(zi)
fig = plt.gcf()
plt.clim()
#
clamp the color limits
plt.title(f)
fnz='interpolacion
_'+ f +'_'+ '.png'

plt.tight_layout()
plt.colorbar( orie
ntation='horizontal')
#plt.pause(0.5)
plt.waitforbuttonp
ress()
draw()

#plt.savefig(fnz,
dpi=1000,
pad_inches=0.5)
#plt.close()

"""
zi)

data=pd.DataFrame(

with
pd.ExcelWriter(wr) as
writer:
data.to_excel(
libro_excel,
sheet_name=f,
merge_cells=False)
libro_excel.save()

ANEXO 2: Algoritmo de la construccin de la red