Cómo instalar TensorFlow con GPU en Windows 11 paso a paso

Configurar TensorFlow para que aproveche de verdad la GPU en Windows 11 puede convertirse en una pequeña odisea si vas a ciegas: versiones que no encajan, errores raros, guías desfasadas y conflictos con instalaciones previas de Python, CUDA o cuDNN. Si alguna vez has pensado “¿por qué narices TensorFlow sigue tirando de CPU teniendo una GPU potente?”, este tutorial está pensado precisamente para ti.

Tras recopilar y unificar la información de varias guías oficiales y prácticas reales, vas a ver cómo dejar funcionando TensorFlow con GPU en Windows 11 de forma fiable usando entornos virtuales (Conda/Miniconda) y verás ejemplos en Python para IA, qué combinaciones de versiones funcionan, qué opciones tienes si tu GPU es NVIDIA (CUDA) o si quieres tirar de DirectML (AMD, Intel, NVIDIA) y cómo comprobar que todo está bien configurado. La idea es que, cuando termines, tengas un entorno estable y aislado, sin romper otras instalaciones de Python ni proyectos.

Requisitos de hardware y opciones de aceleración en Windows 11

Antes de instalar nada es clave saber qué tipo de aceleración quieres usar y si tu hardware es compatible. Principalmente tienes dos caminos en Windows 11 para usar la GPU con TensorFlow: el clásico stack de NVIDIA (CUDA + cuDNN) o el plugin TensorFlow-DirectML-Plugin, que funciona sobre DirectX 12 y admite GPUs NVIDIA, AMD e Intel.

Si tienes una GPU NVIDIA con soporte CUDA (por ejemplo, una GeForce RTX 2060, RTX 3060 o similar) puedes seguir el enfoque tradicional con CUDA y cuDNN, que es el que mejor se integra con TensorFlow 2.10 en Windows nativo. Este método depende mucho de casar bien las versiones: drivers, CUDA Toolkit, cuDNN, Python y TensorFlow. Para instrucciones prácticas sobre la instalación del toolkit CUDA puedes consultar guías específicas sobre CUDA + cuDNN.

En cambio, si tu GPU es AMD o Intel, o simplemente quieres una opción más flexible, TensorFlow-DirectML-Plugin permite usar la GPU a través de DirectML en Windows 10/11, tanto en modo nativo como bajo WSL. En este caso no dependes de CUDA/cuDNN, sino del soporte DirectX 12 y de los drivers actualizados de tu tarjeta.

Resumen de requisitos mínimos típicos en Windows para DirectML (según la documentación de Microsoft) incluye: Windows 10 versión 1709 o superior, o Windows 11 21H2 o superior; Python 3.7 a 3.10 en 64 bits; y una GPU compatible como AMD Radeon R5/R7/R9 2xx o posterior, Intel HD Graphics 5xx o posterior o NVIDIA GeForce GTX 9xx o superior. Si vas a usar CUDA directamente, céntrate en una GPU NVIDIA con arquitectura CUDA 3.5 o superior y drivers actuales.

En todos los casos es obligatorio tener los últimos drivers de GPU instalados. En Windows puedes comprobar actualizaciones desde “Configuración > Windows Update > Buscar actualizaciones” y, para NVIDIA, también desde la aplicación GeForce Experience o la web oficial de drivers.

Elección de versiones: por qué TensorFlow 2.10 es la clave en Windows

Uno de los mayores quebraderos de cabeza al instalar TensorFlow con GPU en Windows 11 es que no todas las versiones se llevan bien entre sí. A partir de TensorFlow 2.11, el soporte para CUDA en Windows nativo desaparece; por eso, en la práctica, TensorFlow 2.10 es la última versión estable que puedes usar con GPU vía CUDA en Windows sin recurrir a WSL o Docker.

En una configuración probada en Windows 11 con CPU Intel Core i7-11800H, GPU NVIDIA GeForce RTX 3060 Laptop, 16 GB de RAM, se utilizó TensorFlow 2.10 con Python 3.10 dentro de Conda, CUDA 11.2 y cuDNN 8.1, aunque el sistema tenía instalados de forma global Python 3.12.6 y CUDA 12.3. Esta separación se logró precisamente gracias al uso de un entorno virtual de Conda.

TensorFlow 2.10 es especialmente delicado con NumPy: no funciona con NumPy 2.x, así que es importante mantener NumPy 1.23.5 u otra versión 1.x soportada. Si ya tenías NumPy 2 instalado en el entorno, deberás reinstalar la versión adecuada antes de instalar TensorFlow.

Si trabajas con versiones históricas, TensorFlow 1.15 diferenciaba entre paquetes CPU y GPU, con nombres distintos en pip (tensorflow y tensorflow-gpu). A partir de TensorFlow 2.x, el paquete pip tensorflow ya trae soporte GPU integrado cuando se cumplen los requisitos de CUDA/cuDNN, aunque en Windows ese soporte se limita de facto a la rama 2.10.

Para quienes opten por DirectML, la combinación recomendada por Microsoft es usar tensorflow-cpu==2.10 como base y añadir luego el paquete tensorflow-directml-plugin, que activa de forma automática el backend DirectML sin cambiar tu código.

Instalar y preparar Miniconda en Windows 11

La forma más limpia de evitar conflictos entre versiones de Python, TensorFlow, CUDA y cuDNN es trabajar con entornos virtuales. Miniconda es una opción ligera y muy cómoda para crear estos entornos aislados en Windows 11, manteniendo intactas las instalaciones globales.

Primero necesitas descargar el instalador de Miniconda para Windows 64 bits (la versión para arquitectura x86-64). El instalador suele venir como archivo .exe. Durante la instalación es muy recomendable que no marques la opción de “Añadir Miniconda a PATH” para evitar interferencias con otras instalaciones de Python que pudieras tener.

Una vez completado el asistente de instalación, reinicia el ordenador para asegurarte de que todo se registra correctamente. Después, abre un terminal (CMD o PowerShell) y comprueba que conda está disponible ejecutando:

conda --version

Si ves un resultado del estilo conda 25.1.1 o similar, significa que Miniconda se ha instalado correctamente y ya puedes empezar a crear entornos virtuales específicos para TensorFlow con GPU.

Crear un entorno Conda para TensorFlow 2.10 y GPU NVIDIA

Con Miniconda funcionando, el siguiente paso es crear un entorno aislado para instalar TensorFlow 2.10 junto con todas sus dependencias CUDA/cuDNN. Así conseguirás que los cambios no afecten al resto de proyectos ni al Python global del sistema.

Abre Anaconda Prompt o PowerShell con soporte de Conda y crea un entorno nuevo, por ejemplo llamado tf-2.10, con Python 3.10:

conda create --name tf-2.10 python=3.10

Cuando termine la creación del entorno, inicializa Conda en tu shell para poder activarlo cómodamente ejecutando:

conda init

Tras ese comando, cierra y vuelve a abrir la ventana de PowerShell o CMD para que los cambios surtan efecto. Entonces ya puedes activar el entorno recién creado con:

conda activate tf-2.10

Con el entorno tf-2.10 activo, todo lo que instales con pip o conda quedará encapsulado ahí, sin mezclarse con otras instalaciones. Es dentro de este entorno donde vas a instalar NumPy, TensorFlow 2.10 y las bibliotecas CUDA/cuDNN necesarias.

Instalar TensorFlow 2.10, NumPy compatible, CUDA y cuDNN en Conda

TensorFlow 2.10 tiene requisitos muy concretos de librerías. Lo primero es asegurarte de que NumPy no esté en la rama 2.x dentro del entorno tf-2.10. Si sospechas que se ha instalado una versión incompatible, puedes fijar la versión correcta así:

pip install numpy==1.23.5

Una vez tengas NumPy en una versión aceptada, instala TensorFlow 2.10 desde pip dentro del mismo entorno:

pip install tensorflow==2.10

Como se ha comentado antes, TensorFlow 2.10 para Windows nativo está ligado a CUDA 11.2 y cuDNN 8.1. Para simplificar la vida y no tener que pelear con instaladores globales de NVIDIA, puedes instalar estas librerías directamente en el entorno de Conda utilizando el canal conda-forge:

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

Con este enfoque, no dependes de que el CUDA Toolkit global de tu máquina coincida con lo que requiere TensorFlow. De hecho, puedes tener, por ejemplo, CUDA 12.3 instalado en Windows para otras tareas, y a la vez usar un CUDA 11.2 “virtual” dentro de tf-2.10 sin que choquen entre sí.

Ten presente que la guía oficial de TensorFlow también describe un procedimiento “clásico” para instalar CUDA y cuDNN a nivel de sistema, añadiendo sus rutas al PATH de Windows. Si decides seguir ese método tradicional, tendrás que cuidar que las versiones instaladas coincidan exactamente con las que exige TensorFlow, y asegurarte de que el archivo cuDNN64_8.dll está presente y accesible.

Instalación clásica de drivers NVIDIA, CUDA Toolkit 11.2 y cuDNN 8.1

Si prefieres o necesitas tener CUDA/cuDNN instalados globalmente en Windows 11, hay una secuencia lógica muy utilizada que también ha sido probada en Windows 10 con GPUs como la GeForce RTX 2060. Este enfoque se basa en el stack oficial de NVIDIA y se apoya en algunas herramientas adicionales.

Lo primero es contar con un compilador de Microsoft Visual C++, ya que CUDA Toolkit se integra con Visual Studio para compilar ciertos componentes. La forma más sencilla es instalar Microsoft Visual Studio con el conjunto de herramientas de C++ activado.

A continuación, instala los drivers más recientes para tu GPU NVIDIA desde la web de descargas oficial de NVIDIA, seleccionando tu modelo concreto (por ejemplo, GeForce RTX 2060) y el sistema operativo Windows correspondiente. El instalador suele ofrecer un modo de instalación rápida; en la práctica, basta con ir aceptando y avanzando.

Con los drivers en su sitio, puedes pasar a instalar CUDA Toolkit 11.2 desde el archivo de versiones archivadas de NVIDIA. Allí escoges la rama 11.2, tu sistema operativo (Windows) y el tipo de instalador (.exe). Durante la instalación es habitual optar por un modo “personalizado”, pero en la mayoría de casos se puede dejar la configuración por defecto simplemente pulsando siguiente y aceptar.

El siguiente paso es ocuparse de cuDNN 8.1, la librería específica para redes neuronales profundas. Para descargarla, necesitas estar registrado en el portal de desarrolladores de NVIDIA. Una vez dentro, accedes al archivo de versiones de cuDNN y eliges la variante que coincide con CUDA 11.2 para Windows.

El paquete de cuDNN no es un instalador clásico, sino un archivo comprimido con una carpeta llamada “cuda” en cuyo interior se encuentran subcarpetas como bin, include y lib, llenas de ficheros .dll, .h y otros. Lo que hay que hacer es copiar el contenido de esas subcarpetas dentro de las correspondientes rutas de la instalación de CUDA 11.2, normalmente en C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v11.2, respetando la estructura de bin, include y lib.

Una vez copiados esos ficheros, es importante revisar y ajustar la variable de entorno %PATH% de Windows para que incluya los directorios donde residen las bibliotecas de CUDA, CUPTI y cuDNN. Por ejemplo, para CUDA 11.0 (análogo a 11.2) la documentación oficial propone comandos como:

SET PATH=C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v11.0\bin;%PATH%
SET PATH=C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v11.0\extras\CUPTI\lib64;%PATH%
SET PATH=C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v11.0\include;%PATH%
SET PATH=C:\tools\cuda\bin;%PATH%

Adaptando esas rutas a tu versión concreta de CUDA y a la carpeta donde hayas colocado cuDNN (por ejemplo, C:\tools\cuda), te aseguras de que TensorFlow encuentre las DLL necesarias cuando se ejecute.

Instalar TensorFlow GPU en entornos Conda alternativos y comprobar la GPU

Existen otras combinaciones de versiones que también se han utilizado con éxito en Windows, especialmente con versiones anteriores de TensorFlow. Por ejemplo, para TensorFlow 2.6.0 con GPU en un entorno con Python 3.7 se puede crear un entorno Conda tipo:

conda create -n test_tensorflow_gpu python=3.7

Tras crear el entorno, se activa con:

conda activate test_tensorflow_gpu

y luego se instala tensorflow-gpu 2.6.0 mediante pip:

pip install tensorflow-gpu==2.6.0

También hay ejemplos de entornos algo más antiguos con TensorFlow 2.1.0 y CUDA 10.1, donde se crea un entorno Conda con Anaconda y Python 3.7.7, se añade ipykernel y se instalan distintas dependencias científicas, Keras 2.3.1 y demás:

$ conda create -n entornoGPU anaconda python=3.7.7
$ conda activate entornoGPU
$ conda install ipykernel
$ python -m ipykernel install --user --name entornoGPU --display-name "entornoGPU"
$ conda install tensorflow-gpu==2.1.0 cudatoolkit=10.1
$ pip install tensorflow==2.1.0
$ pip install jupyter
$ pip install keras==2.3.1
$ pip install numpy scipy Pillow cython matplotlib scikit-image opencv-python h5py imgaug IPython

Sea cual sea la combinación concreta que elijas (2.10, 2.6.0, 2.1.0, etc.), el patrón siempre es el mismo: crear un entorno virtual limpio, instalar la versión compatible de Python, añadir TensorFlow y las bibliotecas CUDA/cuDNN adecuadas y, por último, comprobar que la GPU es visible.

Una forma rápida de ver si TensorFlow reconoce la GPU es entrar en Python y ejecutar:

import tensorflow as tf
print("TensorFlow version:", tf.__version__)
print("GPUs available:", tf.config.list_physical_devices('GPU'))

La salida ideal mostraría algo parecido a:

TensorFlow version: 2.10.0
GPUs available:

Si, por el contrario, la lista de GPUs aparece vacía ([]), TensorFlow está utilizando solo la CPU. En ese caso conviene cerrar el terminal, volver a activar el entorno, revisar que las rutas de CUDA/cuDNN estén correctamente configuradas, que el driver NVIDIA esté actualizado y que no haya incompatibilidades de versiones.

Uso de TensorFlow-DirectML-Plugin en Windows 11

Para muchos usuarios de Windows 11, especialmente quienes tienen GPUs AMD o Intel o quieren evitar la complejidad de CUDA/cuDNN, el plugin tensorflow-directml-plugin ofrece una alternativa interesante. Este complemento se apoya en DirectML sobre DirectX 12 y permite acelerar TensorFlow sin depender del ecosistema CUDA.

El primer requisito es que tu Windows 10/11 esté en una versión compatible (Windows 10 1709+ o Windows 11 21H2+), y que la GPU soporte DirectX 12 y DirectML. Además, necesitas Python x86-64 en versión 3.7, 3.8, 3.9 o 3.10, siendo 3.10 la versión máxima soportada por este plugin.

De nuevo se recomienda usar Miniconda para crear un entorno virtual. Tras instalar Miniconda, puedes crear un entorno llamado, por ejemplo, tfdml_plugin con:

conda create --name tfdml_plugin python=3.9
conda activate tfdml_plugin

Con el entorno activado, debes instalar la versión base de TensorFlow en CPU que requiere el plugin, concretamente tensorflow-cpu==2.10, ya que no es compatible con tensorflow “normal” ni con tensorflow-gpu:

pip install tensorflow-cpu==2.10

A continuación se instala el propio tensorflow-directml-plugin con un simple:

pip install tensorflow-directml-plugin

Una vez completado, tus scripts de TensorFlow deberían empezar a usar el backend DirectML de forma transparente, sin que tengas que modificar el código. Si ya tenías modelos o notebooks, basta con ejecutarlos dentro del entorno tfdml_plugin.

Integrar el entorno Conda con PyCharm y otros IDEs

Si utilizas PyCharm u otro IDE para desarrollar en Python, es muy útil asociar el intérprete del IDE directamente con el entorno Conda que has creado para TensorFlow, de manera que ejecutas y depuras los proyectos usando exactamente las versiones de librerías que has configurado.

En PyCharm, por ejemplo, puedes ir a Archivo > Ajustes > Proyecto: <TuProyecto> > Intérprete de Python y desde ahí añadir el entorno Conda existente. Para ello, selecciona “Añadir intérprete > Añadir intérprete local”.

En el asistente, elige “Entorno existente” y navega hasta la ruta del ejecutable Python de tu entorno, que suele tener esta pinta:

C:\Users\<tu_usuario>\miniconda3\envs\tf-2.10\python.exe

Una vez seleccionado, elige el entorno tf-2.10 (o el nombre que le hayas dado), confirma con OK y PyCharm empezará a usarlo para ese proyecto. De este modo, los imports de TensorFlow, NumPy, CUDA/cuDNN, etc. se resolverán siempre desde el entorno correcto.

Comprobaciones avanzadas y benchmarks GPU vs CPU

Además del chequeo básico de “tf.config.list_physical_devices(‘GPU’)”, hay formas más avanzadas de asegurarte de que TensorFlow está usando la GPU y, de paso, medir la diferencia real de rendimiento frente a la CPU.

Para instalaciones como la de TensorFlow-gpu 2.6.0 en Python 3.7, se puede escribir un pequeño script en Python que obtenga la lista de dispositivos locales y muestre información detallada de la GPU, la versión de CUDA y la versión de cuDNN que está utilizando TensorFlow internamente. Un ejemplo típico sería:

import tensorflow
from tensorflow.python.client import device_lib

def print_info():
print(‘ Versión de TensorFlow: {}’.format(tensorflow.__version__))
print(‘ GPU: {}’.format())
print(‘ Versión Cuda -> {}’.format(tensorflow.sysconfig.get_build_info()))
print(‘ Versión Cudnn -> {}’.format(tensorflow.sysconfig.get_build_info()))

print_info()

La salida de este tipo de script te indica exactamente qué ve TensorFlow: el nombre de la GPU (por ejemplo, NVIDIA GeForce RTX 2060), la compute capability, y las versiones de CUDA/cuDNN integradas. Así puedes confirmar que las combinaciones son coherentes y que se está usando el dispositivo correcto y consultar un glosario de términos si tienes dudas sobre la nomenclatura.

Si quieres dar un paso más, herramientas como ai-benchmark permiten comparar el rendimiento de GPU y CPU en distintas redes neuronales populares (MobileNet, Inception, ResNet, VGG, etc.). Para instalarlo dentro de tu entorno virtual con GPU activa:

pip install ai-benchmark

Después, desde un intérprete de Python, puedes lanzar un benchmark sobre la GPU con:

from ai_benchmark import AIBenchmark
benchmark_gpu = AIBenchmark(use_CPU=False)
benchmark_gpu.run_training()

Los resultados muestran tiempos de entrenamiento por modelo y un “Device Training Score” global. En pruebas con una RTX 2060, por ejemplo, MobileNet-V2 entrenando con batch=50 y tamaño 224×224 se movía alrededor de 325 ms por iteración en GPU.

Para comparar con CPU, puedes ejecutar:

benchmark_cpu = AIBenchmark(use_CPU=True)
benchmark_cpu.run_training()

En esas mismas condiciones, la CPU tardaba del orden de 3148 ms en MobileNet-V2 en el mismo escenario, es decir, cerca de 10 veces más que la GPU. Esa diferencia se repite, con variaciones, en otros modelos del benchmark, y sirve para visualizar de manera muy clara la ventaja de usar la GPU para entrenamiento intensivo.

También es posible hacer una verificación más básica en un entorno con TensorFlow 2.1.0/2.10 ejecutando:

$ python
$ import tensorflow as tf
$ tf.__version__
$ tf.test.gpu_device_name()

Si tf.test.gpu_device_name() devuelve algo como “/device:GPU:0”, la GPU está siendo detectada y utilizada por TensorFlow. Si devuelve una cadena vacía, probablemente falte configurar bien el stack CUDA/cuDNN o corregir alguna incompatibilidad de versiones.

Combinando estas comprobaciones, la configuración de entornos virtuales con Miniconda y la elección cuidadosa de versiones (TensorFlow 2.10 para Windows nativo con CUDA 11.2 y cuDNN 8.1, o bien tensorflow-cpu 2.10 con el plugin DirectML), puedes conseguir que TensorFlow saque partido a tu GPU en Windows 11 sin volverte loco con errores crípticos ni romper otras instalaciones de Python que ya tengas en tu máquina.