Usuario:
Concepto de Layers (Capas)
Imagen 
La clave de un sistema neuronal es la introducción de layers (capas) de nodos que van de un layer de entrada (input) vía los layers intermedios o ocultos (hidden) hasta el layer de salida (output):
Un sistema básico tiene un layer intermedio lo que le permite atender consultas simples tipo AND (y) y OR (o) pero no del tipo XOR que requiere mas de un layer intermedio.
Cuando existe más de un layer interno hablamos de deep learning (aprendizaje profundo).
ID:(10382, 0)
Cargar Tensorflow
Descripción
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.models import Sequential
# load model
from tensorflow.keras.models import load_model
from tensorflow.keras.layers import Activation, Dense
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.metrics import categorical_crossentropy
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.preprocessing import image
from tensorflow.keras.models import Model
from tensorflow.keras.applications import imagenet_utils
from sklearn.metrics import confusion_matrix
ID:(10384, 0)
Definición de Layers (Capas) simple
Imagen
Una vez se tiene el modelo se puede crear la primera layer (capa), que es la oculta, que esta completamente conectado por lo que se usa el método dense (denso) y se define con
```
const hidden = tf.layers.dense(configHidden);
```
en que debemos previamente configurar el layer indicando
- el numero de nodos units,
- el numero de nodos de los que depende inputShape, y
- la forma como son activados activation:
Si se suponen 4 nodos, que dependen de 2 nodos de input y si se usa el método de activación sigmoid (pasa de 0 a 1 en forma paulatina cuando la variable cambia de signo) la configuración sería:
```
const configHidden = {
units: 4,
inputShape: [2],
activation: 'sigmoid'
}
```
Se puede crear una segunda layer (capa) como aquella de salida en forma análoga:
```
const output = tf.layers.dense(configOutput);
```
en que la configuración de la layer de salida sería
```
const configOutput = {
units: 3,
activation: 'sigmoid'
}
```
y se le pueden agregar al modelo usando la función add.
```
model.add(configHidden);
model.add(configOutput);
```
En la configuración del output no es necesario indicar el inputShape ya que este se determina en forma automática.
ID:(10383, 0)
Compilar el Modelo
Descripción
model.compile(
optimizer=Adam(learning_rate=0.0001),
loss='categorical_crossentropy',
metrics=['accuracy']
)
ID:(10385, 0)
Entrenar el Modelo
Imagen
Para entrenar el modelo se debe obtener datos para aplicar que en este caso en un tensor de input
const xs = tf.tensor2d([...]);
y datos de output
const ys = tf.tensor2d([...]);
Con estos dato se puede realizar el entrenamiento mediante
train().then() => {
let output = model.predict(xs);
outputs.print();
console.log('training complete');
con la función
async funtion train() {
for (let i = 0;i < 1000; i++) {
const config = {
shuffle : true,
epochs: 10
}
const response = await model.fit(xs, ys, config);
console.log(response.history.loss[0]);
}
}
ID:(10386, 0)
Problema del XOR
Concepto
Si existen dos nodos
1 La proposición lógica AND (y)
$n_1$ | $n_2$ | $n_0$
---------|----------|----------
V | V | V
V | F | F
F | V | F
F | F | F
que se puede modelar con
2 La proposición lógica OR (o)
$n_1$ | $n_2$ | $n_0$
---------|----------|----------
V | V | V
V | F | V
F | V | V
F | F | F
que se puede modelar con
3 La proposición lógica XOR
$n_1$ | $n_2$ | $n_0$
---------|----------|----------
V | V | F
V | F | V
F | V | V
F | F | F
que no se puede modelar como una ecuación en
ID:(10387, 0)