Introduccin a las Redes Neuronales: Parte 1

Procesamiento Adaptativo
Dr. Ing. Marcelo Risk
Instituto Tecnolgico de Buenos Aires

ndice
1. Introduccin

2. Filtrado adaptativo
2.1. Estructura general de los filtros adaptativos . . . . . . . . . .
2.2. Identificacin de los parmetros . . . . . . . . . . . . . . . . .
2.3. Correccin adaptativa de seales . . . . . . . . . . . . . . . . .
2.4. Tcnicas de estimacin ptima . . . . . . . . . . . . . . . . . .
2.5. Mtodo de resolucin directa . . . . . . . . . . . . . . . . . . .
2.6. Mtodos iterativos . . . . . . . . . . . . . . . . . . . . . . . .
2.6.1. Algoritmo de gradiente mediante el mtodo de Newton
2.6.2. Mtodo de gradiente buscado por descenso escalonado .
2.6.3. Algoritmo LMS de Widrow . . . . . . . . . . . . . . .

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

2
2
3
3
4
6
7
7
8
8

3. Aplicaciones del filtrado adaptativo

3.1. Modelizacin adaptativa en la sntesis de filtros FIR . . . .
3.1.1. Cancelacin adaptativa de ruido . . . . . . . . . . .
3.1.2. Modelizacin adaptativa en la sntesis de filtros IIR
3.2. Implementacin de filtros adaptativos . . . . . . . . . . . .
3.2.1. Estructura bsica de un filtro adaptativo . . . . . .
3.3. Implementacin del combinador lineal adaptativo . . . . .
3.3.1. Cdigo fuente de FILTADAPT.H . . . . . . . . . .
3.3.2. Cdigo fuente de FILTADAPT.CPP . . . . . . . .
3.3.3. Cdigo fuente de FiltroAdaptativo.py . . . . . . . .

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

.
.
.
.
.
.
.
.
.

9
9
9
10
10
10
14
16
16
19

4. Ejemplos de aplicaciones del filtrado adaptativo

4.1. Ejemplo de identificacin de un sistema . . . . . .
4.1.1. Cdigo fuente de FILTRO.CPP . . . . . .
4.1.2. Cdigo fuente de IdentificacionSistema.py
4.2. Ejemplo de cancelacin de interferencias . . . . .
4.2.1. Cdigo fuente de FILTRO2.CPP . . . . .
4.2.2. Cdigo fuente de CancelacionRuido.py . .

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

20
20
21
26
28
29
34

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

.
.
.
.
.
.

1.

Introduccin

En el presente apunte se puede apreciar una breve introduccin al procesamiento

adaptativo de seales, y su relacin con las redes neuronales (RN), es especial con
las arquitecturas de RN basadas el modelo de neurona denominado perceptrn.
La segunda seccin de este documento describe los fundamentos del filtrado
adaptativo, y luego una implementacin de los mismos a partir de un combinador
lineal adaptativo. Finalmente se estudiarn dos aplicaciones, uno a la identificacin
de un sistema y otro para la cancelacin de interferencias.
La parte 2 muestra una introduccin a las redes neuronales, a partir de la modelizacin de una neurona con un combinador lineal modificado. Al final de dicha seccin
se presenta una implementacin completa de una RN, y un ejemplo de aplicacin
de la misma.

2.

Filtrado adaptativo

Los filtros adaptativos son aquellos filtros autoprogramables cuya respuesta en

frecuencia o funcin transferencia est alterada o adaptada para dejar pasar sin
degradacin las componentes deseadas y atenuar las seales no deseadas, o que
generan interferencias, o reducir cualquier distorsin de se`
nal de entrada.
Los primeros filtros adaptativos o de autoaprendizaje fueron descriptos por Lucky
[3], quien los utiliz en el diseo de un ecualizador para compensar la distorsin en
sistemas de transmisin de datos.
Como generalmente no existe informacin disponible a priori, los filtros adaptativos requieren un perodo inicial de aprendizaje, tambin denominado de adaptacin.
Los algoritmos utiizados en el procesamiento digital de seales han tenido su
precedente en la teora de los sistemas adaptativos de control, si bien existen con
respecto de stos ciertas diferencias.

2.1.

Estructura general de los filtros adaptativos

Un filtro adaptativo est compuesto principalmente por tres partes:

a) El ndice de performance, el cual debe ser optimizado.
b) El algoritmo que recalcula los parmetros del filtro.
c) La estructura del filtro, que realiza las operaciones requeridas sobre la seal.
El ndice de performance depende de la aplicacin, es decir, est determinado
por el tipo de trabajo del sistema adaptativo. En general se toma como evaluador
la minimizacin del error cuadrtico medio e el cual generalmente es satisfactoria,
como lo muestra la ecuacin 9, donde y es la salida del sistema, ymodelo es la salida
del modelo.
X
e=
(y ymodelo )2
(1)
2

El algoritmo de optimizacin es el mecanismo mediante el cual los parmetros,

optimizando el criterio, son calculados. Existen dos tipos de algoritmos, el primero
es no recursivo, y requiere la coleccin de todos los datos en una ventana temporal,
para luego resolver un sistema de ecuaciones.
El segundo tipo de algoritmo es el algoritmo del gradiente, el cual requiere la
solucin de un conjunto de ecuaciones lineales por inversin de una matriz y de esta
forma los resultados no estarn disponibles en tiempo real.
En rigor los algoritmos ms utilizados desde el punto de vista del procesamiento
digital son del tipo recursivo, el cual se actualiza a partir de cada entrada de la seal
de entrada o con un pequeo grupo de muestras.
Los resultados estn disponibles inmediatamente y es posible el seguimiento de
seales no estacionarias. Un ejemplo de ello es el algoritmo LMS (least mean square). Como es obvio la estructura del filtro depende tanto del algoritmo como de la
aplicacin.

2.2.

Identificacin de los parmetros

La identificacin de parmetros de un sistema es un procedimiento muy utilizado

para el anlisis en sistemas de control. Para controlar el comportamiento ptimo de
un sistema es necesario conocer su conducta dinmica.
Esta est usualmente dada por ecuaciones diferenciales que relacionan la entrada
y la salida del sistema. Si slo se reconoce la estructura de las ecuaciones, pero no
los parmetros, algn tipo de algoritmo de computacin podra ser aplicado para
estimarlos.
La figura 1 muestra el diagrama en bloques de un sistema de identificacin adaptativo.
Las entradas y salidas ruidosas son medidas tanto durante la aplicacin normal o
durante la prueba de especificaciones. Estas son ingresadas a un filtro con coeficientes
variables, los cuales estn ajustados por un algoritmo optimizador.
Luego de la adaptacin, el filtro representa el mejor modelo para el sistema, y
sus coeficientes son los parmetros identificados del sistema.

2.3.

Correccin adaptativa de seales

Si para una entrada del sistema innaccesible se debe actuar sobre la seal de
salida de forma tal de realizar algn tipo de correccin de la seal, como por ejemplo
la eliminacin de interferencia en la seal de electrocardiograma (ECG), o para la
separacin del ECG materno del fetal, entonces en este caso la informacin de la
seal y de la correccin requerida es de extrema importancia. Un diagrama de este
tipo de filtro correctivo se ve en la figura 2.
Otro tipo de ejemplo muy utilizado de filtro adaptativo que se conoce como filtro
de prediccin lineal, es aquel que provee a su salida las salidas futuras del proceso.
La misin especfica de un filtro de prediccin lineal es la de estimar la salida
futura del proceso como una combinacin lineal de las salidas presente y pasada.

ruido
e(t)

ruido

s(t)

Sistema

+
Criterio
de Error

Modelo

Ajuste del
Modelo

Figura 1: Diagrama en bloques de un sistema de identificacin adaptativo.

Originariamente los filtros de prediccin se utilizaron para predecir las trayectorias de un blanco en movimiento en aplicaciones militares, y hoy en da se utilizan
para predecir la evolucin de procesos muy diversos. La figura 3 muestra el dDiagrama en bloques de un filtro de prediccion lineal.
La seal de entrada s, y versin retardada de la misma son enviadas al procesador
adaptativo, el cual debe intentar predecir la entrada para hacer que con y y d se
calcule el error, buscando que este ltimo se minimize. Los filtros de prediccin se
utilizan adems en decodificacin de seales y reduccin de ruido.

2.4.

Tcnicas de estimacin ptima

Como se dijo anteriormente el error es la resta (segn la aplicacin) entre la

salida del sistema y la del modelo:
e = y ymodelo

(2)

En el caso de seales discretas este ser:

en = yn wn

(3)

si para simplificar la nomenclatura hacemos ymodelo = w:

e n = yn wn
4

(4)

Seal a ser corregida

Ruido

Seal corregida

Filtro
Adaptativo

Algoritmo
Adaptativo

Conocimiento
apriori de
seal y ruido

Criterio

Figura 2: Diagrama en bloques de un sistema de correccion adaptativa de seales.

+
Procesador
Adaptativo

Delay

error

Figura 3: Diagrama en bloques de un filtro de prediccion lineal.

si tomamos para identificar un modelo tipo ARMA:

Pm
j
W (z)
j=0 j z
P
=
X(z)
1 pi=0 i z j

(5)

de donde:
wn =

p
X

i wni +

i=1

m
X

j xnj

(6)

j=0

Entonces para el error entre la salida del sistema fsico y modelo se utiliza la
ecuacin 3, luego:
yn =

p
X

i yni +

i=1

m
X

j xnj

(7)

j=0

p
m
X
X
0
0
en =
(j j )xnj
(i i )yni +

(8)

j=0

i=1

El error cuadrtico medio (ECM ) es una magnitud se calcual como:

= E(e2n )

(9)

La expresin anterior representa en el espacio generado por los coeficientes i y

j un hiperparaboloide de dimensiones p + m + 1, que posee un mnimo absoluto en
el punto dado por:
0

j = j
0

j = j

1ip
0jm

(10)

El problema de estimar los coeficientes se reduce a calcular los coeficientes i y

j que minimizan el error cuadrtico (ver ecuacin 9).

2.5.

Mtodo de resolucin directa

Los mtodos de resolucin directa consisten en calcular el punto en que se anulan

todas las derivadas del error cuadrtico medio, para las siguientes condiciones:

=0
i

=0
j

1ip
(11)
0jm

Dado que la funcin no posee mximos para los valores finitos de i y j la

solucin de las ecuaciones conducen al mnimo deseado.

Si se trata de un proceso cuasiestacionario, debe emplearse la esperanza matemtica de ECM como la suma temporal dentro del perodo de estacionareidad del
proceso, luego el clculo debe repetirse peridicamente, de manera de cubrir todo el
tiempo en estudio.

2.6.

Mtodos iterativos

Estos mtodos involucran un menor nmero de operaciones matemticas y pro0

0
veen adems una estimacin de i y j adaptable a las fluctuaciones de los coeficientes verdaderos i y j . De los diversos mtodos iterativos slo estudiaremos
el algoritmo del gradiente mediante el mtodo de Newton-Raphson, el mtodo del
gradiente buscado por descenso escalonado, y el algoritmo LMS de Widrow.
2.6.1.

Algoritmo de gradiente mediante el mtodo de Newton

Este mtodo consiste en descender sobre el hiperparaboloide de ECM siguiendo

la direccin impuesta por el mtodo de Newton-Raphson para la determinacin de
una raz y por ende con una sencilla transformacin, el mnimo de:
0

f (x0 ) =

f (x0 )
x 0 x1

(12)

f (x0 )
f 0 (x0 )

(13)

entonces:
x1 = x0
luego:

xk+1 = xk

f (xk )
f 0 (xk )

k = 0, 1, ...

(14)

La convergencia depende del valor inicial y de la naturaleza de f (x). Si ahora

tomamos:
0

f (x) = (x)

(15)

en vez de un cero se tendr un mnimo, entonces:

0

(x)
00
=
(x)
0
(x)
ik+1 = ik 00
(x)

ik+1

ik

1ip
(16)
0jm

El coeficiente es una constante que determina la dimensin del peso, y gobierna

la velocidad de convergencia, es decir un valor de demasiado pequeo requiere un
elevado nmero de iteraciones para alcanzar el mnimo.
7

2.6.2.

Mtodo de gradiente buscado por descenso escalonado

En este caso los coeficientes o pesos son ajustados segn el gradiente en cada
paso, lo cual simplifica notablemente el clculo.
Este mtodo est gobernado por las ecuaciones en la cual es una constante
que regula el tamao del paso. Al igual que el mtodo anterior, un valor demasiado
pequeo de requerir un elevado nmero de iteraciones para alcanzar un mnimo,
y un valor excesivo puede ocasionar inestabilidades en el algoritmo.
Tanto en este caso como en el anterior se parte utilizando todo el conocimiento
previo sobre los valores a estimar y luego es desplazada la estimacin inicial descendiendo sobre la superficie de ECM en la direccin del gradiente (perpendicular a las
curvas de nivel) hasta alcanzar un mnimo.
La diferencia entre este mtodo y el de Newton-Raphson radica en la practicidad
del algoritmo puesto que en el primero es necesario resolver una matriz inversa.
El clculo de los coeficientes en este mtodo se realiza con las siguientes ecuaciones:

= ik
j

ik+1 = ik

1ip

ik+1

0jm

(17)

Donde el suprandice indica el orden de iteracin.

2.6.3.

Algoritmo LMS de Widrow

En el algoritmo anterior se requiere la determinacin del gradiente del ECM en

cada iteracin, es decir se estimo el gradiente de .
Bernard Widrow analiz las condiciones de estabilidad, la constante de tiempo
de convergencia, y el error de estimacin del algoritmo anterior, reemplazando el
valor del gradiente por una estimacin del mismo empleando una sola muestra [7].
Es decir, aproximando la esperanza matemtica del ECM por el mismo pero en
cada iteracin. En otras palabras se toma a e2k como una estimacin directa de ,
entonces:
(e2k )
i
(e2 )
= ik k
j

ik+1 = ik
ik+1

1ip
(18)
0jm

Si tomamos la definicin del ECM y elevamos al cuadrado ambos miembros,

calculamos la derivadas parciales y reemplazamos en la ecuacin anterior se obtiene:
ik+1 = ik + 2ek y k1

(19)

ik+1 = ik + 2ek xk1

(20)

3.

Aplicaciones del filtrado adaptativo

3.1.

Modelizacin adaptativa en la sntesis de filtros FIR

La idea bsica es asociar a un pseudofiltro las especificaciones ideales de un filtro

que generalmente no ser fsicamente realizable.
El pseudofiltro es nicamente conceptual; el esquema utilizado puede verse en la
figura 4.

f1
f2

fn

~
~
~

Pseudofiltro

x
Filtro
Adaptativo

-
error

Figura 4: Diagrama en bloques de un sistema de filtrado adaptativo a travs de un

pseudofiltro.

3.1.1.

Cancelacin adaptativa de ruido

La situacin bsica de cancelacin de ruido est ilustrada en la siguiente figura

5.
Una seal es transmitida de un canal a un sensor que recibe la seal ms ruido no
correlacionado n0. Esta combinacin aditiva forma la primera entrada. Un segundo
sensor recibe ruido n1 el cual no est correlacionado con la seal pero s lo est de
alguna manera con el ruido n0. Esta constituye la entrada de referencia al cancelador.
el ruido n1 es filtrado de forma tal de obtener una rplica n0.
La salida se resta de la entrada primaria para producir una salida del sistema
igual a s + n0 + y.
Ejemplo de ello son la cancelacin de ruido en seales de audio (n1 es la interferencia), cancelacin de la interferencia en el ECG del corazn transplantado y

Entrada
Primaria

s+nO

Fuente
de seal

Salida

nO

y
Entrada
Referencia
Fuente
de ruido

Filtro
Adaptativo
n1
error

Cancelador Adaptativo de Ruido

Figura 5: Diagrama en bloques de un sistema de cancelacin de ruido con filtrado

adaptativo.
separacin del ECG materno del fetal como as tambin la cancelacin de ecos en
circuitos telefnicos de larga distancia.
3.1.2.

Modelizacin adaptativa en la sntesis de filtros IIR

Como se ha visto anteriormente la transferencia de un filtro de respuesta infinita

al impulso (IIR) a sintetizar ser:
H(z) =

A(z)
1 B(z)

(21)

El diagrama en bloques de tal filtro se puede apreciar en la figura 6.

3.2.
3.2.1.

Implementacin de filtros adaptativos

Estructura bsica de un filtro adaptativo

Los filtros adaptativos se pueden implementar tanto como filtros de respuesta

finita al impulso (FIR) o de respuesta infinita al impulso (IIR), pero en general se
prefiere el esquema FIR debido a una mayor simplicidad y estabilidad, teniendo en
cuenta que el algoritmo de adaptacin es el encargado de calcular los coeficientes
del filtro, por lo cual un esquema FIR asegura la estabilidad del filtro a pesar de las
combinaciones de coeficientes calculadas.
La estructura de un filtro FIR se puede desarrollar con un combinador lineal,
cuyo diagrama se muestra en la figura 7.

10

A(z)

B(z)

Figura 6: Diagrama en bloques de un filtro adaptativo IIR.

X0

X1

W0

W1

W2

X2
W3
X3

Figura 7: Diagrama en bloques de un combinador lineal.

11

La expresin del combinador es:

Y =

N
1
X

Wk Xk

(22)

k=0

donde N es la cantidad de coeficientes u orden del filtro, X es el vector de

entrada, W es el vector de pesos, e Y es la salida.
La figura anterior muestra el combinador lineal en la forma de entrada paralelo,
pero en la mayora de las aplicaciones es necesario ingresar los datos (muestras) en
forma serie, especialmente cuando el filtro se implementa en tiempo real y por lo
tanto las muestras van llegando una a una, en este caso se debe utilizar la forma
serie del combinador lineal, como lo muestra la figura 7.

W0

X(n)
T

W1

X(n-1)

T
W2

Y(n)

X(n-2)
T

W3

X(n-3)

Figura 8: Diagrama en bloques de un combinador lineal serie.

En el combinador lineal con entrada serie podemos apreciar cmo se forma el
vector de entrada X con la muestra actual X(n) y las muestras anteriores X(n 1)
a X(n 3), para lograr el retardo entre dichas muestras se intercala un bloque de
retardo T . La expresin del combinador lineal con entrada serie es la siguiente:
Y (n) =

N
1
X

Wk Xk (n k)

(23)

k=0

Como se describi en la introduccin, los sistemas de lazo cerrado utilizan la

diferencia entre la salida deseada d(n) y salida actual Y (n) para calcular en error:
e(n) = d(n) Y (n)

12

(24)

por lo tanto:
e(n) = d(n)

N
1
X

Wk Xk (n k)

(25)

k=0

Elevando el error al cuadrado obtenemos el denominado error cuadrtico instantneo:

e2 (n) = d2 (n) 2

N
1
X

Wk Xk (n k) +

k=0

N
1
X

!2
Wk Xk (n k)

(26)

k=0

Por otro lado se define a error cuadrtico medio como:

1
X
 2  M
= E e (n) =
e2 (n)

(27)

m=0

quedando:
=

M
1
X
m=0

d (n) 2

N
1
X

Wk rdx (n) +

n=0

N
1 N
1
X
X

Wk Wl rxx (n l)

(28)

n=0 l=0

donde las ecuaciones rdx y rxx las correlaciones cruzadas entre la salida deseada
y la entrada y la autocorrelacin da la entrada respectivamente.
El error cuadrtico medio describe una superficie de performance, cuando se
lo grafica con respecto a los pesos W , en la figura siguiente podemos observar una
superficie de performance para el caso de dos pesos, donde tambin apreciamos
los pesos ptimos W1 y W2 que corresponden al mnimo de de la superficie de
performance.
El proceso de adaptacin busca minimizar el error cuadrtico medio, para lograr
este objetivo se propone el mtodo de descenso a pasos a travs de la superficie de
performance.
Con el mtodo de descenso a pasos es posible recalcular cada peso teniendo
informacin acerca del peso anterior y del gradiente en el punto de peso anterior
sobre la superficie de performance, multiplicado por un coeficiente de velocidad de
convergencia, como lo indica la ecuacin 29.
Wk (n + 1) = Wk (n) + (5k )

(29)

En el mtodo de adaptacin basado en el error cuadrtico medio, el gradiente se

define como:


e2 (n)
(30)
5k =
Wk (n)
entonces sustituyendo la ecuacin 30 en la 29:


e2 (n)
Wk (n + 1) = Wk (n)
Wk (n)
13

(31)

Se utiliza el error instantneo porque est disponible muestra a muestra durante la optimizacin de los pesos del filtro. Entonces desarrolando la derivada y
reemplazando por la definicin de la ecuacin 25, tenemos:


e(n)
(32)
Wk (n + 1) = Wk (n) 2e(n)
Wk (n)
y reemplazando con 25, quedando:


P 1
d(n) N
W
X
(n

k)
k
k
k=0
Wk (n + 1) = Wk (n) 2e(n)
Wk (n)

(33)

Note que d(n) y Xk (n) son independientes de Wk , por lo tanto:

Wk (n + 1) = Wk (n) 2e(n)Xk (n)

(34)

La ecuacin 34 es la expresin final del algoritmo del mtodo de los cuadrados

mnimos.
El coeficiente de velocidad de convergencia debe elegirse de forma tal de llegar
al valor ptimo lo suficientemente rpido, pero sin perder estabilidad, por lo tanto
los valores recomendados para deben estar en el rango descripto en la ecuacin
??:
1
(35)
20N Px
donde N es la cantidad de coeficientes del filtro, y Px es la potencia de los datos
durante el proceso de optimizacin:
0<<

M
1
X
1
Px =
X 2 (n)
M + 1 n=0

(36)

En la ecuacin 36 M es la cantidad de muestras durante la optimizacin de los

pesos.
El combinador lineal cuando utiliza el mtodo de los cuadrados mnimos se puede
describir con el diagrama en bloques de la figura 9, de esta forma se denomina
combinador lineal adaptativo.

3.3.

Implementacin del combinador lineal adaptativo

El combinador lineal adaptativo se puede implementar como una clase, en lenguaje C++ [4], y en Python [5, 2]. Dentro de la clase FiltroAdaptativo estn encapsuladas todas las propiedades necesarias para el funcionamiento de un objeto que
maneja un vector de datos Xk, un vector de pesos Wk, y otras variables tales el
error Ek, la cantidad de elementos Cantidad y el valor de coeficiente de velocidad de
optimizacin Alfa, dems de las funciones necesarias para la carga de los vectores,
el clculo de la salida y la optimizacin de los coeficientes del filtro.

14

W0

X(n)
T

W1

X(n-1)

T
W2

Y(n)

X(n-2)
T

W3

X(n-3)

e(n)
Algoritmo de
cuadrados mnimos

Figura 9: Diagrama en bloques de un combinador lineal serie adaptativo.

15

d(n)

3.3.1.

Cdigo fuente de FILTADAPT.H

// FILTADAPT.H
#include
#include
#include
#include

<math.h>
<stdlib.h>
<iostream.h>
<fstream.h>

class FiltroAdaptativo {
double *Xk;
double *Wk;
double Ek;
double Sk;
int Cantidad;
public:
double Alfa; // en Alfa a mu por 2
FiltroAdaptativo( int n = 20);
~FiltroAdaptativo();
double Calcula( void);
void LlenaPesos( double *Array, int cantidad);
void LlenaEntradas( double *Array, int cantidad);
void LlenaPesos( double *Array);
void LlenaEntradas( double *Array);
double MuestraSalida( void); void MuestraSet( void);
void CalculaNuevoSet( double e);
double put ( double d); double operator ()( double d)
{
return put (d);
}
int GuardaPesos( char *name); int LeePesos( char *name);
};

3.3.2.

Cdigo fuente de FILTADAPT.CPP

// FILTADAPT.CPP:
#include "filtadapt.h"
#include <stdlib.h>
FiltroAdaptativo::FiltroAdaptativo( int n)
{
16

Alfa = 1.0 / (100.0*double(n));

Ek = 1.0;
Sk = 0.0;
Cantidad = n;
Xk = new double[Cantidad];
Wk = new double[Cantidad];
for( int j = 0; j < Cantidad; j++)
{
Xk[j] = 0.0; Wk[j] = 0.0;
}
}
FiltroAdaptativo::~FiltroAdaptativo()
{
delete Xk;
delete Wk;
}
void FiltroAdaptativo::LlenaPesos( double *Array, int cantidad)
{
for( int j = 0; j < cantidad; j++)
Wk[j] = Array[j];
}
void FiltroAdaptativo::LlenaPesos( double *Array)
{
for( int j = 0; j < Cantidad; j++)
Wk[j] = Array[j];
}
void FiltroAdaptativo::CalculaNuevoSet( double e)
{
Ek = e;
for( int j = 0; j < Cantidad; j++)
{
Wk[j] = Wk[j] + Alfa*Ek*Xk[j];
}
}
void
{
cout
for(
cout
}

FiltroAdaptativo::MuestraSet( void)
<< endl;
int j = 0; j < Cantidad; j++)
<< Wk[j] << ", ";

17

double FiltroAdaptativo::Calcula( void)

{
double Suma = 0.0;
for( int j= 0; j < Cantidad; j++)
Suma += Wk[j] * Xk[j];
Sk = Suma;
return Sk;
}
double FiltroAdaptativo::put( double d)
{
for( int j = Cantidad-1; j > 0; j--)
Xk[j] = Xk[j-1];
Xk[0] = d;
return Calcula(); }
void FiltroAdaptativo::LlenaEntradas( double *Array, int cantidad)
{
for( int j = 0; j < Cantidad; j++)
Xk[j] = Array[j];
Calcula();
}
void FiltroAdaptativo::LlenaEntradas( double *Array)
{
for( int j = 0; j < Cantidad; j++)
Xk[j] = Array[j];
Calcula();
}
double FiltroAdaptativo::MuestraSalida( void)
{
return Sk;
}
int FiltroAdaptativo::GuardaPesos( char *name)
{
ofstream A;
A.open(name);
if( !A)
return -1; A << Cantidad << endl;
for( int j = 0; j < Cantidad; j++)
A << Wk[j] << endl;
18

A.close();
return 0;
}
int FiltroAdaptativo::LeePesos( char *name)
{
ifstream A;
A.open(name);
if( !A)
return -1;
int j;
A >> j;
if( j != Cantidad)
return -2;
for( int j = 0; j < Cantidad; j++)
A >> Wk[j];
A.close();
return 0;
}

3.3.3.

Cdigo fuente de FiltroAdaptativo.py

import sys
import math
from random import *
from pylab import *
class FiltroAdaptativo:
def __init__(self,n):
self.Ek = 1
self.Sk = 0
self.Cantidad = n
self.Alfa = 1.0 / (100.0*float(self.Cantidad)) # en Alfa va mu por 2
self.Xk = zeros(self.Cantidad)
self.Wk = zeros(self.Cantidad)
def Calcula(self):
Suma = 0.0
for j in range(self.Cantidad):
Suma += self.Wk[j] * self.Xk[j]
self.Sk = Suma
def LlenaPesos(self,Array):
19

for j in range(self.Cantidad):
self.Wk[j] = Array[j]
def LlenaEntradas(self,Array):
for j in range(self.Cantidad):
self.Xk[j] = Array[j]
def MuestraSalida(self):
print "Sk = " + self.Sk
def MuestraSet(self):
print self.Wk
def MuestraEntradas(self):
print self.Xk
def CalculaNuevoSet(self,ee):
self.Ek = ee
for j in range(self.Cantidad):
self.Wk[j] = self.Wk[j] + self.Alfa*self.Ek*self.Xk[j]
def put(self,dd):
for j in range(1,self.Cantidad):
self.Xk[self.Cantidad-j] = self.Xk[self.Cantidad-1-j]
self.Xk[0] = dd
self.Calcula()
return self.Sk

4.
4.1.

Ejemplos de aplicaciones del filtrado adaptativo

Ejemplo de identificacin de un sistema

Los filtros adaptativos son capaces de identificar un sistema desconocido, en otras

palabras de desarrollar una modelizacin, el objetivo es encontrar un filtro FIR que
modelice el sistema desconocido [1].
El diagrama en bloques del proceso de modelizacin se muestra en la figura
3b. En los prrafos siguientes se describir una implementacin en C++ para la
identificacin de un sistema, en este ejemplo el sistema desconocido es un filtro IIR
con la siguiente ecuacin de recurrencia:
y(n) = ax(n) + by(n 1)

(37)

donde a y b son los coeficientes del filtro, cuya condicin de estabilidad es que la
suma de los coeficientes sea menor o igual a uno.
20

A continuacin se describen los pasos a seguir para lograr dicho proceso:

1) Ambos sistemas, el filtro y el sistema desconocido, deben ser excitados por un
generador de ruido aleatorio de valor medio nulo.
2) El filtro adaptativo comienza un proceso de optimizacin, comenzando los pesos
con valores iniciales aleatorios pequeos; utilizando el mtodo de los cuadrados
mnimos se optimizan los pesos (coeficientes del filtro) minimizando el error.
3) La cantidad de iteraciones necesarias para la optimizacin se pueden calcular
buscando un error mnimo y una cantidad mxima de iteraciones, en caso de no
lograr el error mnimo.
En el ejemplo presentado el sistema desconocido (filtro IIR) y el filtro tienen una
respuesta al impulso y al escaln como lo muestran las figuras 10 y 11, respectivamente, mientras que la figura 12 muestra el error2 para las 1000 primeras iteraciones
de la adaptacin.

Figura 10: Respuesta del filtro IIR y del filtro adaptativo a un impulso.

4.1.1.

Cdigo fuente de FILTRO.CPP

// FILTRO.CPP: Identificacion de un sistema con un filtro

21

Figura 11: Respuesta del filtro IIR y del filtro adaptativo a un escaln.

22

Figura 12: error2 para las 1000 primeras iteraciones de la adaptacin.

23

// adaptativo
#include
#include
#include
#include

<iostream.h>
<fstream.h>
<math.h>
"filtadapt.h"

void main( void) {

int CantidadCoeficientes = 20;
cout << "Orden del filtro adaptativo = ";
cin >> CantidadCoeficientes;
FiltroAdaptativo F(CantidadCoeficientes);
int Number = 5000;
ofstream Salida;
Salida.open( c:\neural\\filtro.txt);
int j;
double Px = 0.0;
double Mean = 0.0;
double *noise;
noise = new double[Number];
// Calcula ruido blnco sin valor medio
for( j = 0; j < Number; j++){
noise[j] = double(random(1000))/1000.0;
mean += noise[j];
}
Mean /= double(Number);
for( j = 0; j < Number; j++){
noise[j] -= Mean;
Px += (noise[j]*noise[j]);
}
// Calcula potencia del ruido
Px /= double(Number+1);
double x, y, d, dAnt, e;
// coeficientes del sistema a identificar
double a = 0.3;
double b = 0.7;
cout << "Coeficientes del sistema a identificar: " << endl;
cout << "y[n] = a*x[n] + b*y[n-1]" << endl;
cout << "a = ";
24

cin >> a;
cout << "b = ";
cin >> b;
dAnt = 0.0;
// ajuste valor Alfa (coeficiente de velocidad de
convergencia)
// del algoritmo LMS
F.Alfa = 1.0 / (20.0*double(CantidadCoeficientes)*Px);
cout << "Busca la solucion optima por el metodo LMS ..." << endl;
for( j = 0; j < Number; j++){
x = noise[j];
d = a*x + b*dAnt;
y = F(x);
e = d - y;
F.CalculaNuevoSet( e);
dAnt = d;
if( j == 0)
cout << "Error inicial = " << e << endl;
}
cout << "Error final = " << e << endl;
F.GuardaPesos( "c:\\neural\\pesos.txt");
// Respuesta al impulso de ambos filtros
Salida << "Respuesta al impulso" << endl;
cout << "Respuesta al impulso..." << endl;
Salida << "x\td\ty" << endl;
for( j = 0; j < 50; j++){
x = 0.0;
if( j == 25)
x = 1.0;
d = a*x + b*dAnt;
y = F(x);
Salida << x << "\t" << d << "\t" << y << endl;
dAnt = d;
}
Salida << endl;
Salida << "Respuesta al escalon" << endl;
cout << "Respuesta al escalon..." << endl;
Salida << "x\td\ty" << endl;
for( j = 0; j < 50; j++){
x = 0.0;
if( j == 25)
25

x = 1.0;
d = a*x + b*dAnt;
y = F(x);
Salida << x << "\t" << d << "\t" << y << endl;
dAnt = d;
}
delete noise;
cout << endl << "FIN";
}

4.1.2.

Cdigo fuente de IdentificacionSistema.py

import sys
sys.path.append(....) # poner el path de FiltroAdaptativo.py
import math
from random import *
from pylab import *
from FiltroAdaptativo import *
F = FiltroAdaptativo(20)
Number = 5000
Px = 0.0
Mean = 0.0
noise = zeros(Number)
seed()
for j in range(Number):
noise[j] = normalvariate(0.0,1.0)
Px += noise[j] * noise[j]
Px /= float(Number+1)
x = 0.0
y = 0.0
dAnt = 0.0
e = 0.0
a = 0.3
b = 0.7
F.MuestraSet()
F.Alfa = 1.0 / (20.0*float(F.Cantidad)*Px)
26

print F.Alfa
for j in range(Number):
x = noise[j]
d = a*x + b*dAnt
y = F.put(x)
e = d - y
F.CalculaNuevoSet(e)
dAnt = d
F.MuestraSet()
N = 100
xx = arange(N)
yy = zeros(N)
zz = zeros(N)
yy[N/2] = 1.0
F.LlenaEntradas(zeros(20))
for j in range(1,N):
zz[j] = F.put(yy[j])
yy[j] = a*yy[j] + b*yy[j-1]
subplot(211)
plot(xx,yy,b)
ylim(-0.1,1.1)
title(Filtrado con $y(n)=ax(n)+by(n-1)$)
subplot(212)
plot(xx,zz,g)
ylim(-0.1,1.1)
title(Filtrado con $FiltroAdaptativo$)
savefig("EjercicioIdentificacionSistemaRespImpulso.eps")
close()

yy = zeros(N)
zz = zeros(N)
for j in range(N/2,N):
yy[j] = 1.0
27

F.LlenaEntradas(zeros(20))
for j in range(1,N):
zz[j] = F.put(yy[j])
yy[j] = a*yy[j] + b*yy[j-1]
subplot(211)
plot(xx,yy,b)
ylim(-0.1,1.1)
title(Filtrado con $y(n)=ax(n)+by(n-1)$)
subplot(212)
plot(xx,zz,g)
ylim(-0.1,1.1)
title(Filtrado con $FiltroAdaptativo$)
savefig("EjercicioIdentificacionSistemaRespEscalon.eps")
close()

4.2.

Ejemplo de cancelacin de interferencias

En muchas ocasiones una seal de gran ancho de banda w(n) se encuentra interferida por la suma de ruido de ancho de banda estrecho s(n), conformando la seal
suma x(n); las dos seales que forman x(n) no estn correlacionadas:
x(n) = w(n) + s(n)

(38)

La solucin a este problema es disear un filtro de ancho de banda estrecho

(notch), pero en ciertas ocasiones la banda de ruido no es conocida o vara lentamente
en el tiempo, para lo cual los filtros adaptativos pueden utiizarse, pues en cualquiera
de las dos situaciones son capaces de optimizar su funcionamiento [6].
El filtro adaptativo debe ser capaz de sustraer s(n) de x(n), teniendo en cuenta
que debe predecir la componente en cada muestra a travs de las muestras anteriores,
dicha prediccin se logra gracias al ancho de banda estrecho de s(n), y debido a que
como el ancho de banda de s(n) es mucho menor que el de w(n), las muestras de
s(n) tienen tienen una alta correlacin; por otro lado las muestras de w(n) tienen
una muy baja correlacin.
En la figura 13 podemos apreciar el diagrama en bloques del sistema de cancelacin de interferencias, donde el decorrelacionador introduce un retardo de T
muestras, con el propsito de decorrelacionar las componentes s(n) de la seal x(n).

28

x(n)

salida

s(n)

Filtro
Adaptativo

retardo
T

decorrelacionador

e(n) = x(n)

- s(n)

Figura 13: Diagrama en bloques de un filtro adaptativo para cancelacin de interferencias.

La salida del filtro adaptativo tiene la siguiente expresin:
0

s (n) =

N
1
X

Wk (n)x(n k T )

(39)

k=0

La seal de error e(n) se utiliza en el proceso de optimizacin del filtro adaptativo,

con el mtodo de los cuadrados mnimos. En dicho proceso de optimizacin x(n) es
la suma de una secuencia aleatoria de valor medio nulo, sobre la cual se suma el
ruido de ancho de banda estrecha, por ejemplo un tono senoidal, o bien una suma de
dos o tres tonos puros. El retardo del decorrelacionador en la mayora de los casos
es suficiente con una muestra de retardo.
Una vez adaptado el filtro, la seal a filtrar debe ser ingresada directamente
al filtro; eventualmente el filtro, puede reoptimizarse para seguir las variaciones de
seal interferente.
El ejemplo presentado trata de suprimir una interferencia producida por un tono
puro sobre una seal de electrocardiograma (ECG). El programa perteneciente a este
ejemplo es FILTRO2.CPP. y la figura iguiente muestra los resultados del filtrado
sobre una porcin de la seal de ECG.
La figura 14 muestra el error2 para las primeras 500 iteraciones durante la adaptacin del filtro, mientras que la figura 15 muestra en la seal superior el ECG
original sin ruido ni interferencias, en la seal central el mismo ECG pero con la
interferencia sumada, y finalmente en la seal inferior la salida del filtro adaptativo,
note en esta ltima el comportamiento para las primeras 20 muestras, en las cuales
el filtro adaptativo todavia no se enganch.
4.2.1.

Cdigo fuente de FILTRO2.CPP

// FILTRO2.CPP: cancelacion de interferencias con un filtro adaptativo.

#include <iostream.h>
29

Figura 14: error2 para las primeras 500 iteraciones durante la adaptacin del filtro.

30

Figura 15: La seal superior el ECG original sin ruido ni interferencias, en la seal
central el mismo ECG pero con la interferencia sumada, y finalmente en la seal
inferior la salida del filtro adaptativo, note en esta ltima el comportamiento para
las primeras 20 muestras, en las cuales el filtro adaptativo todavia no se enganch.

31

#include <fstream.h>
#include <math.h>
#include "filtadapt.h"
void main( void) {
int CantidadCoeficientes = 20;
cout << "Orden del filtro adaptativo = ";
cin >> CantidadCoeficientes;
FiltroAdaptativo F(CantidadCoeficientes);
int Number = 4000;
ofstream Salida;
Salida.open("filtro2.txt");
int j;
double Px = 0.0;
double Mean = 0.0;
noise = new double[Number];
double *ecg;
ecg = new double[Number];
double *ecgl;
ecg1 = new double[Number];
double Pi = 3.14;
// Calcula ruido blanco sin valor medio mas ruido
// de senoidal
for( j = 0; j < Number; j++){
noise[j] = double(random(1000))/10000.0;
noise[j] += sin( 1000.0*2.0*Pi*double(j)/double(number));
Mean += noise[j];
}
Mean /= double(Number);
for( j = 0; j < Number; j++){
noise[j] -= Mean;
Px += noise[j]*noise[j]);
}
// Calcula potencia del ruido
Px /= double(Number+1);
double x, y, d, dAnt, dAnt2, e;
char NameInput[80] = "apb.txt";
32

ifstream In;
In.open( NameInput);
if( !In){
cout << "I cant open the file !!!!!";
return
}
double data;
for( j = 0; j < Number; j++){
In >> data;
data /= 10.0;
ecg[j] = data;
ecg[j] += sin(
1000.0*2.0*Pi*double(j)/double(Number));
ecg1[j] = data;
In >> data;
}
// ajuste valor Alfa (coeficiente de velocidad de
convergencia)
// del algoritmo LMS
F.Alfa = 1.0 / (20.0*double(CantidadCoeficientes)*Px);
cout << "Alfa = " << F.Alfa << endl;
// Busca la solucion optima por el metodo LMS
cout << "Busca la solucion optima por el metodo LMS ..." << endl;
dAnt = 0.0;
dAnt2 = 0.0;
for( j = 0; j < Number; j++){
x = noise[j];
y = F(dAnt2);
dAnt = x;
dAnt2 = dAnt;
e = x - y;
// cout << e << endl;
F.CalculaNuevoSet( e);
if( j == 0)
cout << "Error inicial = " << e << endl;
}
cout << "Error final = " << e << endl;
Salida << endl;
Salida << "Filtrado de ruido" << endl;
cout << "Filtrado de ruido..." << endl;
Salida << "ecg\tx\ty" << endl;
dAnt = 0.0;
33

dAnt2 = 0.0;
for( j = 0; j < Number; j++){
x = ecg[j];
y = F(dAnt2);
dAnt = x;
dAnt2 = dAnt;
d = x - y;
Salida << ecgl[j] << "\t" << x << "\t" << d << endl;
dAnt = d;
}
delete noise;
delete ecg;
delete ecgl;
cout << endl << "FIN";
}

4.2.2.

Cdigo fuente de CancelacionRuido.py

import sys
sys.path.append(...)
import math
from random import *
from pylab import *
from FiltroAdaptativo import *
F = FiltroAdaptativo(20)
Number = 4000
ecg = zeros(Number)
ecgOrig = zeros(Number)
ecg1 = zeros(Number)
noise = zeros(Number)
Px = 0.0
Mean = 0.0
# calcula ruido blanco + senoidal
for j in range(Number):
noise[j] = normalvariate(0.0,1.0)/10
noise[j] += math.sin(1000.0*2.0*math.pi*float(j)/float(Number))
Mean += noise[j]
Mean /= float(Number)
34

for j in range(Number):
noise -= Mean
Px += noise[j]*noise[j]
Px /= float(Number+1)

fh = open(apb.txt)
for j in range(Number):
linea = fh.readline()
w = linea.split()
ecgOrig[j] = (float(w[0])-128.0)/10.0
ecg[j] = (float(w[0])-128.0)/10.0 + math.sin(1000.0*2.0*math.pi*float(j)/floa
ecg1[j] = (float(w[1])-128.0)/10.0
x = zeros(Number)
y = zeros(Number)
d = zeros(Number)
dAnt = 0.0
dAnt2 = 0.0
e = zeros(Number)
F.Alfa = 1.0 / (20.0*float(F.Cantidad)*Px)
# adaptacion del filtro adaptativo
for j in range(Number):
x[j] = noise[j]
y[j] = F.put(dAnt2)
dAnt = x[j]
dAnt2 = dAnt
e[j] = x[j] - y[j]
F.CalculaNuevoSet(e[j])
# filtrado del ECG
dAnt = 0.0
dAnt2 = 0.0
for j in range(Number):
x[j] = ecg[j]
y[j] = F.put(dAnt2)
dAnt = x[j]
dAnt2 = dAnt
d[j] = x[j] - y[j]
dAnt = d[j];
plot(ecgOrig[:250]+20,g)
plot(x[:250]+10,b)
35

plot(d[:250],r)
savefig("EjercicioCancelacionRuidoECG.eps")
close()
e2 = e*e
plot(e2[:500])
xlabel(iteraciones)
ylabel($error^2$)
savefig("ErrorCancelacionRuidoECG.eps")
close()

Referencias
[1] Ricardo Armentano, Javier Fochesatto, and Marcelo Risk. Anlisis de Seales
y Sistemas. Editorial Rocamora, 1996.
[2] Perry Greenfield and Robert Jedrzejewski. Using Python for interactive data
analysis. Association of Universities for Research in Astronomy, 2007.
[3] R. W. Lucky. Automatic equalization for digital communication. Bell Systems
Technology Journal, 44:547588, 1965.
[4] Al Stevens and Clayton Walnut. Standard C++ Bible. IDG Books, 2000.
[5] Guido van Rossum and Fred L. Drake. Python tutorial, Release 2.5. Python
Software Foundation, docs@python.org, 2006.
[6] Bernard Widrow, John Glover, John MacCool, John Kaunitz, Charles Williams,
Robert Hearn, James Zeidler, Eugene Dong, and Robert Goodlin. Adaptive noise
cancelling: principles and applications. Proceedings of the IEEE, 63(12):1692
1716, 1975.
[7] Bernard Widrow and Michael Lehr. 30 years of adaptive neural networks: perceptron, madaline, and backpropagation. Proceedings of the IEEE, 78(9):14151442,
1990.

36