CLASIFICACIÓN DE PARTÍCULAS
MEDIANTE UNA
RED NEURONAL ARTIFICIAL
USO DE UN PECEPTRÓN MULTICAPA PARA DETERMINAR SI UNA
PARTÍCULA POSEE CARGA POSITIVA, NEGATIVA O NEUTRA EN
FUNCIÓN DE VARIOS PUNTOS DE SU TRAYECTORIA AL SER
SOMETIDA A UN POTENCIAL
MOTIVACIÓN
Supongamos que introducimos una partícula en un campo, y que dicho campo tiene asociado un potencial cuyo efecto será diferente sobre la partícula si ésta posee carga positiva, negativa o neutra. En ese caso, la función de posición de la partícula en función del tiempo será esencialmente diferente según se trate de una partícula cargada positivamente, negativamente o no cargada.
No obstante, la trayectoria de todas las partículas de un tipo determinado no será idéntica, pues debemos tener en cuenta asimismo otras variables, como la velocidad con la que entren en el campo, por ejemplo.
Imaginemos que en un laboratorio pudiésemos saber dónde está la partícula en un instante de tiempo determinado, pero no su trayectoria completa. Tendríamos así una serie de puntos. Si todas las partículas con un tipo de carga (por ejemplo, todas las positivas) ocupasen los mismos puntos en los mismos intervalos de tiempo, y ocurriese lo mismo con cada tipo de carga, el problema sería trivial y fácilmente resoluble. No es el caso. Lo que necesitamos es un programa que reconozca patrones en los datos experimentales, un programa que aún cuando se le presenten datos nuevos que no haya procesado anteriormente sepa decirnos si los puntos de trayectoria se
corresponden a los de una partícula positiva, negativa o neutra. Lo que necesitamos es una red neuronal artificial.
En este caso concreto, se va a programar un perceptrón multicapa y su algoritmo de aprendizaje va a ser el algoritmo de propagación hacia atrás.
SIMULACIÓN DE DATOS EXPERIMENTALES
El primer paso es simular los datos experimentales con los que trabajar.
El experimento simulado es el siguiente:
Disponemos de una fuente emisora de partículas que lanza con una velocidad inicial variable una partícula de masa 1 y carga 1, 0 o -1 contra un muro de potencial de la forma:
( )
Cuando la partícula se encuentra a 3m del muro, el aparato comienza a medir la posición de esta cada 0.05 segundos hasta que transcurren 5 segundos. Sabemos asimismo que la partícula, cuando el aparato comienza a medir, tendrá una velocidad de entre 0 m/s y 2 m/s. Es necesario programar, por lo tanto, un script que nos de dichas posiciones medidas para distintas cargas con diferentes velocidades iniciales.
La fuerza que sufre la partícula ante dicho potencial viene dada por la función Pontencial.m, con la siguiente interfaz:
% Name: Potencial.m
% Author: Pablo Cano Llorente. 18-2-2014
function F = Potencial(m, q, x)
% Returns the force acting on a particle inside a potential % V = 1/x^10 + q/x
% Input:
% m = Mass of the particle % q = Charge of the particle % x = Position of the particle
% * We need the mass of the particle because we want to % integrate its trajectory using verlet.m
% Output:
% F = Force acting on the particle
Integrando mediante verlet.m la función Potencial.m con las condiciones
deseadas y tratando por separado cada una de las tres posibles cargas, obtenemos tres matrices de datos definidas por el script Multipuntos.m:
% Name: Multipuntos.m
% Author: Pablo Cano Llorente. 19-2-2014
% Given a input set (m, r0, dt, tmax), a set of initial
% velocities and the force corresponding to a potential of the % form f=Potential (m, q, x), returns the position of three % particles with charge q=+1, q=0 and q=-1 as three matrixes % (Mpos for q=1, Mneut for q=0 and Mneg for q=-1) in wich:
% Columns : Position of a particle in each of the times desired % (0:dt:tmax)
% Rows : Position of the same particle, thrown with different % initial velocities
% Input:
m=1; % Mass of the three particles
r0=3; % Point from which the three particles are thrown
dt=0.05; % Each of the times in wich we want to know the % position of the particle
tmax=5; % Last time in wich we want to know the position of % the particle
v0max=-2; % Highest (in module) initial velocity
dv=0.05; % Each of the following velocities (v0 + i*dv) with % which we want to throw our particle
t=0:dt:tmax; v=v0max:dv:0;
Mpos =zeros(numel(v), numel(t)); Mneut=zeros(numel(v), numel(t)); Mneg =zeros(numel(v), numel(t));
for i=1:numel(v)
v0(i) = v0max+i*dv; q=1;
Mpos(i,:) = verlet (@(m,x)Potencial(m,q,x), m, r0, v0(i), dt, tmax);
q=0;
Mneut(i,:) = verlet (@(m,x)Potencial(m,q,x), m, r0, v0(i), dt, tmax);
q=-1;
Mneg(i,:) = verlet (@(m,x)Potencial(m,q,x), m, r0, v0(i), dt, tmax);
DISEÑO DEL PERCEPTRÓN MULTICAPA
Una red neuronal consiste en un número variable de capas de elementos denominados neuronas interconectados entre las capas por medio de vectores
denominados pesos. Cada neurona dispara un valor determinado como función de los valores de las neuronas de la capa anterior multiplicados por los pesos que conectan ambas capas. A su vez, el valor disparado por una neurona es multiplicado por su peso correspondiente para entrar como input en las neuronas de la capa siguiente. Por norma general, dicho input será el sumatorio del valor disparado por cada neurona multiplicado por el peso correspondiente a dicha neurona.
En el caso del perceptrón multicapa, cada una de las neuronas de una capa está conectada linealmente con cada una de las siguientes y el input de la función que dispara una neurona es el sumatorio de cada uno de los valores disparados por las neuronas de la capa anterior multiplicados por sus pesos correspondientes. Si la capa de neuronas es la capa de entrada, los valores disparados son directamente los valores de los datos.
Para este caso en particular he escogido un perceptrón de tres capas:
Capa de entrada: 101 neuronas correspondientes con las 101 posiciones dadas por el experimento para cada lanzamiento de una partícula. De dichas neuronas, la primera funciona como un bias (tiene un valor constante 3)
Capa oculta: 50 neuronas y 1 bias (valor constante 1)
Capa de salida: 3 neuronas
El valor de las 101 neuronas de entrada es multiplicado por los vectores
correspondientes para entrar como sumatorio input a las neuronas de la capa oculta. Las neuronas de la capa oculta pasan dicho input a la función sigmoidal, de la forma:
( )
Los outputs de las neuronas de la capa oculta son multiplicados por otros vectores peso correspondientes, que pasan como input a las neuronas de la capa de salida. Dichas neuronas pasan dicho input a la función sigmoidal y devuelven cada una un valor determinado.
ENTRENAMIENTO DEL PERCEPTRÓN MULTICAPA
Queremos que la red neuronal nos de la siguiente interfaz:
Ante una partícula positiva, f(1)≈1 f(2)≈0 f(3)≈0
Ante una partícula neutra, f(1)≈0 f(2)≈1 f(3)≈0
Ante una partícula negativa, f(1)≈0 f(2)≈0 f(3)≈1
Para ello, debemos ajustar los vectores peso de la red neuronal mediante lo que se denomina un algoritmo de aprendizaje, que en nuestro caso conviene que sea automático.
El algoritmo escogido es el denominado como algoritmo de propagación hacia atrás, que ha sido desarrollado en trainingnet.m
Prefiero abrir aparte trainingnet.m y explicarlo directamente sobre el editor de Matlab debido al tamaño y complejidad subyacente de dicho script.
Con la finalidad de que trainingnet.m funcione, es necesario cargar previamente el script datosin.m, que tiene la interfaz:
% Name: datosin.m
% Author: Pablo Cano Llorente.
% Calls Multipuntos.m and generates all initial data % necessary to start training our net
Multipuntos % Returns three matrixes (Mpos, Mneut and Mneg)
w=rand(51,101,1)./10; % Returns a matrix of valid random weights w
z=rand(3,51,1)./10; % Returns a matrix of valid random weights z
p=1; % p is the third dimension coefficient of % the weight vectors matrixes
%( w(:,:,p), z(:,:,p) )
a=0.0001; % Coefficient a used in backpropagation % algorithm
b=0.25; % Coefficient b used in backpropagation % algorithm
y fundamentalmente carga todos los datos necesarios para que trainingnet.m pueda ser iniciada.
El proceso queda automatizado con autonet.m
% Name: autonet.m
% Author: Pablo Cano Llorente.
datosin % Sets initial data
trainingnet % Trains our net for that data
k(1)=p; % Auxiliar vector k(r)=p
r=2;
trainingnet % Trains again our net for that data
k(r)=p;
% Trains the net until w and z classify correctly each of the % data layers of Mpos, Mneut and Mneg
while k(r)~=k(r-1) % If p of w and z vectors hasn't changed, % stop.
% Otherwise, k(r)=k(r-1) and while loop ends
r=r+1; trainingnet k(r)=p; end
Lo que el script autonet.m hace es generar los datos necesarios para que
trainingnet.m corra y correr trainingnet.m una y otra vez hasta que los pesos no varíen, que será cuando clasifiquen correctamente todas y cada una de las líneas de datos.
USO DEL PERCEPTRÓN MULTICAPA
Una vez el perceptrón ha sido entrenado, ya está listo para ser utilizado en la clasificación de partículas dentro de los márgenes de nuestro experimento hipotético.
Dado que no disponemos de los datos de un experimento real, debemos generarlos para una partícula de una carga y velocidad inicial determinadas.
Para ello, definimos q y v0 en la ventana de comandos de Matlab y corremos xgen.m, script con la interfaz:
% Name: xgen.m
% Author: Pablo Cano Llorente.
% Given charge of the particle (q) and initial velocity of the % particle (v0), integers Potencial using verlet and returns the % position of the particle as a vector x
m=1; % Mass of the three particles
r0=3; % Point from which the three particles are thrown
dt=0.05; % Each of the times in wich we want to know the % position of the particle
tmax=5; % Last time in wich we want to know the position of % the particle
x=zeros(1,101);
x(1,:) = verlet (@(m,x)Potencial(m,q,x), m, r0, v0, dt, tmax)
Una vez tenemos las posiciones asociadas a la partícula que queremos clasificar, es hora de definir un nuevo script: testnet.m, que nos clasifique la partícula usando los pesos ya entrenados.
% Name: testnet.m
% Author: Pablo Cano Llorente.
% Given positions vector x as input vector, returns whether if that
% positions vector corresponds to a positive, a negative or a neutral
% charge.
% NET MUST BE TRAINED!
for j=1:50
n(j)=1/(1+exp(-dot(x,w(j,:,p)))); % Hidden neurons layer output
n(51)=1; % Bias
end for k=1:3
f(k)=1/(1+exp(-dot(n(:,:,:),z(k,:,p)))); % Output neurons layer % output
end
% Classifies the particle
if f(1)>f(2)+f(3)
disp('PARTÍCULA POSITIVA') elseif f(2)>f(1)+f(3)
disp('PARTÍCULA NEUTRA') elseif f(3)>f(1)+f(2)
disp('PARTÍCULA NEGATIVA') else
disp('INCIERTO') end
Para cualquier linea de datos introducida como input a testnet.m, la red la clasificará casi instantáneamente gracias al entrenamiento recibido.
BIBLIOGRAFÍA
Tanto Internet como la biblioteca de la Escuela Politécnica de la UAM contienen información muy útil a la hora de aprender a diseñar y programar una red neuronal. En especial, he de destacar dos fuentes:
Fundamentals of Neural Networks, Laurenne Fausset
