Cómo instalar TensorFlow en tu ordenador paso a paso

Si te estás planteando meterte en el mundo del aprendizaje automático y el deep learning, tarde o temprano vas a cruzarte con TensorFlow. Es el framework estrella de Google para crear y entrenar redes neuronales, y la buena noticia es que hoy en día instalarlo es mucho más sencillo de lo que era hace unos años… siempre que sigas algunos pasos clave y respetes las versiones recomendadas.

A lo largo de esta guía te voy a contar, de forma detallada y sin rodeos, cómo instalar TensorFlow correctamente en Linux, macOS, Windows nativo y WSL2, qué tener en cuenta con Python y pip, cómo aprovechar la GPU cuando toca y cómo preparar un entorno de trabajo cómodo con entornos virtuales y herramientas como Visual Studio Code. También verás ejemplos para verificar que todo funciona y pequeñas advertencias que te pueden ahorrar una mañana de quebraderos de cabeza.

Qué es TensorFlow y qué relación tiene con Keras

Antes de liarnos a instalar cosas, conviene tener claro qué estamos montando. TensorFlow es un framework de código abierto para aprendizaje automático, mantenido por Google, que permite definir y entrenar modelos desde redes sencillas hasta arquitecturas profundas muy complejas. Se integra muy bien con otros componentes del ecosistema de Google, como TensorBoard para visualizaciones o las TPU en Colab.

Keras, por su parte, es una API de alto nivel para construir redes neuronales de forma más cómoda. En lugar de escribir todo usando las primitivas de bajo nivel de TensorFlow, Keras te ofrece capas, modelos secuenciales y funcionales, y una sintaxis mucho más amigable para el día a día. Desde TensorFlow 2.x, Keras viene totalmente integrado dentro del propio paquete de TensorFlow.

Esto significa que, cuando instalas TensorFlow con pip, no necesitas instalar Keras por separado. TensorFlow 2.0 y versiones posteriores incluyen la implementación oficial de Keras, accesible a través de tensorflow.keras. Así reduces duplicidades y te aseguras de estar usando versiones compatibles entre sí.

En la práctica, una vez instalado todo, puedes trabajar de dos formas habituales: importar TensorFlow completo o solo las partes que necesitas. Por ejemplo: import tensorflow as tf para tener todo el framework, o bien from tensorflow import keras para centrarte en la API de Keras. Además, es buena práctica importar únicamente las clases específicas que vayas a usar, como from keras.models import Sequential o su equivalente en tensorflow.keras, en lugar de cargar todo el módulo entero sin necesidad.

Requisitos previos: Python, pip y tipos de instalación de TensorFlow

El primer filtro para que todo vaya fino es la versión de Python. TensorFlow y Keras necesitan un Python 3 relativamente moderno. Las guías oficiales han ido cambiando con el tiempo, pero hoy lo razonable es usar un Python dentro del rango 3.9-3.11 (y en versiones anteriores de TensorFlow se recomendaba 3.6-3.8, por ejemplo TensorFlow 2.2 pedía como máximo Python 3.8).

Para ver qué versión tienes instalada, abre una terminal o consola y ejecuta:

python3 --version

La salida debería mostrar algo tipo Python 3.9.7 o similar. Si ves una versión más antigua o todavía tienes Python 2 como principal, tendrás que instalar una versión moderna de Python 3 desde la web oficial, un gestor de paquetes de tu sistema o distribuciones como Anaconda/Miniconda, según el caso.

Además de Python, TensorFlow exige tener un pip actualizado, porque el instalador de paquetes de versiones antiguas puede dar problemas de dependencias o no entender algunas opciones modernas. Puedes actualizar pip con:

python -m pip install --upgrade pip

En cuanto al tipo de instalación, tienes varias vías. La opción recomendada hoy es usar pip y las ruedas oficiales publicadas en PyPI. Algunas distribuciones de Python como ActivePython incluyen TensorFlow y cientos de librerías científicas, pero a nivel práctico, la mayoría de usuarios prefiere tirar de pip y gestionar ambientes virtuales. En Windows, cuando se quiere soporte de GPU, la propia documentación sugiere combinar Miniconda con pip para controlar mejor CUDA y cuDNN.

También hay que decidir si quieres usar CPU, GPU o incluso TPU:

• CPU: funciona en casi cualquier equipo actual. Es la opción más sencilla de configurar, aunque el entrenamiento es más lento.
• GPU: si tienes una gráfica Nvidia (o en algunos casos AMD con soluciones específicas) puedes acelerar muchísimo el entrenamiento, a costa de instalar controladores y librerías extra (CUDA, cuDNN, etc.).
• TPU: están disponibles sobre todo en Google Colab y en la nube de Google; allí no necesitas instalar nada localmente, pero escapa un poco del enfoque de esta guía centrada en tu máquina.

Ten en cuenta también los detalles de licencia: TensorFlow se distribuye bajo licencia Apache 2.0, y mucha documentación y ejemplos de Google están bajo licencias Creative Commons. No afecta a la instalación en sí, pero es útil saberlo si planeas redistribuir código o contenido.

Instalar TensorFlow en Linux (Ubuntu y otras distros)

TensorFlow solo da soporte oficial a Ubuntu de 64 bits, aunque los pasos que vamos a seguir suelen funcionar en otras distribuciones Linux con pequeños ajustes (sobre todo en lo relativo a dependencias del sistema). Además, desde TensorFlow 2.10 existen compilaciones específicas para ARM64/Aarch64 mantenidas por terceros (como AWS) que se instalan automáticamente cuando estás en ese tipo de arquitectura y, para GPUs AMD, suelen emplearse builds con instalación de AMD ROCm.

Como siempre, lo más limpio es aislar todo en un entorno virtual. Python trae de serie el módulo venv para crear entornos, y es el método recomendado por la propia documentación oficial.

Crear y activar un entorno virtual en Linux

Primero, ve a la carpeta donde quieras guardar tus entornos y ejecuta:

python3 -m venv tf

Eso generará una carpeta llamada tf con un Python “independiente”. Para usarlo, actívalo con:

source tf/bin/activate

Verás que en la línea de comandos aparece algo como (tf) delante del prompt, lo que indica que todos los paquetes que instales irán a ese entorno y no al sistema global. A partir de aquí, mantén ese entorno activado durante todo el proceso de instalación.

Instalar TensorFlow con pip en Linux

Con el entorno activado, lo siguiente es actualizar pip y luego instalar TensorFlow. Primero:

pip install --upgrade pip

A continuación, elige según tu caso:

# Si quieres soporte GPU (con CUDA configurado)
pip install "tensorflow"

# Si solo vas a usar CPU
pip install tensorflow

Es importante remarcar que la propia guía oficial desaconseja instalar TensorFlow con conda en Linux, porque los canales pueden ir por detrás de las versiones que salen en PyPI. Lo más fiable es pip directo contra los paquetes oficiales publicados por el equipo de TensorFlow.

Comprobar la instalación en Linux

Para asegurarte de que todo está en su sitio, puedes lanzar una pequeña prueba en la terminal:

python3 -c "import tensorflow as tf; print(tf.reduce_sum(tf.random.normal()))"

Si todo va bien, verás impreso un valor numérico (un tensor reducido a un escalar). Ese resultado indica que TensorFlow se ha instalado correctamente y puede ejecutar operaciones básicas en tu CPU o GPU. Si quieres verificar específicamente la GPU, usa:

python3 -c "import tensorflow as tf; print(tf.config.list_physical_devices('GPU'))"

En este caso deberías obtener una lista de dispositivos GPU detectados. Si aparece una lista vacía, significa que la GPU no se está usando todavía y tendrás que revisar drivers, CUDA, cuDNN o incluso conflictos con instalaciones previas del sistema.

Ajustes extra de GPU en Linux (enlaces simbólicos)

Cuando instalas TensorFlow con GPU en un entorno virtual, a veces las librerías compartidas de Nvidia no se encuentran donde el runtime espera. La documentación oficial plantea una solución basada en crear enlaces simbólicos a las bibliotecas de Nvidia dentro del entorno virtual.

Los pasos típicos son estos (ejecutándolos siempre con el entorno activado):

pushd $(dirname $(python -c 'print(__import__("tensorflow").__file__)'))
ln -svf ../nvidia/*/lib/*.so* .
popd

ln -sf $(find $(dirname $(dirname $(python -c "import nvidia.cuda_nvcc; print(nvidia.cuda_nvcc.__file__)"))/*/bin/) -name ptxas -print -quit) $VIRTUAL_ENV/bin/ptxas

Después de esto, vuelve a lanzar la comprobación de la GPU:

python3 -c "import tensorflow as tf; print(tf.config.list_physical_devices('GPU'))"

Si ahora aparece la lista de GPUs, habrás resuelto el típico problema de detección de componentes CUDA dentro del entorno virtual. Si sigue sin funcionar, toca revisar controladores, versiones de CUDA compatibles con tu versión de TensorFlow o incluso reinstalar desde cero.

Instalar TensorFlow en macOS (Intel y Apple Silicon)

En macOS, la película es parecida, pero con algunos matices. Para empezar, necesitas macOS 10.12.6 (Sierra) o posterior en 64 bits. Aunque TensorFlow soporta Apple Silicon (M1 y sucesores), muchas librerías externas que se apoyan en extensiones C++ personalizadas no están aún compiladas para ARM, por lo que podrías encontrarte con paquetes que funcionan solo bajo emulación x86 con Rosetta.

Además, a día de hoy no hay soporte oficial de GPU para TensorFlow en macOS en la rama principal del proyecto (dejando aparte iniciativas específicas de terceros). En la práctica, eso significa que vas a trabajar con CPU, tanto en equipos Intel como en Apple Silicon, salvo que uses soluciones alternativas.

Comprobar Python y pip en macOS

macOS suele traer una versión antigua de Python 2 y, a veces, alguna versión de Python 3, pero lo recomendable es que instales una versión moderna de Python 3.9-3.11 por tu cuenta (por ejemplo, usando el instalador oficial o Homebrew). Para ver qué tienes ahora mismo:

python3 --version
python3 -m pip --version

Si ves Python 2 como comando principal python y Python 3 como python3, no pasa nada, es lo habitual en muchos Mac. Asegúrate simplemente de usar siempre python3 y pip asociados a esa versión moderna.

En algunos casos, sobre todo en Mac antiguos, te tocará jugar con archivos como .bash_profile o .zshrc para definir alias a la versión correcta de Python y pip. Por ejemplo, puedes añadir algo así:

alias python=python3
alias pip=pip3

Recuerda que el shell por defecto en versiones recientes de macOS es zsh, por lo que las variables y alias que pongas en .bash_profile no se aplicarán a menos que los “enganches” desde .zshrc o trabajes directamente con bash. Es fácil volverse loco pensando que se ha modificado un archivo de inicio que luego no se llega a cargar.

Instalar TensorFlow con pip en macOS

Una vez tengas Python 3 listo, créate un entorno virtual con venv, como hemos visto antes:

python3 -m venv tf
source tf/bin/activate

Con el entorno activado, actualiza pip y luego instala TensorFlow (CPU):

pip install --upgrade pip
pip install tensorflow

El procedimiento es sencillo y, salvo conflictos con versiones antiguas, suele funcionar a la primera. Si alguna dependencia falla, pip te mostrará el mensaje correspondiente y podrás actualizar o instalar el componente que falte.

Verificar la instalación de TensorFlow en macOS

La prueba rápida es la misma que en Linux:

python3 -c "import tensorflow as tf; print(tf.reduce_sum(tf.random.normal()))"

Si ves un número en pantalla, TensorFlow está listo para usar. Como en macOS no hay soporte oficial GPU, no tiene sentido comprobar dispositivos gráficos de la misma forma que en Linux o Windows con Nvidia; el trabajo se hará en CPU.

Instalar TensorFlow en Windows nativo (con y sin GPU)

En Windows las cosas cambian un poco. La primera advertencia importante es que TensorFlow 2.10 fue la última versión en soportar GPU en Windows nativo. A partir de TensorFlow 2.11, si quieres usar la GPU tendrás que pasar por WSL2 o usar otros enfoques como el plugin TensorFlow-DirectML, que está orientado a hardware de Microsoft/AMD (consulta la guía para instalar TensorFlow con GPU en Windows 11).

Además, los binarios de TensorFlow para CPU en Windows, desde la versión 2.10, son proporcionados por Intel como paquetes de terceros (por ejemplo, tensorflow-intel), y se instalan de forma transparente cuando usas los nombres estándar tensorflow o tensorflow-cpu. Estos paquetes se ofrecen “tal cual” y podrían tener ligeros retrasos de actualización respecto al núcleo del proyecto.

Requisitos y preparación del entorno en Windows

Para empezar, necesitas un Windows de 64 bits, versión 7 o superior (aunque en la práctica es muy recomendable usar Windows 10 o 11 actuales) y tener instalado el Microsoft Visual C++ Redistributable para Visual Studio 2015, 2017 y 2019. Desde TensorFlow 2.1.0 se requiere el archivo msvcp140_1.dll, que no viene con redistribuibles más antiguos.

El proceso típico es:

• Ir a la página oficial de descargas de Microsoft Visual C++.
• Buscar la sección correspondiente a Visual Studio 2015, 2017 y 2019.
• Descargar e instalar el redistribuible adecuado para tu plataforma (x64).

También conviene asegurarte de que las rutas largas están habilitadas en Windows, algo que se puede hacer desde la política de grupo o el registro en versiones modernas, para evitar errores con nombres de carpeta muy profundos (bastante frecuentes cuando se usan entornos de desarrollo, Python, etc.).

Instalar Miniconda y crear un entorno para TensorFlow

Aunque podrías instalar TensorFlow directamente con el Python que tengas en el sistema, la documentación recomienda usar Miniconda para gestionar un entorno separado, sobre todo si te interesa la GPU. El flujo es:

conda create --name tf python=3.9

Después, activa y desactiva el entorno cuando lo necesites:

conda activate tf
# ... trabajar con TensorFlow ...
conda deactivate

Trabajar así te permite aislar todas las dependencias de TensorFlow sin tocar el resto del sistema, algo muy útil en Windows donde las rutas y versiones compartidas pueden dar bastantes problemas.

Configurar GPU en Windows con conda (hasta TensorFlow 2.10)

Si tienes una tarjeta NVIDIA y quieres entrenar modelos usando la GPU, tendrás que instalar CUDA y cuDNN en el entorno conda. Desde el propio conda-forge puedes hacerlo con:

conda install -c conda-forge cudatoolkit=11.2 cudnn=8.1.0

Estas versiones concretas son un ejemplo típico que encaja con TensorFlow 2.10 en GPU bajo Windows. Otras combinaciones pueden funcionar, pero conviene seguir las tablas oficiales de compatibilidad para evitar sorpresas.

Instalar TensorFlow en Windows nativo

Con el entorno conda tf activado, el siguiente paso es actualizar pip y luego instalar TensorFlow. Igual que en otras plataformas, se usa pip incluso dentro de conda:

pip install --upgrade pip

Si vas a usar GPU en Windows nativo (recuerda: hasta la versión 2.10), instala una versión por debajo de 2.11:

pip install "tensorflow<2.11"

En caso de que solo quieras usar la CPU, también podrías instalar tensorflow-cpu explícitamente, que tirará igualmente de los paquetes de Intel. No obstante, utilizar el nombre genérico tensorflow es suficiente en la mayoría de escenarios.

Probar TensorFlow en Windows (CPU y GPU)

Para verificar la CPU, ejecuta:

python -c "import tensorflow as tf; print(tf.reduce_sum(tf.random.normal()))"

Si el comando devuelve un número, TensorFlow está instalado y funcionando con la CPU. Para comprobar la GPU, usa:

python -c "import tensorflow as tf; print(tf.config.list_physical_devices('GPU'))"

Si recibes una lista con dispositivos GPU, perfecto: la gráfica está accesible y lista para acelerar tus modelos. Si aparece una lista vacía, toca repasar drivers, versión de CUDA, cuDNN y que la variable de entorno correcta apunte a esas bibliotecas.

Instalar TensorFlow en Windows con WSL2

Debido a las limitaciones de GPU en Windows nativo a partir de TensorFlow 2.11, una alternativa muy interesante es usar WSL2 (Windows Subsystem for Linux). WSL2 permite ejecutar un Linux “real” dentro de Windows 10/11 y aprovechar la GPU con controladores preparados para ello.

Para poder instalar TensorFlow en WSL2 con soporte GPU, necesitas Windows 10 versión 21H2 (build 19044) o superior, o bien Windows 11. Además, deberás instalar los drivers de NVIDIA compatibles con WSL2, que permiten que las aplicaciones dentro de la máquina Linux vean la GPU.

Configurar GPU y comprobar drivers en WSL2

Una vez tengas WSL2 instalado y la distribución Linux configurada, instala los controladores de NVIDIA para WSL2 según la guía oficial. Para confirmar que la GPU está visible dentro del subsistema Linux, ejecuta:

nvidia-smi

Si ves una tabla con el modelo de tu tarjeta, memoria, procesos, etc., el driver está funcionando correctamente dentro de WSL2 y ya puedes seguir con la instalación de TensorFlow como si estuvieras en una máquina Linux normal. Si necesitas instrucciones adicionales para la capa CUDA en WSL2, consulta cómo instalar CUDA en WSL.

Instalar TensorFlow en WSL2 (CPU y GPU)

Dentro de WSL2, los pasos son prácticamente idénticos a los descritos en la sección de Linux. Desde tu distribución (Ubuntu, por ejemplo):

python3 -m venv tf
source tf/bin/activate
pip install --upgrade pip

Y luego elige la instalación adecuada:

# Con GPU en WSL2
pip install "tensorflow"

# Solo CPU
pip install tensorflow

Por último, comprueba que todo está en orden:

python3 -c "import tensorflow as tf; print(tf.reduce_sum(tf.random.normal()))"
python3 -c "import tensorflow as tf; print(tf.config.list_physical_devices('GPU'))"

Si ambas pruebas dan un tensor numérico y una lista con GPUs, respectivamente, tendrás una instalación de TensorFlow moderna, con soporte completo de GPU, corriendo sobre WSL2 y aprovechando el hardware de tu equipo Windows.

Uso de entornos virtuales y organización de proyectos en Python

Trabajar con TensorFlow suele implicar tocar muchas dependencias: NumPy, SciPy, matplotlib, bibliotecas de datos, etc. Para no montar un caos en tu sistema, es fundamental que te acostumbres a usar entornos virtuales para cada proyecto. Así evitarás conflictos de versiones y podrás actualizar librerías sin miedo a romper otros desarrollos.

En Linux y macOS, lo habitual es tirar de python -m venv, como ya hemos visto. En Windows puedes usar tanto venv como entornos conda. En cualquier caso, la idea es la misma: cada proyecto tiene su propio “mini-Python” con sus paquetes, aislado del resto.

Por ejemplo, para crear un entorno llamado .venv dentro de la carpeta de tu proyecto:

python -m venv .venv
source .venv/bin/activate    # Linux / macOS
# o
.venv\Scripts\activate       # Windows

Una vez activado, instalas TensorFlow, Keras (si te hace falta por separado), NumPy, pandas, etc., y te olvidas de afectar al sistema global. Si más adelante quieres actualizar TensorFlow, bastará con ejecutar:

pip install -U tensorflow

y pip se encargará de descargar la nueva versión y sus dependencias, siempre dentro de ese entorno concreto. Puedes comprobar qué versión tienes instalada en cualquier momento con:

python -m pip show tensorflow

La salida mostrará el nombre del paquete, la versión, un pequeño resumen, la licencia, la ruta de instalación y la lista de dependencias requeridas (como google-pasta, six, protobuf, tensorboard, h5py, termcolor, absl-py, opt-einsum, wrapt, grpcio, keras-preprocessing, tensorflow-estimator, numpy, astunparse, wheel, scipy, entre otros). También aparecerá qué otros paquetes dependen de TensorFlow, en caso de que haya alguno.

Instalar y usar TensorFlow con un entorno de desarrollo cómodo

Más allá de la instalación pura y dura, es interesante que configures un entorno de desarrollo agradable para trabajar con Python y TensorFlow. Una de las opciones más populares y ligeras es Microsoft Visual Studio Code (VS Code), disponible para Windows, macOS y Linux.

El flujo habitual sería:

• Descargar e instalar la última versión de VS Code desde la página oficial.
• Abrir el editor y, en la parte de personalización, instalar la extensión oficial de Python.
• Si lo deseas, añadir también paquetes de fragmentos de código (snippets) para TensorFlow y Keras.

Cuando abras una carpeta de proyecto en VS Code, verás en la esquina inferior derecha la selección de intérprete de Python. Desde ahí puedes elegir el Python del entorno virtual donde tienes TensorFlow instalado. Es muy importante no mezclar intérpretes del sistema con entornos virtuales, porque te puedes encontrar con scripts que “no ven” las librerías que creías tener.

Una vez elegido el intérprete correcto, puedes crear un archivo, por ejemplo hola_tensorflow.py, con algo tan sencillo como:

import tensorflow as tf

print(tf.__version__)
print(tf.reduce_sum(tf.random.normal()))

Al ejecutar el archivo desde VS Code (o desde la terminal integrada), verás la versión de TensorFlow y el resultado de la operación de ejemplo. Si esto funciona, tu entorno de desarrollo está listo para empezar a construir modelos más serios, ya sea con scripts sueltos o con notebooks de Jupyter (locales o en Google Colab).

Un detalle práctico: en macOS conviene evitar rutas con espacios o carpetas sincronizadas con iCloud para tus proyectos, ya que a veces generan caminos largos o cambios de ruta poco amigables. Trabajar en una carpeta local sin espacios en la ruta suele ahorrarte problemas con rutas relativas y algunas herramientas antiguas.

Cómo importar y empezar a usar TensorFlow y Keras en tus scripts

Con todo instalado y un editor listo, toca ver cómo se usan realmente las librerías. Para empezar, lo habitual es importar TensorFlow y, si lo necesitas, Keras. Hay varias formas de hacerlo, pero las más comunes son:

# Importar TensorFlow como módulo principal
import tensorflow as tf

# Usar la API de Keras integrada en TensorFlow
from tensorflow import keras

# O importar keras directamente si la tienes instalada
import keras

No es necesario, ni recomendable, hacer importaciones masivas del tipo from tensorflow import *. Lo ideal es importar solo lo que vas a usar. Por ejemplo, si quieres definir un modelo secuencial con capas densas:

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

model = Sequential()

Esta forma de trabajar te da un punto de partida claro: instalas TensorFlow una vez, verificas que todo responde, montas un entorno con un editor cómodo y, a partir de ahí, vas añadiendo solo las piezas de Keras y TensorFlow que necesitas para tu proyecto concreto, sin sobrecargar ni el código ni el entorno.

Con estos pasos ya tienes cubiertas las bases: qué son TensorFlow y Keras, requisitos de Python y pip, instalación en Linux, macOS, Windows nativo y WSL2, configuración de CPU y GPU, uso de entornos virtuales y primeros pasos de importación y prueba en tu entorno de desarrollo. A partir de aquí, el siguiente salto natural es explorar ejemplos fáciles en Python para IA, probar notebooks y empezar a construir modelos que aporten algo de “inteligencia” real a tus aplicaciones, en lugar de quedarte en simples CRUDs sin capacidad de aprendizaje.