OSCR

A non-linear game for two: genetic parameters and prediction of fertilization success using Bayesian and machine learning frameworks.

Code ↔ Paper

2 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 2 matches
  1. [1] § Methods › Two-tower MLP model ↔ 2tower_MLP/AC_fert_2tower.ipynb, lines 349–428 · score 0.60 · class weighted, PyTorch, epoch, binary, accuracy, Training
  2. [2] § Methods › Estimation of genetic parameters for latent fertility traits ↔ 2tower_MLP/AC_fert_2tower.ipynb, lines 349–428 · score 0.52 · latent liability, binary fertilization, matrix, sires, model

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Jupyter notebook · 492 lines · 17 KB · no license · 2 matches

  1. # %%
  2. import numpy as np
  3. import pandas as pd
  4. import torch
  5. import math
  6. import torch.nn as nn
  7. import torch.nn.functional as F
  8. from sklearn.model_selection import StratifiedGroupKFold
  9. from sklearn.metrics import accuracy_score, roc_auc_score, average_precision_score, confusion_matrix, roc_curve
  10. import matplotlib.pyplot as plt
  11. from torch.utils.data import Dataset, DataLoader
  12. import warnings
  13. warnings.filterwarnings("ignore")
  15. SEED = 42
  16. np.random.seed(SEED)
  17. torch.manual_seed(SEED)
  19. # =============================
  20. # Data loading and preprocessing
  21. # =============================
  22. A_df = pd.read_csv("ApIcl.csv", index_col=0)
  24. A_df.index = (
  25. A_df.index.astype(str)
  26. .str.strip()
  27. .str.upper()
  28. .str.replace(r"\.0$", "", regex=True)
  29. )
  30. A_df.columns = A_df.columns.astype(str).str.strip().str.upper()
  31. A_df = A_df.replace([np.inf, -np.inf], np.nan).fillna(0.0).astype(np.float32)
  33. # Founders
  34. A_features_founder = {idx: row.values.astype(np.float32) for idx, row in A_df.iterrows()}
  36. def assign_founder_features(df, lookup):
  37. df = df.copy()
  38. df["Sire"] = df["Sire"].astype(str)
  39. df["Dam"] = df["Dam"].astype(str)
  40. df["Sire_features"] = df["Sire"].map(lookup)
  41. df["Dam_features"] = df["Dam"].map(lookup)
  42. return df
  44. crosses_df = pd.read_csv("EggsIcl.csv", index_col=0)
  45. crosses_df = assign_founder_features(crosses_df, A_features_founder)
  47. # Feature vector
  48. EXPECTED_DIM = A_df.shape[1]
  49. DEFAULT_VEC = np.zeros(EXPECTED_DIM, dtype=np.float32)
  51. def clean_features(x):
  52. if isinstance(x, (list, np.ndarray)):
  53. v = np.asarray(x, dtype=np.float32)
  54. if v.shape[0] == EXPECTED_DIM:
  55. return np.nan_to_num(v, nan=0.0, posinf=0.0, neginf=0.0)
  56. return DEFAULT_VEC
  58. for col in ["Sire_features", "Dam_features"]:
  59. crosses_df[col] = crosses_df[col].apply(clean_features)
  61. crosses_df = crosses_df.reset_index(drop=True)
  63. # =========
  64. # Dataloader
  65. # ============
  66. def build_inputs_matrix(df):
  67. sire = np.stack(df["Sire_features"]).astype(np.float32)
  68. dam = np.stack(df["Dam_features"]).astype(np.float32)
  69. return sire, dam
  71. class FertilityDataset(Dataset):
  72. def __init__(self, df):
  73. sire_feats, dam_feats = build_inputs_matrix(df)
  74. sire_feats = np.nan_to_num(sire_feats, nan=0.0, posinf=0.0, neginf=0.0).astype(np.float32)
  75. dam_feats = np.nan_to_num(dam_feats, nan=0.0, posinf=0.0, neginf=0.0).astype(np.float32)
  77. self.sire_input = torch.tensor(sire_feats, dtype=torch.float32)
  78. self.dam_input = torch.tensor(dam_feats, dtype=torch.float32)
  79. self.y = torch.tensor(df["BinPheno"].values, dtype=torch.float32)
  81. # IDs
  82. sire_col, dam_col, cross_col = ["Sire", "Dam", "Cohort.Sib"]
  83. self.sire_ids = (df[sire_col].astype(str).tolist() if sire_col else df.index.astype(str).tolist())
  84. self.dam_ids = (df[dam_col].astype(str).tolist() if dam_col else df.index.astype(str).tolist())
  85. self.cross_ids = (df[cross_col].astype(str).tolist() if cross_col else ["" for _ in range(len(df))])
  87. self._sire_col_name = sire_col or "SireID_fallback"
  88. self._dam_col_name = dam_col or "DamID_fallback"
  89. self._cross_col_name = cross_col or "CrossID"
  91. def __len__(self):
  92. return len(self.y)
  94. def __getitem__(self, idx):
  96. return (self.sire_input[idx],
  97. self.dam_input[idx],
  98. self.y[idx],
  99. self.sire_ids[idx],
  100. self.dam_ids[idx],
  101. self.cross_ids[idx])
  104. # =====
  105. # Model
  106. # ======
  107. class BinaryFertilityModel(nn.Module):
  108. def __init__(self, input_dim, dropout1=0.2, dropout2=0.2):
  109. super().__init__()
  110. self.sire_net = self._make_tower(input_dim, dropout1, dropout2)
  111. self.dam_net = self._make_tower(input_dim, dropout1, dropout2)
  113. @staticmethod
  114. def _make_tower(input_dim, d1, d2):
  115. return nn.Sequential(
  116. nn.Linear(input_dim, 128), nn.ReLU(), nn.Dropout(d1),
  117. nn.Linear(128, 64), nn.ReLU(), nn.Dropout(d2),
  118. nn.Linear(64, 32), nn.ReLU(),
  119. nn.Linear(32, 1)
  120. )
  122. def forward(self, sire_input, dam_input):
  123. a = self.sire_net(sire_input).squeeze(-1)
  124. b = self.dam_net(dam_input).squeeze(-1)
  125. return a, b
  127. # =========================
  128. # Helpers: probs, loss, eval
  129. # =========================
  130. def _phi(x: torch.Tensor) -> torch.Tensor:
  131. # Standard normal CDF
  132. if hasattr(torch.special, "ndtr"):
  133. return torch.special.ndtr(x)
  134. return 0.5 * (1.0 + torch.erf(x / math.sqrt(2.0)))
  136. def probs_from_scores(a, b, link="probit", stable=True, eps=1e-7):
  137. """
  138. Turn tower outputs a, b into a joint (fused) probability.
  139. """
  140. if link == "probit":
  141. if stable and hasattr(torch.special, "log_ndtr"):
  142. # log version
  143. log_p = torch.special.log_ndtr(a) + torch.special.log_ndtr(b)
  144. p = torch.exp(log_p)
  145. else:
  146. p = _phi(a) * _phi(b)
  147. elif link == "logit":
  148. if stable:
  149. # log
  150. log_p = -F.softplus(-a) + -F.softplus(-b)
  151. p = torch.exp(log_p)
  152. else:
  153. p = torch.sigmoid(a) * torch.sigmoid(b)
  154. else:
  155. raise ValueError(f"Unknown link: {link}")
  157. return torch.clamp(p, min=eps, max=1.0 - eps)
  160. def weighted_bce_on_prob(p, y, pos_weight_value, device):
  161. per_sample_nll = -(y * torch.log(p) + (1 - y) * torch.log(1 - p))
  162. pos_w = torch.as_tensor(pos_weight_value, dtype=torch.float32, device=device)
  163. w = torch.where(y > 0.5, pos_w, torch.tensor(1.0, device=device))
  164. return (per_sample_nll * w).sum() / w.sum()
  166. @torch.no_grad()
  167. def evaluate_split(model, loader, device="cpu", threshold=0.5,
  168. return_ids=False, return_scores=False):
  169. model.eval()
  170. all_probs, all_labels = [], []
  171. all_sire_ids, all_dam_ids, all_cross_ids = [], [], []
  172. all_a, all_b = [], []
  174. for batch in loader:
  176. if len(batch) == 3:
  177. sire_x, dam_x, y = batch
  178. sire_ids = dam_ids = cross_ids = None
  179. else:
  180. sire_x, dam_x, y, sire_ids, dam_ids, cross_ids = batch
  182. sire_x, dam_x = sire_x.to(device), dam_x.to(device)
  183. a, b = model(sire_x, dam_x)
  185. p_joint = probs_from_scores(a, b, link="probit", stable=True)
  187. if return_scores:
  188. all_a.extend(a.detach().cpu().numpy().ravel())
  189. all_b.extend(b.detach().cpu().numpy().ravel())
  191. all_probs.extend(p_joint.cpu().numpy().ravel())
  192. all_labels.extend(y.numpy().ravel())
  194. if return_ids and sire_ids is not None:
  195. all_sire_ids.extend(sire_ids)
  196. all_dam_ids.extend(dam_ids)
  197. all_cross_ids.extend(cross_ids)
  199. y_true = np.asarray(all_labels)
  200. y_prob = np.asarray(all_probs)
  201. y_pred = (y_prob >= threshold).astype(int)
  203. acc = accuracy_score(y_true, y_pred)
  204. if len(np.unique(y_true)) > 1:
  205. auc = roc_auc_score(y_true, y_prob)
  206. prau = average_precision_score(y_true, y_prob)
  207. else:
  208. auc, prau = np.nan, np.nan
  209. cm = confusion_matrix(y_true, y_pred)
  211. out = (acc, auc, prau, cm, y_true, y_prob)
  212. if return_ids and len(all_sire_ids) > 0:
  213. out += (np.array(all_sire_ids), np.array(all_dam_ids), np.array(all_cross_ids))
  214. if return_scores:
  215. out += (np.array(all_a), np.array(all_b)) # latent liabilities
  216. return out
  219. # =========================
  220. # Training (early stopping)
  221. # =========================
  222. def train_model(model, train_loader, val_loader, pos_weight_value,
  223. epochs=200, lr=1e-3, weight_decay=1e-4, device="cpu",
  224. patience=15, max_grad_norm=5.0, return_best_epoch=False):
  225. model.to(device)
  226. optim = torch.optim.Adam(model.parameters(), lr=lr, weight_decay=weight_decay)
  228. best_auc = -float("inf")
  229. best_state = None
  230. best_epoch = 0
  231. patience_ctr = 0
  233. for epoch in range(1, epochs + 1):
  234. model.train()
  235. # training loop
  236. for sire_x, dam_x, y, _sire_ids, _dam_ids, _cross_ids in train_loader:
  237. sire_x, dam_x, y = sire_x.to(device), dam_x.to(device), y.to(device)
  238. a, b = model(sire_x, dam_x)
  239. p = probs_from_scores(a, b, link="probit", stable=False)
  240. loss = weighted_bce_on_prob(p, y, pos_weight_value, device)
  241. if not torch.isfinite(loss):
  242. continue
  243. optim.zero_grad()
  244. loss.backward()
  245. if max_grad_norm is not None:
  246. nn.utils.clip_grad_norm_(model.parameters(), max_grad_norm)
  247. optim.step()
  249. acc_v, auc_v, pr_v, _, _, _ = evaluate_split(model, val_loader, device=device, threshold=0.5)
  250. print(f"Epoch {epoch:03d} | Val Acc {acc_v:.3f} | Val AUC {auc_v:.3f} | Val PR-AUC {pr_v:.3f}")
  252. if auc_v > best_auc:
  253. best_auc = auc_v
  254. best_epoch = epoch
  255. best_state = {k: v.detach().cpu().clone() for k, v in model.state_dict().items()}
  256. patience_ctr = 0
  257. else:
  258. patience_ctr += 1
  259. if patience_ctr >= patience:
  260. print(f"Early stopping at epoch {epoch} — best Val AUC {best_auc:.3f} (epoch {best_epoch})")
  261. break
  263. if best_state is not None:
  264. model.load_state_dict(best_state)
  265. print(f"Restored best model (Val AUC {best_auc:.3f} at epoch {best_epoch})")
  266. return (model, best_epoch) if return_best_epoch else model
  268. # ====================================
  269. # 80/20 split + inner 4-fold grid search
  270. # =======================================
  271. device = "cuda" if torch.cuda.is_available() else "cpu"
  272. input_dim = EXPECTED_DIM
  274. # Grid for first/second layer dropout
  275. dropout1_grid = [0.0, 0.1, 0.2, 0.3, 0.4, 0.5]
  276. dropout2_grid = [0.0, 0.1, 0.2, 0.3, 0.4, 0.5]
  278. # 80/20 stratified split
  279. groups_all = crosses_df["Cohort"].astype(str).values
  280. y_all = crosses_df["BinPheno"].values.astype(int)
  282. sgkf_80_20 = StratifiedGroupKFold(n_splits=5, shuffle=True, random_state=SEED)
  283. train_idx_all, test_idx = next(sgkf_80_20.split(np.zeros(len(y_all)), y_all, groups_all))
  285. train_df = crosses_df.iloc[train_idx_all].reset_index(drop=True).copy()
  286. test_df = crosses_df.iloc[test_idx].reset_index(drop=True).copy()
  287. print(f"Train size: {len(train_df)} | Test size: {len(test_df)}")
  288. assert set(train_df["Cohort"]).isdisjoint(set(test_df["Cohort"])), "Group leakage"
  291. # Inner 4-fold CV on 80% for dropout search
  292. inner_groups = train_df["Cohort"].astype(str).values
  293. inner_y = train_df["BinPheno"].values.astype(int)
  294. inner_cv = StratifiedGroupKFold(n_splits=4, shuffle=True, random_state=SEED)
  296. grid_scores = [] # (d1, d2, mean_auc, mean_prauc)
  297. epoch_book = {} # key: (d1, d2) -> list of best_epoch
  299. for d1 in dropout1_grid:
  300. for d2 in dropout2_grid:
  301. fold_metrics = []
  302. epoch_book[(d1, d2)] = []
  303. print(f"\nGrid candidate: dropout1={d1}, dropout2={d2}")
  305. for tr_idx, val_idx in inner_cv.split(np.zeros(len(inner_y)), inner_y, inner_groups):
  306. tr_df = train_df.iloc[tr_idx].reset_index(drop=True).copy()
  307. va_df = train_df.iloc[val_idx].reset_index(drop=True).copy()
  309. tr_loader = DataLoader(FertilityDataset(tr_df), batch_size=32, shuffle=True)
  310. va_loader = DataLoader(FertilityDataset(va_df), batch_size=64, shuffle=False)
  312. n_pos = int((tr_df["BinPheno"] == 1).sum())
  313. n_neg = int((tr_df["BinPheno"] == 0).sum())
  314. pos_weight_value = float(n_neg) / max(1.0, float(n_pos))
  316. model = BinaryFertilityModel(input_dim=input_dim, dropout1=d1, dropout2=d2)
  317. model, best_ep = train_model(
  318. model, tr_loader, va_loader, pos_weight_value,
  319. epochs=200, lr=1e-3, weight_decay=1e-4,
  320. device=device, patience=15, max_grad_norm=5.0,
  321. return_best_epoch=True
  322. )
  324. acc, auc, prauc, _, _, _ = evaluate_split(model, va_loader, device=device, threshold=0.5)
  325. fold_metrics.append((acc, auc, prauc))
  326. epoch_book[(d1, d2)].append(best_ep)
  328. fm = np.array(fold_metrics, dtype=float)
  329. mean_auc = np.nanmean(fm[:, 1])
  330. mean_prauc = np.nanmean(fm[:, 2])
  331. grid_scores.append((d1, d2, mean_auc, mean_prauc))
  332. print(f" 4-fold CV -> Mean AUC={mean_auc:.3f} | Mean PR-AUC={mean_prauc:.3f}")
  334. # Pick best by mean ROC AUC
  335. grid_scores.sort(key=lambda t: (t[2], t[3]), reverse=True)
  336. best_d1, best_d2, best_auc_inner, best_pra_inner = grid_scores[0]
  338. best_epochs = epoch_book[(best_d1, best_d2)]
  339. fixed_epochs = int(np.median(best_epochs)) if len(best_epochs) else 100
  341. print("\n=== GRID SEARCH SUMMARY ===")
  342. print(f"Best (dropout1, dropout2) = ({best_d1}, {best_d2})")
  343. print(f"4-fold mean AUC = {best_auc_inner:.3f} | mean PR-AUC = {best_pra_inner:.3f}")
  344. print("Grid (top 5):")
  345. for row in grid_scores[:5]:
  346. print(f" d1={row[0]} d2={row[1]} | mean AUC={row[2]:.3f} | mean PR-AUC={row[3]:.3f}")
  349. # %%
  350. # =========================
  351. # Final training on 80% with val, test on 20%
  352. # ============================================
  353. device = "cuda" if torch.cuda.is_available() else "cpu"
  354. input_dim = EXPECTED_DIM
  356. #best_d1 = 0.0
  357. #best_d2 = 0.5
  359. # Split 80% train_df into train_sub and val_sub
  360. inner_sgkf = StratifiedGroupKFold(n_splits=5, shuffle=True, random_state=SEED)
  361. tr_idx, va_idx = next(inner_sgkf.split(
  362. np.zeros(len(train_df)),
  363. train_df["BinPheno"].values,
  364. train_df["Cohort"].astype(str).values
  365. ))
  367. tr_df = train_df.iloc[tr_idx].reset_index(drop=True).copy()
  368. va_df = train_df.iloc[va_idx].reset_index(drop=True).copy()
  370. # DataLoaders
  371. tr_loader = DataLoader(FertilityDataset(tr_df), batch_size=32, shuffle=True)
  372. va_loader = DataLoader(FertilityDataset(va_df), batch_size=64, shuffle=False)
  373. te_loader = DataLoader(FertilityDataset(test_df), batch_size=64, shuffle=False)
  375. # Class weight from train_sub
  376. n_pos = int((tr_df["BinPheno"] == 1).sum())
  377. n_neg = int((tr_df["BinPheno"] == 0).sum())
  378. pos_weight_value = float(n_neg) / max(1.0, float(n_pos))
  380. # Train final model with best dropout and early stopping
  381. final_model = BinaryFertilityModel(input_dim=input_dim, dropout1=best_d1, dropout2=best_d2)
  382. final_model = train_model(
  383. final_model, tr_loader, va_loader, pos_weight_value,
  384. epochs=300, lr=1e-3, weight_decay=1e-4,
  385. device=device, patience=15, max_grad_norm=5.0)
  388. acc_t, auc_t, pr_t, cm_t, y_true_t, y_prob_t, sire_ids_t, dam_ids_t, cross_ids_t = evaluate_split(
  389. final_model, te_loader, device=device, threshold=0.5, return_ids=True)
  391. print("\nFINAL TEST RESULTS")
  392. print(f"Acc={acc_t:.3f} | AUC={auc_t:.3f} | PR-AUC={pr_t:.3f}")
  393. print("Confusion matrix:\n", cm_t)
  395. # IDs + latent scores
  396. res = evaluate_split(
  397. final_model, tr_loader, device=device, threshold=0.5,
  398. return_ids=True, return_scores=True
  399. )
  401. # Unpack
  402. (acc_t, auc_t, pr_t, cm_t,
  403. y_true_t, _y_prob_joint,
  404. sire_ids_t, dam_ids_t, cross_ids_t,
  405. a_sire_t, b_dam_t) = res
  407. # Output dataframe: IDs + latent liabilities
  408. out = {
  409. "SireID": sire_ids_t,
  410. "DamID": dam_ids_t,
  411. "a_sire": a_sire_t,
  412. "b_dam": b_dam_t,
  413. }
  415. if any(cross_ids_t):
  416. out["CrossID"] = cross_ids_t
  418. if isinstance(y_true_t, np.ndarray) and y_true_t.size == a_sire_t.size:
  419. out["y_true"] = y_true_t
  421. cols = [c for c in ["CrossID","SireID","DamID","y_true","a_sire","b_dam"] if c in out]
  422. latent_df = pd.DataFrame(out, columns=cols)
  424. latent_df.to_csv("final_test_latent_liabilities_with_ids.csv", index=False)
  425. print(latent_df.head())
  427. np.save("latents_sire_a.npy", a_sire_t)
  428. np.save("latents_dam_b.npy", b_dam_t)
  432. # %%
  433. full_loader = DataLoader(
  434. FertilityDataset(crosses_df),
  435. batch_size=64,
  436. shuffle=False
  437. )
  439. res_full = evaluate_split(
  440. final_model,
  441. full_loader,
  442. device=device,
  443. threshold=0.5,
  444. return_ids=True,
  445. return_scores=True
  446. )
  448. (acc_f, auc_f, pr_f, cm_f,
  449. y_true_f, _yprob_f,
  450. sire_ids_f, dam_ids_f, cross_ids_f,
  451. a_sire_f, b_dam_f) = res_full
  453. np.save("latents_full_sire_a.npy", a_sire_f)
  454. np.save("latents_full_dam_b.npy", b_dam_f)
  457. # %%
  458. final_model.eval()
  459. all_labels, all_probs = [], []
  461. with torch.no_grad():
  462. for sire_x, dam_x, y, _, _, _ in te_loader:
  463. sire_x, dam_x = sire_x.to(device), dam_x.to(device)
  464. a, b = final_model(sire_x, dam_x)
  466. probs = probs_from_scores(a, b, link="probit", stable=True)
  468. all_probs.extend(probs)
  469. all_labels.extend(y.numpy())
  471. all_labels = np.array(all_labels)
  472. all_probs = np.array(all_probs)
  473. pred_labels = (all_probs >= 0.5).astype(int)
  475. # Confusion matrix
  476. cm = confusion_matrix(all_labels, pred_labels)
  477. print("\nConfusion Matrix:\n", cm)
  479. # ROC + AUC
  480. auc_val = roc_auc_score(all_labels, all_probs)
  481. fpr, tpr, _ = roc_curve(all_labels, all_probs)
  483. plt.figure(figsize=(6,5))
  484. plt.plot(fpr, tpr, label=f"ROC Curve (AUC = {auc_val:.3f})")
  485. plt.plot([0, 1], [0, 1], linestyle="--")
  486. plt.xlabel("False Positive Rate")
  487. plt.ylabel("True Positive Rate")
  488. plt.title("ROC Curve — Final Test")
  489. plt.legend()
  490. plt.grid(True)
  491. plt.show()

AC_fert_2tower.ipynb at commit 9a0d895, no license · at the source

Overview

Authors: Fotis Pappas1, Paul Vincent Debes2, Martin Johnsson1, Christos Palaiokostas1
ORCID iDs: Fotis Pappas, Paul Vincent Debes, Martin Johnsson, Christos Palaiokostas
  1. Department of Animal Biosciences, Swedish University of Agricultural Sciences, Uppsala, Sweden
  2. Department of Aquaculture and Fish Biology, Hólar University, Sauðárkrókur, Iceland
Institutions: Swedish University of Agricultural Sciences (Sweden); Hólar University College (Iceland)
Journal: Genetics, selection, evolution : GSE, volume 58, issue 1, article 34
Dates: received 10 November 2025; accepted 6 July 2026; published online 16 July 2026
Type: Brief report · Language: English
License: CC BY
Identifiers: DOI 10.1186/s12711-026-01070-9 · PMID 42464095 · PMCID PMC13377850 · OpenAlex W4416394785
Open access: gold, a free copy (OpenAlex)
Preprint: doi:10.21203/rs.3.rs-8078842/v1
Status: code verified
Methods: Machine learning, Statistics
MeSH: Fertility*, Fertilization*, Machine Learning*, Animals, Bayes Theorem, Breeding, Female, Male, Models, Genetic, Prediction Algorithms, Predictive Learning Models (* major topic)
Topic: Genetic and phenotypic traits in livestock (Genetics, Biochemistry, Genetics and Molecular Biology), according to OpenAlex
Funding: Rannís (2410430)
Citations: not cited yet (Europe PMC); 30 references in the paper

Abstract

Fertility is an important but often cryptic and intrinsic characteristic of domesticated animals. Predicting reproductive potential is of great importance for the industry but assessment through indirect proxies is laborious and often impractical. Among other biological factors, genetic effects are expected to play a crucial role in shaping male and female fertility. In cases where heritable components are strong, polygenic merit could be a valuable tool for decision-making in breeding schemes. Here we estimate sex-specific variance components affecting fertilization success by analyzing outcomes of over 3000 controlled mating events in an Arctic charr breeding nucleus from Iceland. Furthermore, a machine learning framework using relationships-to-founders vectors as input and a two-tower neural network architecture is proposed and tested for prediction of fertilization success. Both approaches seem to capture a meaningful biological signal and offer alternative tools for ranking, selecting or even allocating matings between breeding candidates.

Supplementary Information: The online version contains supplementary material available at 10.1186/s12711-026-01070-9.

Reproduced under the paper's license (CC BY), from the paper cited above.

Repository

Its files are read in the Code ↔ Paper reader above, with 2 matches between paragraphs and lines of code.

pappasfotios/AC_Iceland_fertility

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 9a0d8952581e1e1458798aeee1d158cf78fdadf9, 25 September 2026
Languages: Jupyter (1), Stan (1)
Size: 6 files, 2 scripts
Software Heritage: not archived
Found in: “Data availability”
Holds: README, 1 notebook
Not found: license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: Matplotlib (1 file), NumPy (1 file), pandas (1 file), PyTorch (1 file), scikit-learn (1 file), Stan (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
3 files
At the source: github.com/pappasfotios/AC_Iceland_fertility

The paper's code and data availability statement is in the Data section.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 2 scripts, each with its path and the digest of its content;
  • 2 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

No dataset and no data link were found in the paper.

Data availability

Data and code available at: https://github.com/pappasfotios/AC_Iceland_fertility.

Reproduced under the paper's license (CC BY), from the paper cited above.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 4 authors, 11 MeSH terms, 1 funder, 14 references.

Cite

This paper

Pappas, F., Debes, P. V., Johnsson, M., & Palaiokostas, C. (2026). A non-linear game for two: genetic parameters and prediction of fertilization success using Bayesian and machine learning frameworks. Genetics, selection, evolution : GSE, 58(1), 34. https://doi.org/10.1186/s12711-026-01070-9

BibTeX

@article{pappas2026non,
author = {Pappas, Fotis and Debes, Paul Vincent and Johnsson, Martin and Palaiokostas, Christos},
title = {{A non-linear game for two: genetic parameters and prediction of fertilization success using Bayesian and machine learning frameworks}},
journal = {Genetics, selection, evolution : GSE},
year = {2026},
month = jul,
volume = {58},
number = {1},
pages = {34},
publisher = {BMC},
issn = {0999-193X},
doi = {10.1186/s12711-026-01070-9},
url = {https://doi.org/10.1186/s12711-026-01070-9},
pmid = {42464095},
pmcid = {PMC13377850}
}

RIS

TY - JOUR
AU - Pappas, Fotis
AU - Debes, Paul Vincent
AU - Johnsson, Martin
AU - Palaiokostas, Christos
TI - A non-linear game for two: genetic parameters and prediction of fertilization success using Bayesian and machine learning frameworks
T2 - Genetics, selection, evolution : GSE
J2 - Genet Sel Evol
PY - 2026
DA - 2026/07/16
VL - 58
IS - 1
SP - 34
SN - 0999-193X
PB - BMC
DO - 10.1186/s12711-026-01070-9
UR - https://doi.org/10.1186/s12711-026-01070-9
LA - en
ER -

CSL-JSON

{
"id": "10.1186/s12711-026-01070-9",
"type": "article-journal",
"title": "A non-linear game for two: genetic parameters and prediction of fertilization success using Bayesian and machine learning frameworks",
"container-title": "Genetics, selection, evolution : GSE",
"author": [
{
"family": "Pappas",
"given": "Fotis"
},
{
"family": "Debes",
"given": "Paul Vincent"
},
{
"family": "Johnsson",
"given": "Martin"
},
{
"family": "Palaiokostas",
"given": "Christos"
}
],
"container-title-short": "Genet Sel Evol",
"volume": "58",
"issue": "1",
"page": "34",
"DOI": "10.1186/s12711-026-01070-9",
"PMID": "42464095",
"PMCID": "PMC13377850",
"ISSN": "0999-193X",
"publisher": "BMC",
"URL": "https://doi.org/10.1186/s12711-026-01070-9",
"language": "en",
"issued": {
"date-parts": [
[
2026,
7,
16
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.1038/s41467-026-75653-x [code]
Concept2Brain: an AI model for predicting neurophysiological responses to text and pictures.
Journal: Nature communications
In common: PyTorch, scikit-learn, pandas, 2 other tools, 2 references
[2] doi:10.7554/elife.107423 [code]
A context-free model of savings in motor learning.
Journal: eLife
In common: PyTorch, scikit-learn, pandas, 2 other tools, 2 references
[3] doi:10.1038/s42003-026-10957-8 [code]
Brain defence by the extracellular matrix protein Cochlin.
Journal: Communications biology
In common: Stan, PyTorch, scikit-learn, 3 other tools
[4] doi:10.7554/elife.108223 [code]
Two time scales of adaptation in human learning rates.
Journal: eLife
In common: Stan, pandas, Matplotlib, 1 other tool, 1 reference
[5] doi:10.3390/jcm15176501 [code]
Saliency-Curated Deep Learning for Predicting Receptor Status in Breast Cancer Brain Metastases.
Journal: Journal of clinical medicine
In common: PyTorch, scikit-learn, pandas, 2 other tools, 1 reference
[6] doi:10.34133/csbj.0076 [code]
SpheronizaTor: Spherical Voxelization for Interpretable Protein Microenvironment Modeling.
Journal: Computational and structural biotechnology journal
In common: PyTorch, scikit-learn, pandas, 2 other tools, 1 reference
[7] doi:10.1038/s41598-026-47814-x [code]
Predicting post-stroke functional outcome using explainable machine learning and integrated data.
Journal: Scientific reports
In common: PyTorch, scikit-learn, pandas, 2 other tools, 1 reference
[8] doi:10.64898/2026.03.30.715222 [code]
Synthetic lumen rounding directs neural progenitor division mode
Journal: bioRxiv (preprint)
In common: PyTorch, scikit-learn, pandas, 2 other tools, 1 reference
[9] doi:10.1186/s13293-026-00927-4 [code]
Gene regulatory network analysis identifies dysregulation of hypoxia pathways as contributing to glioblastoma treatment resistance in females.
Journal: Biology of sex differences
In common: Stan, PyTorch, pandas, 2 other tools
[10] doi:10.1016/j.stemcr.2026.102977 [code]
Integrative analysis of drug-gene signatures in human pluripotent stem cells reveals prazosin as a novel SQSTM1 regulator for ALS therapeutics.
Journal: Stem cell reports
In common: Stan, scikit-learn, pandas, 2 other tools

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.