Change the code.
Keep the
evidence.

Make a shuffled split reproducible.

from sklearn.model_selection import train_test_split
train_test_split(X, y)

from sklearn.model_selection import train_test_split
train_test_split(X, y, random_state=seed)

The covered split omits random_state. An explicit seed makes the intended policy visible; global RNG initialization can also matter and should be reviewed.

Avoid an implicitly initialized generator.

import numpy as np
np.random.default_rng()

import numpy as np
np.random.default_rng(seed)

Calling default_rng without a seed draws fresh entropy. Use a seed chosen for the experiment, and retain its inputs and environment as well.

Make a local random generator explicit.

import random
random.Random()

import random
random.Random(seed)

A new Random instance without an argument is not controlled by seeding the module-level generator. Supply the seed intended for this instance.

Shuffle indices from a seeded generator instead of unseeded global state.

import numpy as np
indices = np.arange(len(X))
np.random.shuffle(indices)

import numpy as np
rng = np.random.default_rng(seed)
indices = np.arange(len(X))
rng.shuffle(indices)

np.random.shuffle draws from NumPy's global RNG, and nothing in this file seeds it. A Generator created with the experiment's seed keeps the policy local and visible. Seeding may also happen in another module; this is a review item, not a defect finding.

Does seed() without a value pin the global RNG?

import numpy as np
np.random.seed()
indices = np.arange(len(X))
np.random.shuffle(indices)

import numpy as np
np.random.seed(seed)
indices = np.arange(len(X))
np.random.shuffle(indices)

np.random.seed() and seed(None) draw OS or clock entropy, so they do not make a later shuffle repeatable. Pass the experiment's seed, or switch to a Generator created with that seed.

Make module-level random state explicit.

import random
random.shuffle(items)

import random
rng = random.Random(seed)
rng.shuffle(items)

random.shuffle draws from Python's module-level generator, and this file never seeds it. A dedicated Random instance keeps the experiment's policy visible; seeding may also happen elsewhere, so this remains a review item.

A seed does not make every updater deterministic.

import xgboost as xgb
xgb.XGBRegressor(booster='gblinear', random_state=seed)

import xgboost as xgb
xgb.XGBRegressor(booster='gblinear', updater='coord_descent', random_state=seed)

The default shotgun updater for gblinear is nondeterministic. Coordinate descent is an alternative to review for your experiment.

Make CPU histogram construction explicit.

import lightgbm as lgb
params = {'deterministic': True}
lgb.train(params, train_data)

import lightgbm as lgb
params = {'deterministic': True, 'force_col_wise': True, 'seed': seed}
lgb.train(params, train_data)

For the covered CPU configuration, deterministic mode also needs an explicit histogram choice. Select row-wise or column-wise construction for your workload; the example uses column-wise.

Make random weight initialization repeatable.

import torch
weights = torch.randn(64, 32)

import torch
torch.manual_seed(seed)
weights = torch.randn(64, 32)

torch.randn draws from PyTorch's global RNG, which this file never seeds. torch.manual_seed with the experiment's seed makes the initialization repeatable on one device; cuDNN kernels and data loading still need their own review.

Give shuffled loading an explicit generator.

from torch.utils.data import DataLoader
DataLoader(dataset, shuffle=True)

import torch
from torch.utils.data import DataLoader
DataLoader(dataset, shuffle=True, generator=torch.Generator().manual_seed(seed))

A missing generator needs review because RNG state may be managed elsewhere. The example makes generator ownership explicit; worker initialization and dataset behavior still need attention.

Does a sampler need its own generator?

from torch.utils.data import DataLoader, RandomSampler
DataLoader(dataset, sampler=RandomSampler(dataset))

import torch
from torch.utils.data import DataLoader, RandomSampler
DataLoader(dataset, sampler=RandomSampler(dataset, generator=torch.Generator().manual_seed(seed)))

DataLoader does not shuffle when a sampler is passed, so an unseeded RandomSampler is invisible to the shuffle check. The sampler draws from the global RNG until generator= is a seeded torch.Generator. SequentialSampler is not random and is not flagged.

Does passing torch.Generator() seed the shuffle?

import torch
from torch.utils.data import DataLoader
DataLoader(dataset, shuffle=True, generator=torch.Generator())

import torch
from torch.utils.data import DataLoader
DataLoader(dataset, shuffle=True, generator=torch.Generator().manual_seed(seed))

DataLoader accepts a generator object, but the constructor draws OS entropy until manual_seed is given a value. Chain manual_seed with the experiment's seed. A generator variable is still accepted without proving that it was seeded.

Review cuDNN algorithm benchmarking.

import torch
torch.backends.cudnn.benchmark = True

import torch
torch.backends.cudnn.benchmark = False

Benchmarking can select different convolution algorithms between runs. Turning it off addresses this setting, but does not establish deterministic execution.

Choose how the RNG state is initialized.

import tensorflow as tf
tf.random.Generator.from_non_deterministic_state()

import tensorflow as tf
tf.random.Generator.from_seed(seed)

This constructor explicitly requests nondeterministic state. The alternative uses your chosen seed; it does not configure every TensorFlow operation.

Decide whether determinism is required or advisory.

from lightning.pytorch import Trainer
Trainer(deterministic='warn')

from lightning.pytorch import Trainer, seed_everything
seed_everything(seed, workers=True)
Trainer(deterministic=True, benchmark=False)

Warning-only mode allows operations without a deterministic implementation to proceed. Strict mode can raise errors, so review the choice and its effect on training.

Make unsupported deterministic operations visible.

import os
import torch
os.environ["CUBLAS_WORKSPACE_CONFIG"] = ":4096:8"
torch.use_deterministic_algorithms(True, warn_only=True)

import os
import torch
os.environ["CUBLAS_WORKSPACE_CONFIG"] = ":4096:8"
torch.use_deterministic_algorithms(True, warn_only=False)

With warn_only=True, an unsupported operation can continue. Strict mode changes that behavior and may stop a run; it is a policy decision, not a universal fix.