Proyecto Final – QM2515

Neurona: Una Explicación con Matemáticas

Una neurona es la unidad básica de una red neuronal, y su funcionamiento se basa en la combinación lineal de entradas ponderadas, seguida de la aplicación de una función de activación no lineal. Aquí te proporcionaré una descripción detallada con las matemáticas asociadas:

Estructura de una Neurona:

Entradas ((x_1, x_2, …, x_n)): Representan las características o señales de entrada. Cada entrada está ponderada por un peso.

Pesos ((w_1, w_2, …, w_n)): Son parámetros ajustables que indican la importancia relativa de cada entrada para la neurona. Se asocia un peso a cada conexión de entrada.

Sumador Ponderado ((z)): La suma ponderada de las entradas y los pesos. Se calcula como:

$z=\sum_{i=1}^n(x_i\cdot w_i)+b$z=n∑i=1(xi​·wi​)+b​

Donde (b) es el sesgo (un parámetro adicional que proporciona cierto grado de flexibilidad a la neurona). (Esto se parece mucho a una regresión Lineal)

Función de Activación ((f)):

Introduce no linealidad en la salida de la neurona. La salida de la neurona ((a)) se calcula aplicando la función de activación al sumador ponderado:

$a=f(z)$a=f(z)​

Matemáticas Detalladas:

Sumador Ponderado:

[𝑧=∑𝑖=1𝑛(𝑥𝑖⋅𝑤𝑖)+𝑏][z=i=1∑n​(xi​⋅wi​)+b]

(x_i) son las entradas.

(w_i) son los pesos asociados a las entradas.

(b) es el sesgo.

Función de Activación:

La función de activación introduce no linealidad y determina la salida de la neurona. [ a = f(z) ] Algunas funciones de activación comunes son la función sigmoide, la función tangente hiperbólica (tanh), y la función de rectificación lineal (ReLU).

Funcionamiento General:

1. Entrada y Pesos: Las entradas ((x_i)) y los pesos ((w_i)) representan la información que la neurona procesa.
2. Sumador Ponderado: La neurona calcula la suma ponderada ((z)) de las entradas y los pesos, incluyendo el sesgo.
3. Función de Activación: La salida ((a)) se obtiene aplicando una función de activación al sumador ponderado ((z)).
4. Salida de la Neurona: La salida de la neurona se utiliza como entrada para las siguientes capas en una red neuronal.

Ejemplo con Función Sigmoide:

Si utilizamos la función de activación sigmoide

$((f(z)=\frac{1}{1+e^{-z}}))$((f(z)=11+e−z​))​

la salida de la neurona sería:

[𝑎=11+𝑒−(∑𝑖=1𝑛(𝑥𝑖⋅𝑤𝑖)+𝑏)][a=1+e−(∑i=1n​(xi​⋅wi​)+b)1​]

Esto representa la probabilidad de activación de la neurona.

Resumen:

• Una neurona realiza una combinación lineal ponderada de entradas, seguida de la aplicación de una función de activación no lineal.
• Los pesos determinan la influencia de cada entrada en la salida.
• La función de activación introduce no linealidad y permite a la red aprender patrones complejos.

Este es el concepto básico de una neurona en una red neuronal. En redes más complejas, múltiples neuronas trabajan en conjunto para aprender y representar patrones en los datos.

Hay varias formas de crear una red neuronal con Python, y la elección depende de diversos factores, como la complejidad del problema, el nivel de control que necesitas sobre la arquitectura de la red y tu familiaridad con las herramientas. A continuación, se presentan algunas de las formas comunes:

1. TensorFlow y Keras:

• Descripción: TensorFlow es una biblioteca de aprendizaje automático de código abierto desarrollada por Google. Keras es una interfaz de alto nivel que se ejecuta sobre TensorFlow y facilita la construcción y entrenamiento de redes neuronales.
• Ventajas:
• Facilidad de uso con Keras.
• Amplia comunidad y documentación.
• Compatibilidad con GPU para entrenamiento acelerado.
• Ejemplo:

  import tensorflow as tf
  from tensorflow import keras

  model = keras.Sequential([
      keras.layers.Dense(128, activation='relu', input_shape=(input_dim,)),
      keras.layers.Dropout(0.5),
      keras.layers.Dense(10, activation='softmax')
  ])

2. PyTorch:

• Descripción: PyTorch es una biblioteca de aprendizaje automático de código abierto desarrollada por Facebook. Se centra en la programación dinámica, lo que facilita la construcción y experimentación con modelos de redes neuronales.
• Ventajas:
• Flexibilidad y extensibilidad.
• Adopción creciente en la comunidad de investigación.
• Ejemplo:

  import torch
  import torch.nn as nn

  class SimpleNN(nn.Module):
      def __init__(self, input_dim, hidden_dim, output_dim):
          super(SimpleNN, self).__init__()
          self.layer1 = nn.Linear(input_dim, hidden_dim)
          self.relu = nn.ReLU()
          self.layer2 = nn.Linear(hidden_dim, output_dim)

      def forward(self, x):
          x = self.layer1(x)
          x = self.relu(x)
          x = self.layer2(x)
          return x

3. Scikit-Learn:

• Descripción: Scikit-learn es una biblioteca de aprendizaje automático que proporciona herramientas sencillas y eficientes para análisis de datos y modelado predictivo. Aunque no es tan especializada como TensorFlow o PyTorch, es adecuada para problemas más simples.
• Ventajas:
• Sintaxis simple y fácil de usar.
• Integración con otras herramientas de análisis de datos.
• Ejemplo:

  from sklearn.neural_network import MLPClassifier

  model = MLPClassifier(hidden_layer_sizes=(100,), max_iter=1000)

4. Keras (standalone):

• Descripción: Keras también se puede utilizar como una biblioteca independiente sin depender de TensorFlow. En este caso, se utiliza el back-end de Keras para proporcionar la implementación de bajo nivel.
• Ventajas:
• Simplifica la construcción de redes neuronales.
• Compatible con varias bibliotecas de backend, incluyendo TensorFlow y Theano.
• Ejemplo:

  from keras.models import Sequential
  from keras.layers import Dense

  model = Sequential()
  model.add(Dense(128, activation='relu', input_shape=(input_dim,)))
  model.add(Dense(10, activation='softmax'))

Estas son solo algunas de las opciones disponibles para construir redes neuronales en Python. La elección entre ellas dependerá de tus necesidades específicas, preferencias y nivel de experiencia.

Las capas son bloques fundamentales en la construcción de redes neuronales, y diferentes tipos de capas desempeñan roles específicos en el procesamiento de datos. A continuación, se describen algunos tipos comunes de capas en una red neuronal junto con explicaciones detalladas:

1. Capa de Entrada (Input Layer):

• Función:
• Recibe las características de entrada y transmite la información a las capas ocultas.
• Características:
• No realiza ningún cálculo.
• Tiene tantas neuronas como características de entrada.
• Ejemplo:

  from keras.layers import Input
  input_layer = Input(shape=(input_dim,))

2. Capa Densa (Fully Connected o Dense Layer):

• Función:
• Cada neurona en esta capa está conectada a todas las neuronas de la capa anterior.
• Realiza una combinación lineal de las entradas ponderadas y aplica una función de activación.
• Características:
• Cada conexión tiene un peso asociado.
• Ejemplo:

  from keras.layers import Dense
  dense_layer = Dense(units=128, activation='relu')

3. Capa de Activación:

• Función:
• Introduce no linealidad al aplicar una función de activación a la salida de las neuronas.
• Características:
• Puede ser colocada después de una capa densa u otra capa que produzca una salida.
• Ejemplo:

  from keras.layers import Activation
  activation_layer = Activation('relu')

4. Capa de Dropout:

• Función:
• Aleatoriamente “apaga” (pone a cero) algunas unidades durante el entrenamiento para prevenir el sobreajuste.
• Características:
• Introduce regularización al modelo.
• Ejemplo:

  from keras.layers import Dropout
  dropout_layer = Dropout(rate=0.5)

5. Capa de Salida (Output Layer):

• Función:
• Produce la salida final de la red neuronal.
• Características:
• Número de neuronas depende del tipo de problema (clasificación binaria, clasificación multiclase, regresión, etc.).
• Ejemplo:

  from keras.layers import Dense
  output_layer = Dense(units=num_classes, activation='softmax')

6. Capa Convolucional (Convolutional Layer):

• Función:
• Utilizada en redes neuronales convolucionales (CNN) para el procesamiento de datos bidimensionales, como imágenes.
• Aplica filtros convolucionales a regiones locales de la entrada.
• Características:
• Conserva la estructura espacial de los datos.
• Ejemplo:

  from keras.layers import Conv2D
  conv_layer = Conv2D(filters=32, kernel_size=(3, 3), activation='relu')

7. Capa de Agrupación (Pooling Layer):

• Función:
• Reduce la dimensionalidad espacial de la entrada para reducir la cantidad de parámetros y cálculos.
• Características:
• Operaciones comunes: Max pooling, Average pooling.
• Ejemplo:

  from keras.layers import MaxPooling2D
  pooling_layer = MaxPooling2D(pool_size=(2, 2))

Estos son solo algunos ejemplos de tipos de capas en una red neuronal. La elección de las capas y su arquitectura dependerá del tipo de tarea que estés abordando y la naturaleza de tus datos. Experimentar con diferentes configuraciones de capas y funciones de activación es una parte esencial del desarrollo de modelos de redes neuronales efectivos.

Algunos ejemplos adicionales de tipos de capas que se utilizan comúnmente en el diseño de redes neuronales:

8. Capa de Normalización por Lotes (Batch Normalization Layer):

• Función:
• Normaliza la salida de una capa anterior para estabilizar y acelerar el entrenamiento.
• Características:
• Mejora la convergencia y reduce la dependencia de la inicialización de pesos.
• Ejemplo:

  from keras.layers import BatchNormalization
  batch_norm_layer = BatchNormalization()

9. Capa de Concatenación (Concatenation Layer):

• Función:
• Concatena las salidas de varias capas.
• Características:
• Útil para modelos con múltiples entradas o salidas.
• Ejemplo:

  from keras.layers import Concatenate
  concat_layer = Concatenate(axis=-1)

10. Capa de Atención (Attention Layer):

• Función:
• Permite a la red centrarse en partes específicas de la entrada.
• Características:
• Común en modelos de procesamiento de lenguaje natural.
• Ejemplo:

  from keras.layers import Attention
  attention_layer = Attention()

11. Capa Embebida (Embedding Layer):

• Función:
• Utilizada para mapear enteros (índices de palabras) a vectores densos de palabras.
• Características:
• Útil en tareas de procesamiento de lenguaje natural.
• Ejemplo:

  from keras.layers import Embedding
  embedding_layer = Embedding(input_dim=vocab_size, output_dim=embedding_dim)

12. Capa de Residuos (Residual Layer):

• Función:
• Introduce conexiones de salto para ayudar al modelo a aprender funciones residuales.
• Características:
• Ayuda a aliviar el problema de la desaparición del gradiente.
• Ejemplo:

  from keras.layers import Add
  residual_layer = Add()

13. Capa de Transformador (Transformer Layer):

• Función:
• Basada en la arquitectura de transformer, es utilizada para modelar relaciones en datos secuenciales.
• Características:
• Muy común en tareas de procesamiento de lenguaje natural.
• Ejemplo:

  from keras.layers import MultiHeadAttention
  transformer_layer = MultiHeadAttention()

14. Capa de Gradiente Reversible (Reversible Gradient Layer):

• Función:
• Permite calcular el gradiente de manera reversible, útil para entrenar modelos con memoria limitada.
• Características:
• Útil en modelos con restricciones de memoria.
• Ejemplo:

  from keras.layers import ReversibleBlock
  reversible_layer = ReversibleBlock()

Estos ejemplos representan solo una fracción de las capas disponibles en diversas bibliotecas de redes neuronales en Python. La elección de la capa dependerá del problema que estés abordando y de las características específicas que requiera tu modelo.

Existen diversos tipos de redes neuronales diseñadas para abordar diferentes tipos de problemas en el ámbito del aprendizaje automático y la inteligencia artificial. Aquí te proporcionaré una visión general de algunos tipos comunes de redes neuronales, para qué sirven y cuándo es apropiado utilizarlos:

1. Redes Neuronales de Alimentación Adelante (Feedforward Neural Networks):

• Propósito: Son la forma más básica de redes neuronales, donde la información fluye en una dirección, desde la capa de entrada hasta la capa de salida.
• Uso: Apropiadas para problemas de clasificación y regresión sencillos cuando no hay dependencias temporales o patrones complejos en los datos.

2. Redes Neuronales Convolucionales (Convolutional Neural Networks – CNN):

• Propósito: Diseñadas para procesar datos con estructura de cuadrícula, como imágenes. Utilizan capas de convolución para aprender patrones locales.
• Uso: Ideal para tareas de visión por computadora, reconocimiento de imágenes, segmentación de imágenes y problemas relacionados con datos en forma de cuadrícula.

3. Redes Neuronales Recurrentes (Recurrent Neural Networks – RNN):

• Propósito: Diseñadas para trabajar con datos secuenciales, donde la entrada tiene una relación temporal. Mantienen una memoria interna para procesar secuencias de datos.
• Uso: Útiles para tareas como procesamiento de lenguaje natural (NLP), pronóstico de series temporales, traducción automática y otros problemas con datos temporales.

4. Redes Neuronales de Memoria a Corto y Largo Plazo (Long Short-Term Memory – LSTM):

• Propósito: Una variante de RNN que aborda el problema de desvanecimiento del gradiente en RNN estándar, permitiendo la retención de información a largo plazo.
• Uso: Útiles cuando se requiere recordar patrones a largo plazo, como en tareas de NLP y series temporales más complejas.

5. Redes Generativas Adversarias (Generative Adversarial Networks – GAN):

• Propósito: Comprenden dos redes, un generador y un discriminador, que compiten entre sí. El generador crea datos nuevos y el discriminador evalúa su autenticidad.
• Uso: Para generar datos sintéticos realistas, como en la creación de imágenes, mejora de resolución de imágenes, y generación de contenido creativo.

6. Redes Neuronales Siamesas:

• Propósito: Diseñadas para comparar dos entradas y determinar si son similares o diferentes. Tienen aplicaciones en tareas de emparejamiento y verificación de similitud.
• Uso: En problemas de reconocimiento facial, verificación de documentos y sistemas de recomendación personalizados.

7. Redes Neuronales de Atención (Attention Networks):

• Propósito: Permiten a la red enfocarse en partes específicas de la entrada, asignando pesos diferentes a diferentes partes de la entrada.
• Uso: Muy efectivas en tareas de procesamiento de lenguaje natural, traducción automática y cualquier tarea que requiera un enfoque selectivo en partes específicas de la entrada.

La elección de la red neuronal depende en gran medida de la naturaleza del problema que estás abordando y la naturaleza de tus datos. Es común experimentar con diferentes arquitecturas para encontrar la que mejor se adapte a tus necesidades.

Crearemos una red neuronal sencilla (de una neurona para convertir grados Centígrados a grados Fahrenheit)

1. Importar Bibliotecas:

import tensorflow as tf
import numpy as np

2. Preparar Datos:

Generemos algunos datos de ejemplo para entrenar nuestra red. Crearemos un rango de temperaturas en grados Celsius y sus correspondientes valores en Fahrenheit.

celsius = np.array([-40, -10, 0, 8, 15, 22, 38], dtype=float)
fahrenheit = np.array([-40, 14, 32, 46, 59, 72, 100], dtype=float)

3. Definir el Modelo las Capas y el Modelo:

Vamos a crear un modelo de red neuronal con una sola neurona.

capa = tf.keras.layers.Dense(units=1, input_shape=[1])
modelo = tf.keras.Sequential([capa])

4. Compilar el Modelo:

Configuramos el modelo para la fase de entrenamiento especificando el optimizador y la función de pérdida.

modelo.compile(
    optimizer=tf.keras.optimizers.Adam(0.1), # 0.1 representa el valor de corrección
    loss="mean_squared_error"
)

Adam: Adam es un algoritmo de optimización popular que se utiliza para ajustar los pesos de una red neuronal durante el entrenamiento. Se adapta de forma dinámica las tasas de aprendizaje para cada parámetro, lo que lo hace eficiente y efectivo en muchos casos. El valor 0.1 que pasas como argumento es la tasa de aprendizaje, que controla cuánto se deben ajustar los pesos en cada iteración del entrenamiento.

Mean Squared Error (Error Cuadrático Medio): Esta función de pérdida se utiliza comúnmente en problemas de regresión. Calcula la diferencia cuadrática promedio entre las predicciones del modelo y los valores reales. El objetivo durante el entrenamiento es minimizar esta pérdida.

5. Entrenar el Modelo:

Entrenamos el modelo utilizando los datos de temperatura Celsius y Fahrenheit.

print("Comenzando entrenamiento...")
historial = modelo.fit(celsius, fahrenheit, epochs=1000, verbose=True)
print("Modelo entrenado!")

Aquí, estamos utilizando 1000 épocas para realizar el aprendizaje (puedes usar verbose = False para no ver los datos del entrenamiento y los ajustes.

6. Hacer Predicciones e Imprimiendo el resultado:

Después de entrenar el modelo, podemos hacer predicciones utilizando nuevas temperaturas en grados Celsius.

print ("hagamos una predicción")
resultado = modelo.predict([100.0]) #Puedes cambiar el valor de 100.0 a otro número
print("El resultado es " + str(resultado) + "fahrenheit")

7. Viendo los pesos y los sesgos de la red

Finalmente, veremos los pesos y los sesgos que utilizó mi red neuronal (de una neurona y una capa)

print ("Variales internas del modelo")
print (capa.get_weights())

Este es un ejemplo sencillo de cómo puedes crear y entrenar una red neuronal con TensorFlow y Keras para realizar una tarea de conversión simple. Recuerda que, para tareas más complejas, podrías necesitar arquitecturas más avanzadas y ajustar los hiperparámetros.

Preguntas

1. Prueba escribir un programa en python que haga lo mismo pero sin usar una red neuronal ¿Cómo se comparan los resultados obtenidos por la red neuronal con el valor predicho por la ecuación de conversión?
2. ¿Son los valores de pesos (m) y sesgos (b) obtenidos por la red neuronal similares a los obtenidos de forma convencional?

Probemos ahora modificar la red neuronal anterior agregando más neuronas y más capas para ver que sucede:

import tensorflow as tf
import numpy as np

oculta1 = tf.keras.layers.Dense(units=3, input_shape=[1])
oculta2 = tf.keras.layers.Dense(units=3)
salida = tf.keras.layers.Dense(units=1)
modelo = tf.keras.Sequential([oculta1, oculta2, salida])

modelo.compile(
    optimizer=tf.keras.optimizers.Adam(0.1),
    loss='mean_squared_error'
)

print("Comenzando entrenamiento...")
historial = modelo.fit(celsius, fahrenheit, epochs=1000, verbose=False)
print("Modelo entrenado!")

import matplotlib.pyplot as plt
plt.xlabel("# Epoca")
plt.ylabel("Magnitud de pérdida")
plt.plot(historial.history["loss"])

print("Hagamos una predicción!")
resultado = modelo.predict([100.0])
print("El resultado es " + str(resultado) + " fahrenheit!")

print("Variables internas del modelo")
#print(capa.get_weights())
print(oculta1.get_weights())
print(oculta2.get_weights())
print(salida.get_weights())

Ahora haremos el mismo código anterior pero ahora usando Pytorch. El código modificado sería el siguiente:

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt

# Convertir datos de Numpy a Tensores de PyTorch
celsius = np.array([-40, -10, 0, 8, 15, 22, 38], dtype=np.float32)
fahrenheit = np.array([-40, 14, 32, 46, 59, 72, 100], dtype=np.float32)

# Convertir a tensores
celsius_tensor = torch.tensor(celsius)
fahrenheit_tensor = torch.tensor(fahrenheit)

# Definir la arquitectura del modelo en PyTorch
class Modelo(nn.Module):
    def __init__(self):
        super(Modelo, self).__init__()
        self.oculta1 = nn.Linear(1, 3)
        self.oculta2 = nn.Linear(3, 3)
        self.salida = nn.Linear(3, 1)

    def forward(self, x):
        x = torch.relu(self.oculta1(x))
        x = torch.relu(self.oculta2(x))
        x = self.salida(x)
        return x

# Crear una instancia del modelo
modelo = Modelo()

# Definir la función de pérdida y el optimizador en PyTorch
criterio = nn.MSELoss()
optimizador = optim.Adam(modelo.parameters(), lr=0.1)

# Entrenar el modelo
num_epochs = 1000
historial_pérdida = []

for epoch in range(num_epochs):
    # Forward pass
    predicciones = modelo(celsius_tensor.view(-1, 1))
    pérdida = criterio(predicciones, fahrenheit_tensor.view(-1, 1))

    # Backward pass y optimización
    optimizador.zero_grad()
    pérdida.backward()
    optimizador.step()

    # Guardar la pérdida para su visualización
    historial_pérdida.append(pérdida.item())

# Visualizar la pérdida a lo largo de las épocas
plt.plot(historial_pérdida)
plt.xlabel("# Época")
plt.ylabel("Magnitud de pérdida")
plt.show()

# Hacer una predicción
modelo.eval()
with torch.no_grad():
    resultado_tensor = modelo(torch.tensor([100.0]))
    resultado = resultado_tensor.item()
    print("El resultado es {:.2f} Fahrenheit!".format(resultado))

Este código utiliza PyTorch en lugar de TensorFlow y Keras. Recuerda que las operaciones y la sintaxis pueden ser diferentes entre las dos bibliotecas, por lo que ajusté el código para que sea compatible con PyTorch. Este modelo es bastante simple, pero puedes adaptarlo según tus necesidades específicas.

Scikit-Learn no tiene un módulo específico para redes neuronales como TensorFlow o Keras. Sin embargo, puedes utilizar la implementación de regresión lineal de Scikit-Learn para crear un modelo sencillo. Aquí tienes una adaptación del código usando Scikit-Learn para una regresión lineal:

import numpy as np
from sklearn.linear_model import LinearRegression
import matplotlib.pyplot as plt

# Convertir datos de Numpy a arreglos bidimensionales
celsius = np.array([-40, -10, 0, 8, 15, 22, 38], dtype=np.float32).reshape(-1, 1)
fahrenheit = np.array([-40, 14, 32, 46, 59, 72, 100], dtype=np.float32)

# Crear y entrenar el modelo de regresión lineal
modelo = LinearRegression()
modelo.fit(celsius, fahrenheit)

# Hacer predicciones
predicciones = modelo.predict(celsius)

# Visualizar el ajuste
plt.scatter(celsius, fahrenheit, color='blue', label='Datos reales')
plt.plot(celsius, predicciones, color='red', linewidth=2, label='Ajuste lineal')
plt.xlabel('Celsius')
plt.ylabel('Fahrenheit')
plt.title('Regresión Lineal para Conversión de Temperatura')
plt.legend()
plt.show()

# Hacer una predicción
temperatura_nueva = np.array([[100.0]])
resultado = modelo.predict(temperatura_nueva)
print("El resultado es {:.2f} Fahrenheit!".format(resultado[0]))

En este código, utilizamos la clase LinearRegression de Scikit-Learn para crear un modelo de regresión lineal. Luego, entrenamos el modelo con los datos de temperatura y hacemos predicciones. La visualización muestra los datos reales y la línea de ajuste lineal. La última sección realiza una predicción para 100.0 grados Celsius e imprime el resultado en Fahrenheit.

Ten en cuenta que este modelo es simple y lineal, y para tareas más complejas, podrías necesitar explorar bibliotecas más avanzadas como TensorFlow o PyTorch.

Puedes simplificar el código para usar solamente Keras en lugar de TensorFlow y Keras, ya que Keras se ha integrado directamente en TensorFlow. Aquí está el código modificado:

from keras.models import Sequential
from keras.layers import Dense
import numpy as np
import matplotlib.pyplot as plt

# Convertir datos de Numpy a Tensores de Keras
celsius = np.array([-40, -10, 0, 8, 15, 22, 38], dtype=np.float32)
fahrenheit = np.array([-40, 14, 32, 46, 59, 72, 100], dtype=np.float32)

# Definir el modelo en Keras
modelo = Sequential([
    Dense(units=3, input_shape=[1]),
    Dense(units=3),
    Dense(units=1)
])

# Compilar el modelo
modelo.compile(optimizer='adam', loss='mean_squared_error')

# Entrenar el modelo
historial = modelo.fit(celsius, fahrenheit, epochs=1000, verbose=False)
print("Modelo entrenado!")

# Visualizar la pérdida a lo largo de las épocas
plt.xlabel("# Época")
plt.ylabel("Magnitud de pérdida")
plt.plot(historial.history["loss"])
plt.show()

# Hacer una predicción
resultado = modelo.predict(np.array([100.0]))
print("El resultado es {:.2f} Fahrenheit!".format(resultado[0][0]))

En este código, hemos eliminado la importación de TensorFlow y hemos utilizado las clases Sequential y Dense directamente desde el módulo keras.models y keras.layers, respectivamente. También hemos cambiado el optimizador a 'adam', que es el optimizador por defecto en Keras.

Este código realiza la misma tarea que el original, pero utilizando únicamente las funcionalidades de Keras que están integradas en TensorFlow.

Crea tu propia red neuronal usando la librería que tu quieras (Tensorflow, Pytorch, Scikit-Learn o Keras) y utilizala para calcular la concentración de una muestra problema a partir de los siguientes espectros UV-Visible con concentraciones conocidas.

Ahora piensa un poco en como modificar el código anterior pero ahora para que los datos de entrenamiento del modelo sean los espectros obtenidos y el al cargar el espectro de la muestra problema diga la concentración.

Ayuda:

1. Piensa primero en tu set de datos (Puedes importarlos como si fueras a graficarlos todos) y en su etiquetado (esta es la entrada).
2. Piensa ahora en tu salida (debería darte la concentración)
3. Piensa ahora en el tamaño de la red y en el tipo de red (Puedes usar las capas ocultas que quieras, pero el tamaño de entrada dependerá de la cantidad de datos existentes (nm y absorbancia)).
4. Piensa en agregar una función de activación (la función de activación introduce elementos no lineales a la red, para hacerla no lineal) y la función de perdida a utilizar.
5. Entrena tu red y has una predicción.