CREAR UN PERCEPTRÓN con SQL-T

PERCEPTRÓN.

Los tipos de dato se generan para que al momento de crear IA con Perceptrones

evitar codificar la creación de tablas que actuarán como los Arrays

/*     ╔═══════════════════════════════════════════╗

       ║ CREA EL TIPO DE DATO DE UN PERCEPTRÓN     ║

       ╚═══════════════════════════════════════════╝ */

CREATE TYPE Perceptron AS TABLE

(

 Id                        SMALLINT NOT NULL IDENTITY (1,1),

 IndiceCapa                TINYINT  NOT NULL,

 NumeroDeNeuronas          TINYINT  NOT NULL

);

GO

/*     ╔════════════════════════════════════════════════════════╗

       ║ CREA EL TIPO DE DATO PARA ALMACENAR LAS NEURONAS       ║

       ╚════════════════════════════════════════════════════════╝ */

CREATE TYPE Neuronas AS TABLE

(

 i                                TINYINT             NOT NULL,

 j                                TINYINT             NOT NULL,

 ValorFuncion       DECIMAL (18,8)      NULL,

 ValorUmbral        DECIMAL (18,8)      NULL

);

GO

/*     ╔══════════════════════════════════════════════════════════╗

       ║ CREA EL TIPO DE DATO DE PARA RELACIONAR LAS OMEGAS       ║

       ╚══════════════════════════════════════════════════════════╝ */

CREATE TYPE Omegas  AS TABLE

 (

  Indice_W          TINYINT,

  Neurona_Ai TINYINT,

  Neurona_Aj TINYINT,

  Neurona_Pi TINYINT,

  Neurona_Pj TINYINT

  );

 GO

 -- Cuando se declarara un Perceptron y se carga, se envía a ésta función para generar las N neuronas en sus respectivos índices

-- Regresa una tabla con sus Neuronas en una Mattriz (i,j)

 IF OBJECT_ID('DBO.fn_GetNeuronas') IS NOT NULL DROP FUNCTION DBO.fn_GetNeuronas;

 GO

 CREATE FUNCTION DBO.fn_GetNeuronas

  (

   @Perceptron      Perceptron   READONLY

  )

 RETURNS @Neuronas TABLE

  (

       i                   TINYINT         NOT NULL,

       j                   TINYINT         NOT NULL,

       ValorFuncion        DECIMAL (18,8)  NULL,

       ValorUmbral         DECIMAL (18,8)  NULL

  )

BEGIN

 

       DECLARE @i                 TINYINT

       DECLARE @j                 TINYINT

       SET @i = 1;

             WHILE (@i<= (SELECT MAX(IndiceCapa) from @Perceptron))

                    BEGIN

                           SET @j = 1;

                           WHILE (@j <= (SELECT NumeroDeNeuronas from @Perceptron WHERE IndiceCapa = @i))

                                  BEGIN                                  

                                        INSERT INTO @Neuronas (i,j)

                                        SELECT @i, @j

                                        SET @j = @j +1;

                                  END

                           SET @i = @i + 1;

                    END

 RETURN

END

   GO

-- Una vez que se tiene la Matriz de Neuronas

-- Se envía a ésta función para generar las n Combinaciones de Omegas que puedan existir.

 IF OBJECT_ID('DBO.fn_GetOmegas') IS NOT NULL DROP FUNCTION DBO.fn_GetOmegas;

 GO

 CREATE FUNCTION DBO.fn_GetOmegas

  (

   @Neuronas Neuronas     READONLY

  )

 RETURNS @Omegas TABLE

  (

       Indice_W            TINYINT,

       Neurona_Ai          TINYINT,

       Neurona_Aj          TINYINT,

       Neurona_Pi          TINYINT,

       Neurona_Pj          TINYINT

  )

 BEGIN

             DECLARE @Contador          TINYINT

             DECLARE @NumOmegas         TINYINT

             -- El contador inicia con 1 ya que las capas de las Neuronas comienzan también con 1 N[k] Inicial = 1;

             SET @Contador = 1;

             SET @NumOmegas = (SELECT NumOmegas = MAX (i)-1 FROM @Neuronas);

            

             -- PARA GENERAR EL PRIMER  OMEGA       

             -- El primer SELECT selecciona todas las Neuronas del Indice N[k] = 1  del contador = @Contador = 1;

             -- Y genera un CROSS JOIN para hacer todas las combinaciones contra las Neuronas del Indice N[k+1] => 2 => @Contador + 1

             --

             -- Para generar los omegas subsecuentes, solamente basta con incrementar el contador y tener un WHILE

             -- para cambiar de N[K] a N[k]+1   y volver a insertar...

                    WHILE (@Contador <= @NumOmegas)

                           BEGIN

                                  INSERT INTO @Omegas        -- Inserta la capa de Omegas  N[k]  <-- vs --> N[k+1]

                                  SELECT DISTINCT                

                                   W = n.i

                                  ,Ai = n.i

                                  ,Aj = N.j

                                  ,[Pi] = ca.i

                                  ,Pj = ca.j         

                                  FROM   @Neuronas    AS N   -- Esto selecciona N[k]

                                  CROSS JOIN

                                                      (

                                                       SELECT      DISTINCT x.j, x.i

                                                       FROM  @Neuronas    AS X

                                                       WHERE x.i = @Contador + 1        -- Esto selecciona N[k+1]

                                                      ) as ca

                                  WHERE   N.I = @Contador

                                  SET @Contador = @Contador + 1;

                           END

             RETURN

 END

GO

Para generar un Perceptrón como el de la imágen superior, se realiza de la siguiente Manera:

/*     ╔═══════════════════════════════════════════╗

       ║     CREA LA ESTRUCTURA DEL PERCEPTRÓN     ║

       ╚═══════════════════════════════════════════╝ */

--

-- SE CONSIDERA INICIAR CON LA CAPA DE ENTRADA CON UN INDICE = [1];  SIEMPRE!

DECLARE @Perceptron AS Perceptron;

INSERT INTO @Perceptron VALUES (1,3); -- Capa N[1] se tienen 3 Neuronas de Entrada

INSERT INTO @Perceptron VALUES (2,4)  -- Capa N[2] se tienen 4 Neuronas como capa intermedia

INSERT INTO @Perceptron VALUES (3,4)  -- Capa N[3] se tienen 4 Neuronas como capa intermedia

INSERT INTO @Perceptron VALUES (4,2)  -- Capa N[4] se tienen 2 Neuronas de Salida

éste tipo de dato con estructura de tipo tabla es la que indica cómo es la estructura del Perceptrón.

Ahora, se llama a la función que Genera la "Matriz" de las Neuronas indicadas por el Perceptron.

DECLARE @Neuronas   NEURONAS;

INSERT INTO @Neuronas;

SELECT *      FROM   dbo.fn_GetNeuronas (@Perceptron);

Esto es lo que contiene la variable @Neuronas

La función genera la matriz y se insertan en la variable...

Luego se declara un tipo de Dato Omegas que es una tabla donde se insertan las n combinaciones

DECLARE @Omegas     OMEGAS

INSERT INTO @Omegas

SELECT *      FROM dbo.fn_GetOmegas (@Neuronas);

SELECT *      FROM   @Omegas

Cada omega 1 = Indice_W contiene la combinación entre una Neurona y la otra

    N[k]     w[p]     N[k+1]

Neurona Ai          Neurona Pi

              W

Neurona Aj          Neurona Pj

i = índice de las capas de las Neuronas

ej:

i = 1   => índice de la capa de entrada

i = 4   >= índice de la capa de salida

j = índice de las Neuronas que se encuentran hacia abajo dentro de cualquier capa N