En aquest tema, explorarem com desenvolupar projectes pràctics utilitzant xarxes neuronals. Aprendrem a dissenyar, entrenar i avaluar models de xarxes neuronals per a diferents aplicacions. També veurem alguns exemples pràctics i realitzarem exercicis per consolidar els coneixements adquirits.

Objectius d'Aprenentatge

  • Comprendre el procés de desenvolupament d'un projecte de xarxes neuronals.
  • Aprendre a dissenyar i implementar xarxes neuronals utilitzant eines i llibreries populars.
  • Avaluar el rendiment dels models de xarxes neuronals.
  • Aplicar xarxes neuronals a problemes reals.

  1. Introducció als Projectes de Xarxes Neuronals

1.1. Fases d'un Projecte de Xarxes Neuronals

Un projecte de xarxes neuronals típicament segueix les següents fases:

  1. Definició del Problema: Identificar el problema a resoldre i els objectius del projecte.
  2. Recopilació i Preparació de Dades: Obtenir les dades necessàries i preparar-les per al model.
  3. Disseny del Model: Seleccionar l'arquitectura de la xarxa neuronal adequada.
  4. Entrenament del Model: Entrenar la xarxa neuronal amb les dades preparades.
  5. Avaluació del Model: Avaluar el rendiment del model utilitzant mètriques adequades.
  6. Implementació i Desplegament: Implementar el model en un entorn de producció.

1.2. Eines i Llibreries Populars

Algunes de les eines i llibreries més utilitzades per desenvolupar projectes de xarxes neuronals són:

  • TensorFlow: Una llibreria de codi obert per a l'aprenentatge automàtic desenvolupada per Google.
  • Keras: Una API de xarxes neuronals de codi obert escrita en Python, que s'executa sobre TensorFlow.
  • PyTorch: Una llibreria de codi obert per a l'aprenentatge automàtic desenvolupada per Facebook.

  1. Exemple Pràctic: Classificació d'Imatges amb Xarxes Neuronals

2.1. Definició del Problema

Volem construir un model de xarxa neuronal capaç de classificar imatges de dígits manuscrits (dataset MNIST).

2.2. Recopilació i Preparació de Dades

Utilitzarem el dataset MNIST, que conté 60,000 imatges de dígits manuscrits per a entrenament i 10,000 imatges per a prova.

import tensorflow as tf
from tensorflow.keras.datasets import mnist
from tensorflow.keras.utils import to_categorical

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

# Normalitzar les dades
x_train = x_train.astype('float32') / 255
x_test = x_test.astype('float32') / 255

# Convertir les etiquetes a one-hot encoding
y_train = to_categorical(y_train, 10)
y_test = to_categorical(y_test, 10)

2.3. Disseny del Model

Dissenyarem una xarxa neuronal simple amb una capa d'entrada, una capa oculta i una capa de sortida.

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

# Crear el model
model = Sequential()
model.add(Flatten(input_shape=(28, 28)))
model.add(Dense(128, activation='relu'))
model.add(Dense(10, activation='softmax'))

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

2.4. Entrenament del Model

Entrenarem el model amb les dades d'entrenament.

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

2.5. Avaluació del Model

Avaluarem el rendiment del model utilitzant les dades de prova.

# Avaluar el model
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f'Test accuracy: {test_acc}')

2.6. Implementació i Desplegament

Un cop el model ha estat entrenat i avaluat, es pot implementar en un entorn de producció per a la seva utilització.

  1. Exercicis Pràctics

Exercici 1: Classificació de Flors amb Xarxes Neuronals

Utilitzant el dataset Iris, dissenya i entrena una xarxa neuronal per classificar les diferents espècies de flors.

Exercici 2: Reconeixement de Veus amb Xarxes Neuronals

Utilitzant un dataset de mostres de veu, dissenya i entrena una xarxa neuronal per reconèixer diferents parlants.

Exercici 3: Predicció de Preus d'Habitatges amb Xarxes Neuronals

Utilitzant un dataset de preus d'habitatges, dissenya i entrena una xarxa neuronal per predir el preu d'un habitatge basant-se en les seves característiques.

Solucions dels Exercicis

Solució Exercici 1

# Importar llibreries necessàries
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.utils import to_categorical

# Carregar el dataset Iris
iris = load_iris()
x = iris.data
y = to_categorical(iris.target, 3)

# Dividir el dataset en entrenament i prova
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=42)

# Normalitzar les dades
scaler = StandardScaler()
x_train = scaler.fit_transform(x_train)
x_test = scaler.transform(x_test)

# Crear el model
model = Sequential()
model.add(Dense(64, activation='relu', input_shape=(4,)))
model.add(Dense(3, activation='softmax'))

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

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

# Avaluar el model
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f'Test accuracy: {test_acc}')

Solució Exercici 2

# Aquest exercici requereix un dataset de mostres de veu, que no està inclòs aquí.
# Es recomana utilitzar llibreries com librosa per carregar i processar les mostres de veu.

Solució Exercici 3

# Importar llibreries necessàries
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

# Carregar el dataset de preus d'habitatges
data = pd.read_csv('housing.csv')
x = data.drop('price', axis=1).values
y = data['price'].values

# Dividir el dataset en entrenament i prova
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=42)

# Normalitzar les dades
scaler = StandardScaler()
x_train = scaler.fit_transform(x_train)
x_test = scaler.transform(x_test)

# Crear el model
model = Sequential()
model.add(Dense(64, activation='relu', input_shape=(x_train.shape[1],)))
model.add(Dense(1))

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

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

# Avaluar el model
test_loss = model.evaluate(x_test, y_test)
print(f'Test loss: {test_loss}')

Conclusió

En aquesta secció, hem après a desenvolupar projectes de xarxes neuronals des de la definició del problema fins a la implementació i desplegament del model. Hem vist exemples pràctics i hem realitzat exercicis per consolidar els coneixements adquirits. Ara estem preparats per aplicar xarxes neuronals a una àmplia varietat de problemes reals.

© Copyright 2024. Tots els drets reservats