OSCR

Using deep learning to identify inherited retinal diseases based on wide-field retinal imaging data.

Code ↔ Paper

7 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 7 matches
  1. [1] § 2 Methods › 2.4 Deep learning models ↔ KcrossValidationProcess.py, lines 32–93 · score 0.62 · cross entropy loss, subsets, optimizer, weights, fold, cropping
  2. [2] § 2 Methods › 2.4 Deep learning models ↔ Augmentations.py, lines 5–16 · score 0.61 · horizontal flips, translations, vertical, probabilistically, augmentation, training
  3. [3] § 2 Methods › 2.6 Performance evaluation and statistical analysis ↔ MainProcess.py, lines 89–162 · score 0.57 · confusion matrices, F1 score, recall, AUC, precision, accuracy
  4. [4] § 2 Methods › 2.6 Performance evaluation and statistical analysis ↔ Utils.py, lines 103–121 · score 0.56 · confusion matrices, F1 score, recall, AUC, precision, accuracy
  5. [5] § 2 Methods › 2.4 Deep learning models ↔ Utils.py, lines 124–133 · score 0.55 · 47.5–72.5 %, center cropping
  6. [6] § 2 Methods › 2.4 Deep learning models ↔ Main.py, lines 32–38 · score 0.51 · cross entropy loss, weights, cropping, batch, training, class
  7. [7] § 3 Results ↔ Utils.py, lines 103–121 · score 0.50 · confusion matrices, F1 score, AUC, precision, accuracy, predictive

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

Python · 416 lines · 15 KB · no license · 3 matches

  1. import copy
  2. import glob
  3. import random
  4. import numpy as np
  5. import cv2
  6. import matplotlib.pyplot as plt
  7. import torch
  8. import torchvision
  9. from matplotlib.patches import Rectangle
  10. from torchvision.utils import save_image
  11. import os
  12. import shutil
  13. import imageio as iio
  14. import matplotlib.patches as mpatches
  15. import torchvision.transforms as transforms
  16. import pandas as pd
  17. import sklearn.metrics as met
  18. import imblearn.metrics as immet
  19. import csv
  20. import math
  21. from sklearn.metrics import recall_score
  22. from sklearn.metrics import roc_auc_score
  23. GPU = True
  24. import albumentations as A
  26. import matplotlib
  27. matplotlib.use('TkAgg')
  30. def save_decoded_image(img, name):
  31. save_image(img.view(img.shape), name)
  34. def normalize_img(img):
  35. norm = transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
  36. return norm(img)
  39. # scale : X -> unnormalize to (0,X)
  40. def unnormalize_img(img, scale):
  41. img = img / 2 + 0.5
  42. return img*scale
  45. def get_device():
  46. if GPU:
  47. if torch.cuda.is_available():
  48. device = 'cuda:0'
  49. else:
  50. device = 'cpu'
  52. return device
  53. # return 'cpu'
  56. def makedir(path):
  57. if not os.path.exists(path):
  58. os.mkdir(path)
  61. def rgb2gray(rgb):
  62. return np.dot(rgb[..., :3], [0.2125, 0.7154, 0.0721])
  65. def output_learning_graph(tr_losses, dev_losses, output_file_name, threshold=5):
  66. # for better visualization
  67. plt.figure()
  68. tr_losses_norm = [x if x < threshold else threshold for x in tr_losses]
  69. dev_losses_norm = [x if x < threshold else threshold for x in dev_losses]
  70. iteration = np.arange(0, len(tr_losses_norm))
  71. plt.plot(iteration, tr_losses_norm, 'g-', iteration, dev_losses_norm, 'r-')
  72. plt.xlabel('iteration')
  73. plt.ylabel('loss')
  74. green_patch = mpatches.Patch(color='green', label='train')
  75. red_patch = mpatches.Patch(color='red', label='test')
  76. plt.legend(handles=[green_patch, red_patch])
  77. plt.savefig(f'{output_file_name}.png')
  78. # plt.show()
  79. # the images should be normalized to (-1,1)
  82. def write_results_to_file(accuracy, f1_score, precision, sensitivity, specificity, recall, auc, class_accuracy, subjects_list, label_list, predicted_list, train_or_test, output_file_name, classes, topk_accuracy):
  83. file_name = f'{output_file_name}_{train_or_test}_results.csv'
  84. df_dict = {'subject': subjects_list, 'ground_truth': label_list, 'predicted': predicted_list}
  85. df = pd.DataFrame(df_dict)
  86. df.to_csv(file_name)
  88. with open(file_name, 'a') as f:
  89. writer = csv.writer(f)
  90. if topk_accuracy:
  91. writer.writerow([f'top5_accuracy: {topk_accuracy}'])
  92. writer.writerow([f'accuracy: {accuracy}'])
  93. writer.writerow([f'f1_score: {f1_score}'])
  94. writer.writerow([f'precision: {precision}'])
  95. writer.writerow([f'sesitivity: {sensitivity}'])
  96. writer.writerow([f'specificity: {specificity}'])
  97. writer.writerow([f'recall: {recall}'])
  98. writer.writerow([f'auc: {auc}'])
  99. for i, cs in enumerate(class_accuracy):
  100. writer.writerow([f'{classes[i]} accuracy : {cs})'])
  103. def calculate_scores(predicted_list, label_list, classes, proba_predicted=None):
  104. accuracy = sum(predicted_list == label_list) / len(predicted_list) * 100
  105. f1_score = met.f1_score(label_list, predicted_list, average='macro', zero_division=0.0) * 100
  106. mat = met.confusion_matrix(label_list, predicted_list, labels=list(range(len(classes))))
  107. specificity = immet.specificity_score(label_list, predicted_list, average='weighted')*100
  108. sensitivity = immet.sensitivity_score(label_list, predicted_list, average='weighted')*100
  109. precision = met.classification_report(label_list, predicted_list, labels=list(np.arange(len(classes))), target_names=classes, output_dict=True, zero_division=0.0)['weighted avg']['precision']*100
  110. recall = recall_score(label_list, predicted_list, average='weighted')*100
  111. try:
  112. if proba_predicted:
  113. auc = roc_auc_score(vector_to_one_hot(label_list, len(classes)), proba_predicted, average='weighted') * 100
  114. else:
  116. auc = roc_auc_score(vector_to_one_hot(label_list, len(classes)), vector_to_one_hot(predicted_list, len(classes)), average='weighted')*100
  117. except:
  118. auc = 0
  121. return accuracy, f1_score, specificity, sensitivity, precision, mat, recall, auc
  124. def crop(image, crop_rate=False):
  125. height = len(image)
  126. width = len(image[0])
  127. crop_number = random.uniform(0.475, 0.725) #(0.375, 0.625)
  128. if crop_rate:
  129. crop_number = crop_rate
  130. cropped_height = int(height*crop_number)
  131. cropped_width = int(width*crop_number)
  132. crop_transform = A.CenterCrop(height=cropped_height, width=cropped_width)
  133. return crop_transform(image=image)['image']
  136. def crop_two_images(image1, image2, crop_rate=0.75):
  137. height = len(image1)
  138. width = len(image1[0])
  139. crop_number = crop_rate #random.uniform(0.75, 1.25)
  140. cropped_height = int(height * crop_number)
  141. cropped_width = int(width * crop_number)
  142. crop_transform = A.CenterCrop(height=cropped_height, width=cropped_width)
  143. return crop_transform(image=image1)['image'], crop_transform(image=image2)['image']
  146. def labels_count(data, classes, loader=False):
  147. labels = []
  148. if not loader:
  149. for subject in data:
  150. labels.append(subject.get_labels())
  151. else:
  152. for subject in data:
  153. labels.extend(subject[2])
  155. uniques, counts = np.unique(np.array(labels), return_counts=True)
  156. for unique, count in zip(uniques, counts):
  157. print(f'gene: {classes[unique]}, count: {count} ')
  158. distribution = np.zeros(len(classes))
  159. distribution[uniques] = counts
  160. class_distribution = [(count/sum(counts))*100 for count in distribution]
  161. print(class_distribution)
  162. return np.array(class_distribution)
  165. # same as above just for dataloader to count after sampling
  166. def count_labels_loader(loader):
  167. count = np.zeros(25)
  168. for data in loader:
  169. subjects, scans, labels = data
  170. for i in range(25):
  171. count[i] += labels.tolist().count(i)
  173. print(count/sum(count)) # the distribution is now right for some reason
  176. def np_permute(image, in_axis=0, out_axis=2):
  177. permuted = []
  178. for i in range(image.shape[in_axis]):
  179. permuted.append(np.take(image, i, axis=in_axis))
  180. return np.stack(permuted, axis=out_axis)
  183. def denormalize(image):
  184. image = np_permute(image)
  185. mean = np.array([0.28, 0.28, 0.20])
  186. std = np.array([0.16, 0.16, 0.15])
  188. image = image * std + mean
  189. image = np.clip(image, 0, 1)
  190. return image
  193. def show_one_batch(classes, dataiter, batch_size):
  194. # labels should be one hot vector (or not?)
  195. subjects, images, labels = next(dataiter)
  196. faf = images[0]
  197. color = images[1]
  198. plt.imshow(np_permute(torchvision.utils.make_grid(faf)))
  199. plt.show()
  200. plt.imshow(np_permute(torchvision.utils.make_grid(color)))
  201. plt.show()
  202. print(' '.join('%5s' % classes[labels[j]] for j in range(batch_size)))
  205. def rgba2rgb(rgba, background=(255, 255, 255)):
  206. row, col, ch = rgba.shape
  208. if ch == 3:
  209. return rgba
  211. assert ch == 4, 'RGBA image has 4 channels.'
  213. rgb = np.zeros((row, col, 3), dtype='float32' )
  214. r, g, b, a = rgba[:,:,0], rgba[:,:,1], rgba[:,:,2], rgba[:,:,3]
  216. a = np.asarray(a, dtype='float32' ) / 255.0
  217. # a[a > 0.01] = 1
  218. # a[a <= 0.01] = 0
  219. R, G, B = background
  221. rgb[:,:,0] = r * a + (1.0 - a) * R
  222. rgb[:,:,1] = g * a + (1.0 - a) * G
  223. rgb[:,:,2] = b * a + (1.0 - a) * B
  225. return np.asarray(rgb, dtype='uint8')
  228. def crop_by_pixel_value(img, save_rate=0.5, color=255):
  229. width, height = (img.shape[1], img.shape[0])
  230. up = 0
  231. down = height
  232. left = 0
  233. right = width
  234. for i in range(int(height / (8 / 3)), -1, -1):
  235. # we want to check if a row or a column across all 3
  236. # channels have at least 10 percent of white pixels, then we will remove it
  237. if sum(np.all(img[i, :, :] == color, axis=1)) >= width * save_rate:
  238. up = i
  239. break
  240. for i in range(int(height / (8 / 5)), height, 1):
  241. if sum(np.all(img[i, :, :] == color, axis=1)) >= width * save_rate:
  242. down = i
  243. break
  244. for i in range(int(width / (8 / 3)), -1, -1):
  245. if sum(np.all(img[:, i, :] == color, axis=1)) >= height * save_rate:
  246. left = i
  247. break
  248. for i in range(int(width / (8 / 5)), width, 1):
  249. if sum(np.all(img[:, i, :] == color, axis=1)) >= height * save_rate:
  250. right = i
  251. break
  252. img = img[up:down, left:right, :]
  253. return img, (up, down, left, right)
  256. # img - the img to process
  257. # thresh_hold - the threshold value for the pixels we want to color
  258. # crop - whether to crop the image or not
  259. # color - the color to color the chosen pixels
  260. # save_rate - the rate of colored_pixels in a row or column in order to remove it
  261. def change_color_background(img, thresh_hold=35, crop=True, save_rate=0.5, color=0, size=224):
  262. changed = copy.deepcopy(img)
  263. if color == 'avg':
  264. pass
  265. changed[np.all(img <= thresh_hold, axis=2)] = color
  266. if crop:
  267. changed, dimensions = crop_by_pixel_value(changed, save_rate, color)
  269. resize = A.Resize(size, size)
  270. changed = resize(image=changed)['image']
  271. return changed, dimensions
  274. # helper function for crop_with_beam
  275. def find_boundaries(beam_values, high_derivative_threshold, small_derivative_threshold, low_derivative_distance):
  276. boundary = len(beam_values)-1
  277. derivative = np.abs(beam_values[1:] - beam_values[:-1])
  278. high_derivative = np.argwhere(derivative > high_derivative_threshold).T[0]
  280. for der in high_derivative:
  281. if der + 1 + low_derivative_distance >= boundary:
  282. if (beam_values[der + 1:] < small_derivative_threshold).all():
  283. boundary = der + 1
  284. break
  285. elif (beam_values[der+1: der+1+low_derivative_distance] < small_derivative_threshold).all():
  286. boundary = der + 1
  287. break
  289. return boundary
  292. # img: the image to process
  293. # derivative_threshold: the difference in derivative we start cropping from
  294. # low_derivative_distance: amount of pixels with low derivative o-
  295. # starting_distance: start step
  296. def crop_with_beam(img, high_derivative_threshold=20, small_derivative_threshold=5, low_derivative_distance=0.01, color=255, starting_distance=1, crop=False):
  298. relevant_coordinates = []
  299. width, height = (img.shape[1], img.shape[0])
  300. middle_point_y = int(width/2)
  301. middle_point_x = int(height/2)
  302. x = 0
  303. y = 0
  304. mask = np.zeros((img.shape[0], img.shape[1]), dtype=np.bool)
  305. thetas = [x/10 for x in range(360)] # we change the degree in 0.1 every step
  306. for theta in thetas:
  307. beam_values = []
  308. beam_coordinates = []
  309. r = starting_distance
  310. # first_step
  311. y = middle_point_y - math.floor(r * np.sin(theta))
  312. x = middle_point_x + math.floor(r * np.cos(theta))
  313. beam_values.append(img[x, y])
  314. beam_coordinates.append((x, y))
  315. r += 1
  316. y = middle_point_y - math.floor(r * np.sin(theta))
  317. x = middle_point_x + math.floor(r * np.cos(theta))
  318. # rest of the steps
  319. while height > x >= 0 and width > y >= 0:
  320. # check that the step was big enough to change pixel
  321. if beam_coordinates[-1][0] != x or beam_coordinates[-1][1] != y:
  322. beam_values.append(img[x, y])
  323. beam_coordinates.append((x, y))
  324. r += 1
  325. y = middle_point_y - math.floor(r * np.sin(theta))
  326. x = middle_point_x + math.floor(r * np.cos(theta))
  328. # we need to find the drastic change in derivative in every channel and choose the first one that occurs
  329. relevant_coordinates_red = find_boundaries(np.asarray(beam_values, dtype=np.longlong)[:, 0], high_derivative_threshold, small_derivative_threshold, int(round(low_derivative_distance*width)))
  330. relevant_coordinates_green = find_boundaries(np.asarray(beam_values, dtype=np.longlong)[:, 1], high_derivative_threshold, small_derivative_threshold, int(round(low_derivative_distance*width)))
  331. relevant_coordinates_blue = find_boundaries(np.asarray(beam_values, dtype=np.longlong)[:, 2], high_derivative_threshold, small_derivative_threshold, int(round(low_derivative_distance*width)))
  333. relevant_coordinates.extend(beam_coordinates[min(relevant_coordinates_red, relevant_coordinates_green, relevant_coordinates_blue):])
  335. for coordinate in relevant_coordinates:
  336. mask[coordinate[0], coordinate[1]] = True
  338. changed = copy.deepcopy(img)
  339. changed[mask] = 255
  341. if crop:
  342. changed, _ = crop_by_pixel_value(changed, save_rate=0.1)
  344. return changed
  347. def extract_results(path, correct_dictionary):
  348. df = pd.read_csv(path)
  349. for index, row in df.iterrows():
  350. name = row[1]
  351. ground_truth = row[2]
  352. predicted = row[3]
  353. result = int(ground_truth == predicted)
  355. if correct_dictionary.get(name):
  356. correct_dictionary[name] += result
  357. else:
  358. correct_dictionary[name] = result
  359. return correct_dictionary
  362. def find_repeated_mistake(path='/media/neuro/LivnyLab/General/TEAM_Folders/Tim/IRD'):
  363. num_of_cases = 0
  364. correct_dictionary = {}
  365. for directory in os.listdir():
  366. try:
  367. if directory[:3] == 'run':
  368. results = f'{path}/{directory}/train_train_results.csv'
  369. num_of_cases += 1
  370. extract_results(results, correct_dictionary)
  371. except:
  372. continue
  373. sorted_scan_accuracy = sorted(correct_dictionary.items(), key=lambda x: x[1])
  374. print(sorted_scan_accuracy)
  377. def vector_to_one_hot(target, num_classes):
  378. one_hot = np.zeros((len(target), num_classes))
  379. one_hot[np.arange(len(target)), target.astype(int)] = 1
  380. return one_hot
  383. def compareModelWeights(model1, model2):
  384. for p1, p2 in zip(model1.parameters(), model2.parameters()):
  385. if p1.data.ne(p2.data).sum() > 0:
  386. return False
  387. return True
  390. def get_labels_and_groups(dataset):
  391. groups = []
  392. group_subjects = []
  394. labels = []
  395. for i, subject in enumerate(dataset):
  396. labels.append(subject[-1])
  397. group = subject[0].split('.')[0] #+subject[0].split('.')[-1]
  398. try:
  399. group_subjects.append(groups.index(group))
  400. except:
  401. groups.append(group)
  402. group_subjects.append(groups.index(group))
  404. return labels, group_subjects
  405. # calculate_kcross_average('/media/neuro/C_BIRD/LivnyLab/General/TEAM_Folders/Tim/IRD/run 192 batch size = 36 FIRST STAGE 10 folds cf + faf different seed 150 iterations seed = 5', 18, 'test')
  408. def calculate_topk_accuracy(topk_predicted, label_list, k):
  409. # Check if true label is within top-k predictions for each sample
  410. correct_predictions = np.any(topk_predicted == label_list.reshape(-1, 1), axis=1)
  412. # Calculate accuracy
  413. accuracy = sum(correct_predictions)/len(label_list)
  415. return accuracy*100

Utils.py at commit d419615, no license · at the source

Overview

Authors: Leo Joskowicz1, Tim Buchbinder1, Eldan Chodorov1, Assaf Hoogi2, Katherine Matos3, Antonio Rivera3, Dror Sharon3, Eyal Banin3, Jaime Levy3
ORCID iDs: Assaf Hoogi, Jaime Levy
  1. School of Computer Science and Engineering, The Hebrew University of Jerusalem, Jerusalem, Israel
  2. School of Computer Science, Ariel University, Ariel, Israel,‌‌
  3. Department of Ophthalmology, Hadassah Medical Center, Faculty of Medicine, The Hebrew University of Jerusalem, Jerusalem, Israel
Institutions: Hebrew University of Jerusalem (Israel); Ariel University (Israel); Hadassah Medical Center (Israel)
Journal: PloS one, volume 21, issue 5, article e0348866
Dates: received 2 December 2024; accepted 22 April 2026; published online 11 May 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1371/journal.pone.0348866 · PMID 42113772 · PMCID PMC13160341 · OpenAlex W7160864879
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: other (modality), human (organism), clinical / translational (subfield)
Methods: Statistics, Machine learning
MeSH: Deep Learning*, Retina*, Retinal Diseases*, Convolutional Neural Networks, Fundus Oculi, Humans, Image Processing, Computer-Assisted, Optical Imaging, Retrospective Studies (* major topic)
Topic: Retinal Imaging and Analysis (Radiology, Nuclear Medicine and Imaging, Medicine), according to OpenAlex
Citations: cited by 1 paper (Europe PMC); 34 references in the paper

Abstract

Objective: To evaluate a novel image-based deep learning method for the automated identification of inherited retinal diseases (IRDs) and to explore the feasibility of predicting selected causative gene groups using a multimodal analysis of wide-field fundus autofluorescence (FAF) and pseudocolor fundus (pCF) images.

Design: The method was evaluated using a retrospective dataset of patient studies containing FAF and pCF images, as well as genetic tests for IRD.

Participants: Patients with confirmed IRD for which both wide-field FAF and pCF images and genetic tests for IRD performed at Hadassah University Medical Center were included. The dataset consisted of 409 patients (330 patients with IRD with the 25 most commonly affected genes in our population and patients without IRD, and 79 patients without IRD).

Methods: Nine EfficientNet-V2-m convolutional neural networks were trained for the following three classification tasks: a binary IRD vs. non-IRD classification, and classification into two groups of five causative genes (Groups 1 and 2). For each task, three models were trained on the FAF images only, the pCF images only, and both the FAF and pCF images. The performance of the models was then evaluated and compared using 5-fold cross-validation.

Main outcome measures: Accuracy, precision, F1 scores, AUC, and confusion matrices.

Results: The multimodal classification models that were trained on both the FAF and pCF images yielded the best results. The binary classification model had a mean (±SD) accuracy of 0.95 ± 0.01, a mean precision of 0.92 ± 0.01, and a mean F1 score of 0.90 ± 0.02. The Group 1 classification model had a mean accuracy of 0.92 ± 0.03, a mean precision of 0.93 ± 0.03, and a mean F1 score of 0.89 ± 0.03. Finally, the Group 2 classification model had a mean accuracy of 0.85 ± 0.03, a mean precision of 0.87 ± 0.04, and a mean F1 score of 0.83 ± 0.04.

Conclusions: Our results indicate that determining whether a patient has IRD can be performed with high accuracy within this retrospective cohort based on FAF and pCF images using image-based deep learning classifiers. This image-based approach may assist clinicians during the patient’s initial visit by providing decision support prior to genetic testing. It may also help prioritize patients for genetic workup, particularly in settings in which genetic testing is not readily available. Further prospective and external validation is required before clinical implementation.

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 7 matches between paragraphs and lines of code.

timshik/Deep-learning-based-identification-of-inherited-retinal-disease-using-wide-field-retina-imaging

License: none: the authors keep all their rights
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Commit: d4196159f13abe62b7baba1111d6fd5fac070876, 24 October 2024
Languages: Python (17)
Size: 19 files, 17 scripts
Software Heritage: not archived
Found in: “Data Availability”
Holds: README
Not found: license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: PyTorch (11 files), NumPy (7 files), Matplotlib (5 files), OpenCV (4 files), scikit-learn (4 files), pandas (2 files), Pillow (2 files), SciPy (2 files), imageio (1 file), imbalanced-learn (1 file), MONAI (1 file), Plotly (1 file), scikit-image (1 file), seaborn (1 file)
Availability: 1 check, the latest on 28 September 2026: the link answers
  • 28 September 2026: the link answers
18 files
At the source: github.com/timshik/Deep-learning-based-identification-of-inherited-retinal-disease-using-wide-field-retina-imaging

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;
  • 17 scripts, each with its path and the digest of its content;
  • 7 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

All data supporting the findings of this study are available within the manuscript and in supplementary materials. Due to patient privacy and ethical restrictions, raw retinal images cannot be made publicly available. However, all aggregated performance metrics, confusion matrices, model architecture details, and hyperparameters are provided within the manuscript and supplementary materials. The code is available at: https://github.com/timshik/Deep-learning-based-identification-of-inherited-retinal-disease-using-wide-field-retina-imaging.

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, 28 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 9 authors, 9 MeSH terms, 29 references.

Cite

This paper

Joskowicz, L., Buchbinder, T., Chodorov, E., Hoogi, A., Matos, K., Rivera, A., Sharon, D., Banin, E., & Levy, J. (2026). Using deep learning to identify inherited retinal diseases based on wide-field retinal imaging data. PloS one, 21(5), e0348866. https://doi.org/10.1371/journal.pone.0348866

BibTeX

@article{joskowicz2026using,
author = {Joskowicz, Leo and Buchbinder, Tim and Chodorov, Eldan and Hoogi, Assaf and Matos, Katherine and Rivera, Antonio and Sharon, Dror and Banin, Eyal and Levy, Jaime},
title = {{Using deep learning to identify inherited retinal diseases based on wide-field retinal imaging data}},
journal = {PloS one},
year = {2026},
month = may,
volume = {21},
number = {5},
pages = {e0348866},
publisher = {PLOS},
issn = {1932-6203},
doi = {10.1371/journal.pone.0348866},
url = {https://doi.org/10.1371/journal.pone.0348866},
pmid = {42113772},
pmcid = {PMC13160341}
}

RIS

TY - JOUR
AU - Joskowicz, Leo
AU - Buchbinder, Tim
AU - Chodorov, Eldan
AU - Hoogi, Assaf
AU - Matos, Katherine
AU - Rivera, Antonio
AU - Sharon, Dror
AU - Banin, Eyal
AU - Levy, Jaime
TI - Using deep learning to identify inherited retinal diseases based on wide-field retinal imaging data
T2 - PloS one
J2 - PLoS One
PY - 2026
DA - 2026/05/11
VL - 21
IS - 5
SP - e0348866
SN - 1932-6203
PB - PLOS
DO - 10.1371/journal.pone.0348866
UR - https://doi.org/10.1371/journal.pone.0348866
LA - en
ER -

CSL-JSON

{
"id": "10.1371/journal.pone.0348866",
"type": "article-journal",
"title": "Using deep learning to identify inherited retinal diseases based on wide-field retinal imaging data",
"container-title": "PloS one",
"author": [
{
"family": "Joskowicz",
"given": "Leo"
},
{
"family": "Buchbinder",
"given": "Tim"
},
{
"family": "Chodorov",
"given": "Eldan"
},
{
"family": "Hoogi",
"given": "Assaf"
},
{
"family": "Matos",
"given": "Katherine"
},
{
"family": "Rivera",
"given": "Antonio"
},
{
"family": "Sharon",
"given": "Dror"
},
{
"family": "Banin",
"given": "Eyal"
},
{
"family": "Levy",
"given": "Jaime"
}
],
"container-title-short": "PLoS One",
"volume": "21",
"issue": "5",
"page": "e0348866",
"DOI": "10.1371/journal.pone.0348866",
"PMID": "42113772",
"PMCID": "PMC13160341",
"ISSN": "1932-6203",
"publisher": "PLOS",
"URL": "https://doi.org/10.1371/journal.pone.0348866",
"language": "en",
"issued": {
"date-parts": [
[
2026,
5,
11
]
]
}
}

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.3389/frai.2026.1771088 [code]
Few-shot deployment of pretrained MRI transformers in brain imaging tasks.
Journal: Frontiers in artificial intelligence
In common: MONAI, imageio, OpenCV, 9 other tools
[2] doi:10.1038/s42003-026-10957-8 [code]
Brain defence by the extracellular matrix protein Cochlin.
Journal: Communications biology
In common: imbalanced-learn, Plotly, OpenCV, 9 other tools
[3] doi:10.1016/j.isci.2026.116825 [code]
Social hierarchy shapes behavioral and transcriptional responses to chronic stress and ketamine in male mice.
Journal: iScience
In common: imbalanced-learn, Plotly, OpenCV, 9 other tools
[4] doi:10.1186/s12880-026-02481-2 [code]
Deep learning-based neuroanatomical profiling reveals population-specific brain changes in multiple sclerosis: a large-scale Middle Eastern study.
Journal: BMC medical imaging
In common: imageio, Plotly, OpenCV, 8 other tools, clinical / translational
[5] doi:10.3389/fnins.2026.1870124 [code]
An end-to-end pipeline for automated fetal brain segmentation and biometry from 3D SSFP MRI.
Journal: Frontiers in neuroscience
In common: MONAI, imageio, OpenCV, 8 other tools
[6] doi:10.1371/journal.pcbi.1013499 [code]
VesiclePy: A machine learning vesicle analysis toolbox for volume electron microscopy.
Journal: PLoS computational biology
In common: imageio, Plotly, OpenCV, 8 other tools
[7] doi:10.1016/j.xcrm.2026.102766 [code]
A longitudinal single-cell and spatial multiomic atlas of pediatric high-grade glioma.
Journal: Cell reports. Medicine
In common: imageio, Plotly, OpenCV, 8 other tools
[8] doi:10.1038/s41598-026-57519-w [code]
Automated segmentation of neurons and spinal cord structures in immunofluorescence images using SpineDL.
Journal: Scientific reports
In common: imageio, Plotly, OpenCV, 8 other tools
[9] doi:10.1371/journal.pcbi.1014571 [code]
SynAPSeg: A novel dataset and image analysis framework for deep learning-based synapse detection and quantification.
Journal: PLoS computational biology
In common: imageio, OpenCV, scikit-image, 8 other tools
[10] doi:10.1038/s41593-026-02388-9 [code]
Hippocampal CA3 connectomics reveals a gradient of mossy fiber inputs and selective feedforward inhibition onto pyramidal cells.
Journal: Nature neuroscience
In common: imageio, Plotly, OpenCV, 8 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.