El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Arquitectura de Xarxes Neuronals

Següent ►
►

Introducció

Les xarxes neuronals són un component fonamental del Deep Learning i estan inspirades en la manera en què el cervell humà processa la informació. Aquestes xarxes estan compostes per capes de neurones artificials que treballen conjuntament per resoldre problemes complexos. En aquesta secció, explorarem les diferents arquitectures de xarxes neuronals, les seves components i com es poden aplicar a diverses tasques.

Components d'una Xarxa Neuronal

  1. Neurona Artificial:

    • Pesos (Weights): Determinen la importància de cada entrada.
    • Funció d'Activació: Decideix si una neurona s'activa o no.
    • Bias: Un valor addicional que ajuda a ajustar la sortida del model juntament amb els pesos.

  2. Capes:

    • Capa d'Entrada: Rep les dades d'entrada.
    • Capes Ocultes: Processen les dades mitjançant les neurones.
    • Capa de Sortida: Proporciona el resultat final.

Tipus d'Arquitectures de Xarxes Neuronals

  1. Xarxes Neuronals Feedforward (FNN)

Les xarxes neuronals feedforward són les més senzilles i consisteixen en capes d'entrada, ocultes i de sortida. Les dades flueixen en una sola direcció, des de l'entrada fins a la sortida, sense cicles.

Exemple de Codi:

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

# Crear el model
model = Sequential()

# Afegir capes
model.add(Dense(units=64, activation='relu', input_shape=(input_dim,)))
model.add(Dense(units=64, activation='relu'))
model.add(Dense(units=output_dim, activation='softmax'))

# Compilar el model
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

  1. Xarxes Neuronals Convolucionals (CNN)

Les CNN són especialment efectives en tasques de visió per computador. Utilitzen convolucions per extreure característiques de les imatges.

Components Clau:

  • Capes Convolucionals: Aplicar filtres per extreure característiques.
  • Capes de Pooling: Reduir la dimensionalitat de les característiques.

Exemple de Codi:

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense

# Crear el model
model = Sequential()

# Afegir capes convolucionals i de pooling
model.add(Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=(28, 28, 1)))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(64, kernel_size=(3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))

# Afegir capes denses
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dense(10, activation='softmax'))

# Compilar el model
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

  1. Xarxes Neuronals Recurrents (RNN)

Les RNN són adequades per a dades seqüencials, com el text o les sèries temporals. Utilitzen connexions recurrents per mantenir informació de les etapes anteriors.

Components Clau:

  • Unitats Recurrents: Manté l'estat de la seqüència.

Exemple de Codi:

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import SimpleRNN, Dense

# Crear el model
model = Sequential()

# Afegir capes recurrents
model.add(SimpleRNN(50, activation='relu', input_shape=(timesteps, input_dim)))
model.add(Dense(output_dim, activation='softmax'))

# Compilar el model
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

  1. Xarxes Neuronals de Memòria a Llarg i Curt Termini (LSTM)

Les LSTM són una variant de les RNN que poden recordar informació durant períodes més llargs, fent-les útils per a tasques com la traducció automàtica i la predicció de sèries temporals.

Components Clau:

  • Cèl·lules LSTM: Mantenen l'estat de llarg termini.

Exemple de Codi:

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense

# Crear el model
model = Sequential()

# Afegir capes LSTM
model.add(LSTM(50, activation='relu', input_shape=(timesteps, input_dim)))
model.add(Dense(output_dim, activation='softmax'))

# Compilar el model
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

Comparació d'Arquitectures

Arquitectura Avantatges Desavantatges
FNN Senzilla, fàcil d'implementar No adequada per a dades seqüencials o imatges
CNN Excel·lent per a visió per computador Complexitat computacional elevada
RNN Adequada per a dades seqüencials Problemes amb la memòria a llarg termini
LSTM Resol problemes de memòria a llarg termini Més complexa i lenta d'entrenar

Exercici Pràctic

Objectiu: Crear una xarxa neuronal convolucional per classificar imatges de dígits manuscrits (dataset MNIST).

Passos:

  1. Carregar el dataset MNIST.
  2. Preprocessar les dades.
  3. Crear i compilar el model CNN.
  4. Entrenar el model.
  5. Avaluar el model.

Codi:

import tensorflow as tf
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense
from tensorflow.keras.utils import to_categorical

# Carregar el dataset MNIST
(x_train, y_train), (x_test, y_test) = mnist.load_data()

# Preprocessar les dades
x_train = x_train.reshape(x_train.shape[0], 28, 28, 1).astype('float32') / 255
x_test = x_test.reshape(x_test.shape[0], 28, 28, 1).astype('float32') / 255
y_train = to_categorical(y_train, 10)
y_test = to_categorical(y_test, 10)

# Crear el model
model = Sequential()
model.add(Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=(28, 28, 1)))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(64, kernel_size=(3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dense(10, activation='softmax'))

# Compilar el model
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

# Entrenar el model
model.fit(x_train, y_train, epochs=10, batch_size=200, validation_split=0.2)

# Avaluar el model
score = model.evaluate(x_test, y_test, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])

Conclusió

En aquesta secció, hem explorat les diferents arquitectures de xarxes neuronals, incloent-hi les xarxes feedforward, convolucionals, recurrents i LSTM. Cada arquitectura té els seus avantatges i desavantatges, i la seva elecció depèn de la naturalesa del problema a resoldre. Hem proporcionat exemples pràctics de codi per ajudar a comprendre com implementar aquestes arquitectures utilitzant TensorFlow i Keras. En la següent secció, aprofundirem en les aplicacions del Deep Learning i com aquestes arquitectures poden ser utilitzades en el món real.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats