Tutorial de TensorFlow para principiantes
TensorFlow é un dos marcos de traballo máis populares para a aprendizaxe profunda e a aprendizaxe automática. Desenvolvido polo equipo de Google Brain, TensorFlow utilizouse amplamente en numerosos proxectos de investigación e aplicacións industriais. Este artigo ofrece un tutorial paso a paso para axudarche, como principiante, a comezar a usar TensorFlow.
1. Entender os conceptos básicos de TensorFlow
Antes de comezar a instalar e usar TensorFlow, é importante comprender que é TensorFlow e os conceptos básicos que o sustentan. TensorFlow é un marco de código aberto para computación numérica e aprendizaxe automática. Emprega gráficos de fluxo de datos para realizar operacións numéricas, onde os nodos do gráfico representan operacións matemáticas e as arestas representan matrices de datos multidimensionais (tensores) conectadas entre elas.
2. Instalación de TensorFlow
O primeiro paso para usar TensorFlow é instalalo. Aquí tes como instalar TensorFlow usando pip, o xestor de paquetes de Python.
1. Instalación de Python:
Asegúrate de ter Python instalado no teu sistema. TensorFlow é compatible con Python 3.6 a 3.9 no momento de escribir isto. Podes descargar Python desde o sitio web oficial de Python.
2. Entorno virtual:
É moi recomendable crear un entorno virtual para illar o teu proxecto de TensorFlow:
"`sh"
python -m venv myenv
fonte myenv/bin/activate Para usuarios de Mac/Linux
myenv\Scripts\activate Para usuarios de Windows
“
3. Instalación de TensorFlow:
Agora, instala TensorFlow usando pip:
"`sh"
instalación de pip en tensorflow
“
3. Ola mundo con TensorFlow
Agora que TensorFlow está instalado, imos crear un script sinxelo de Python para verificar a instalación. Crea un novo ficheiro de Python e chámao `hello_tensorflow.py`.
"pitón"
importar tensorflow como tf
Crear unha constante
ola = tf.constant('Ola, TensorFlow!')
Iniciar sesión
con tf.Session() como sesión:
resultado = sesión.run(ola)
imprimir (resultado)
“
Adapta o código segundo a versión 2.x de TensorFlow:
"pitón"
importar tensorflow como tf
Crear unha constante
ola = tf.constant('Ola, TensorFlow!')
Executar usando a execución impaciente (activada por defecto)
imprimir(ola.numpy())
“
Garda o ficheiro e logo executa:
"`sh"
python ola_tensorflow.py
“
4. Comprensión dos tensores e as operacións básicas
Os tensores son a estrutura de datos principal en TensorFlow, que son matrices multidimensionais. Aquí tes algúns exemplos para axudarche a comprender os tensores:
"pitón"
importar tensorflow como tf
Creando tensores
escalar = tf. constante(7) escalar
vector = tf. constante([1, 2, 3]) vector
matriz = tf. constante([[1, 2], [3, 4]]) matriz
tensor3d = tf.constant([[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]]) Tensor 3D
imprimir(f'Escalar: {escalar}')
imprimir(f'Vector: {vector}')
imprimir(f'Matriz: {matriz}')
imprimir(f'Tensor 3D: {tensor3d}')
“
Para realizar operacións básicas con tensores:
"pitón"
a = tf.constante([[1, 2], [3, 4]])
b = tf.constante([[5, 6], [7, 8]])
Operación de suma
sumar = tf.sumar(a, b)
Operacións de multiplicación de matrices
mul = tf.matmul(a, b)
imprimir(f'Suma: {sumar}')
imprimir(f'Multiplicación de matrices: {mul}')
“
5. Creación dun modelo de rede neuronal simple
O seguinte paso é crear un modelo de rede neuronal sinxelo. Construiremos un modelo de clasificación de imaxes usando o conxunto de datos MNIST, unha base de datos de imaxes de díxitos escritos a man. Comecemos:
"pitón"
importar tensorflow como tf
desde tensorflow.keras importar conxuntos de datos, capas e modelos
Descarga do conxunto de datos MNIST
(imaxes_tren, etiquetas_tren), (imaxes_proba, etiquetas_proba) = conxuntos_de_datos.mnist.cargar_datos()
Normalización da imaxe
imaxes_do_tren, imaxes_de_proba = imaxes_do_tren / 255.0, imaxes_de_proba / 255.0
Facer unha maqueta
modelo = modelos.Secuencial([
capas.Aplanar(forma_de_entrada=(28, 28)),
layers.Dense(128, activation='relu'),
capas.Densa(10)
])
Compilación de modelos
modelo.compilar(optimizador='adam',
perda=tf.keras.perdas.EntropíaCrosadaCategoricaDispersa(de_logits=Verdadeiro),
métricas=['precisión'])
Adestramento do modelo
modelo.axuste(imaxes_do_tren, etiquetas_do_tren, épocas=5)
Probando o modelo
perda_de_proba, acc_de_proba = modelo.avaliar(imaxes_de_proba, etiquetas_de_proba)
imprimir(f'Precisión da proba: {test_acc}')
“
Explicación:
– Conxuntos de datos: Importamos e cargamos o conxunto de datos MNIST.
– Preprocesamento: Normalizar o conxunto de datos dividindo os valores dos píxeles por 255.
– Modelo: Definimos un modelo simple con dúas capas. A primeira capa é unha capa `Flatten` para converter a imaxe 2D nunha matriz 1D. A segunda capa é unha capa `Densa` con 128 neuronas e `relu` como función de activación, e a última é unha capa `Densa` con 10 neuronas que representan 10 clases.
– Compilar: Compilamos o modelo usando o optimizador `adam` e `SparseCategoricalCrossentropy` como función de perda.
– Adestrar: Adestra o modelo para 5 épocas.
– Avaliar: Avaliar o modelo cos datos de proba.
6. Gardar e cargar modelos
Despois de adestrar un modelo, pode que queiras gardalo para usalo máis tarde sen ter que volver adestralo. Aquí tes como gardar e cargar un modelo:
"pitón"
Gardando o modelo
modelo.gardar('o_meu_modelo.h5')
Cargando modelo
novo_modelo = tf.keras.modelos.cargar_modelo('o_meu_modelo.h5′)
Verificación do modelo cargado
perda, acc = novo_modelo.avaliar(imaxes_de_proba, etiquetas_de_proba)
print(f'Precisión do modelo cargado: {acc}')
“
Conclusión
Esta guía ofrece unha introdución detallada para comezar a usar TensorFlow para principiantes. Abordamos a instalación, as operacións tensoriais básicas e a creación dun modelo de rede neuronal sinxelo usando o conxunto de datos MNIST. TensorFlow ofrece moitas capacidades avanzadas para explorar, como o procesamento avanzado de datos, modelos máis complexos e o uso de TensorFlow en dispositivos como TPU e GPU. Agardamos que este tutorial che axude a comezar no mundo da aprendizaxe automática con TensorFlow.
