How to Resolve TensorFlow CUDA cuInit UNKNOWN ERROR (303) on Kaggle by Enabling the GPU Runtime

Seeing 'failed call to cuInit' when loading a Keras model on Kaggle? This guide explains the cause (no GPU runtime) and shows the quick fix: enable GPU.

When a TensorFlow model refuses to load on Kaggle with a CUDA initialization error, it’s tempting to suspect drivers, versions, or broken wheels. In this case, the failure is simpler: the Kaggle kernel is not running with a GPU, so CUDA initialization (cuInit) aborts and TensorFlow surfaces UNKNOWN ERROR (303). Below is a concise walk-through that shows the symptom, explains what’s going on, and how to resolve it.

Minimal reproduction

The environment uses TensorFlow 2.18.0, and querying TensorFlow’s build info reports CUDA 12.5.1. The model is loaded via keras.load_model inside a Kaggle notebook.

import os as os_mod, json as json_mod, joblib as jl
from pathlib import Path as P
import warnings as warn
warn.filterwarnings("ignore")

from sklearn.model_selection import train_test_split as split_train_test
from sklearn.preprocessing import StandardScaler as StdScaler, LabelEncoder as LabelEnc
from sklearn.utils.class_weight import compute_class_weight as calc_class_weight

from tensorflow.keras.utils import Sequence as KSeq, to_categorical as to_cat, pad_sequences as pad_seq
from tensorflow.keras.models import Model as KModel, load_model as load_trained
from tensorflow.keras.layers import (
    Input as KInput, Conv1D as Conv1d, BatchNormalization as BN, Activation as Act, add as add_layer, MaxPooling1D as MaxPool1d, Dropout as Drop,
    Bidirectional as Bi, LSTM as Lstm, GlobalAveragePooling1D as GAP1d, Dense as DenseLayer, Multiply as Mul, Reshape as ReshapeLayer,
    Lambda as LambdaLayer, Concatenate as Concat, GRU as Gru, GaussianNoise as GNoise
)
from tensorflow.keras.regularizers import l2 as l2_reg
from tensorflow.keras.optimizers import Adam as AdamOpt
from tensorflow.keras.callbacks import EarlyStopping as EarlyStop
from tensorflow.keras import backend as Kb
import tensorflow as tf
import polars as pl
from sklearn.model_selection import StratifiedGroupKFold as StratGroupKF
from scipy.spatial.transform import Rotation as Rot

WEIGHTS_ROOT = P("/kaggle/input/gesture_two_branch_mixup.h5/tensorflow2/default/1")

net = load_trained(
    WEIGHTS_ROOT / "gesture_two_branch_mixup.h5",
    compile=False,
    custom_objects=alt_objects
)

The failure shows up as:

failed call to cuInit: INTERNAL: CUDA error: Failed call to cuInit: UNKNOWN ERROR (303)

Context from the same session:

tensorflow: 2.18.0

print(tf.sysconfig.get_build_info()['cuda_version'])
# 12.5.1

What actually happens

On Kaggle, the runtime is CPU-only by default. If the kernel is not configured to use a GPU, TensorFlow still attempts to initialize CUDA, and with no GPU-backed runtime it fails during cuInit, yielding the UNKNOWN ERROR (303) you’re seeing while calling keras.load_model.

The fix

Switch the Kaggle notebook hardware to GPU. Kaggle provides a straightforward toggle labeled Enable GPU. Turn it on for your kernel, then restart the session so the GPU runtime is provisioned. Official step-by-step guidance is available here: https://www.kaggle.com/code/dansbecker/running-kaggle-kernels-with-a-gpu

No code changes are required. After enabling GPU, re-run the exact same loading code:

from pathlib import Path as P
from tensorflow.keras.models import load_model as load_trained

WEIGHTS_ROOT = P("/kaggle/input/gesture_two_branch_mixup.h5/tensorflow2/default/1")

net = load_trained(
    WEIGHTS_ROOT / "gesture_two_branch_mixup.h5",
    compile=False,
    custom_objects=alt_objects
)

Why this matters

Misconfigured hardware accelerators waste time and can mask themselves as package or driver problems. In cloud notebook environments like Kaggle, choosing the proper runtime is a prerequisite for any GPU-dependent workflow. Ensuring the kernel runs with a GPU eliminates the cuInit failure at the source and lets TensorFlow operate as expected.

Closing notes

Before loading or training GPU-backed TensorFlow/Keras models on Kaggle, verify that the kernel is launched with GPU support through the Enable GPU setting, then restart the notebook. If you need a refresher on where that switch lives, refer to Kaggle’s guide linked above. With the GPU enabled, the same code path that previously failed during cuInit proceeds without the UNKNOWN ERROR (303).