Latest / Glaucoma, Vision & Longevity: Supplements & Science / Eyes Wide Open: How Karpathy's Autoresearch Framework Could Democratize Glaucoma Research — A Blueprint for Patient-Led, AI-Driven Discovery in Vision Restoration

Transcript

Eyes Wide Open: How Karpathy's Autoresearch Framework Could Democratize Glaucoma Research — A Blueprint for Patient-Led, AI-Driven Discovery in Vision Restoration · Glaucoma, Vision & Longevity: Supplements & Science

• 0:00
  SPEAKER_00: Eyes Wide Open How Carpathy's Auto Research Framework Could Democratize Glaucoma Research.
• 0:06
  SPEAKER_00: Introduction.
• 0:07
  SPEAKER_00: Glaucoma is a chronic optic neuropathy that progressively destroys the retinal ganglion cells, RGCs, and leads to irreversible vision loss.
• 0:15
  SPEAKER_00: It affects millions worldwide, an estimated 64.3 million people in 2013, projected to rise above 110 million by 2040.
• 0:24
  SPEAKER_00: Worryingly, about half of all cases remain undiagnosed until vision loss has already begun.
• 0:31
  SPEAKER_00: Traditional glaucoma care is focused on lowering intraocular pressure through medications or surgery, but these treatments cannot reverse damage or fully prevent blindness.
• 0:42
  SPEAKER_00: As a result, there is an urgent need for new discovery in areas like neuroprotection, RGC optic nerve regeneration, and innovative gene and cell therapies.
• 0:52
  SPEAKER_00: However, academic and pharma research on these frontiers remains under-resourced, partly because they are long-term high-risk efforts.
• 1:00
  SPEAKER_00: Meanwhile, advances in machine learning, ML, and artificial intelligence, AI, are empowering new approaches to data analysis and generative design.
• 1:09
  SPEAKER_00: Recent work, for example, Andre Carpathy's Auto Research Project, suggests that AI agents can autonomously run hundreds of small experiments on a single GPU based only on simple high-level instructions.
• 1:23
  SPEAKER_00: In this paradigm, a human writes a short programmed MD describing the research goal, and an AI agent iteratively tweaks the model or hyperparameters, running five-minute training runs, keeping successful changes, and discarding others.
• 1:38
  SPEAKER_00: Overnight, this loop can perform on the order of 100 experiments, exploring architecture and parameter space without manual coding.
• 1:46
  SPEAKER_00: This article explores how Carpathy's auto research framework could be applied to glaucoma research by motivated patients, caregivers, citizen scientists, and open source developers.
• 1:58
  SPEAKER_00: We will survey underexplored glaucoma research areas, neuroprotection, regeneration, etc., and identify machine learning tasks in each domain where small model experimentation could plausibly help.
• 2:10
  SPEAKER_00: For each task, we suggest specific public data sets, baseline models architectures, evaluation metrics, and outline what the agent's program.
• 2:21
  SPEAKER_00: We then discuss practical steps for a community to set up and share such experiments, including hardware considerations, data preparation, and collaboration platforms.
• 2:30
  SPEAKER_00: We examine the specific context of vision restoration therapies and whether auto research style loops might speed up optimization of neural prosthesis or other interventions.
• 2:41
  SPEAKER_00: Finally, we address how citizen-generated hypotheses could be validated and escalated to clinicians and lay out a concrete 90-day roadmap for launching a patient-led auto research initiative, including how to avoid pitfalls of research theater and ensure real impact.
• 2:59
  SPEAKER_00: Throughout, we cite current sources on glaucoma research and AI envision, aiming for a balanced, realistic, and accessible guide.
• 3:07
  SPEAKER_00: The glaucoma research landscape unmet needs.
• 3:10
  SPEAKER_00: Glaucoma research spans multiple fronts, from understanding disease mechanisms to developing new therapies for neuroprotection and vision restoration.
• 3:19
  SPEAKER_00: Many promising areas are under-resourced.
• 3:21
  SPEAKER_00: Neuroprotection, interventions that protect RGCs from dying, independent of IOP.
• 3:27
  SPEAKER_00: Examples include neurotrophic factors and metabolic support.
• 3:31
  SPEAKER_00: For instance, implants releasing ciliary neurotrophic factor, CNTF, have shown potential in early trials, and other molecules like nerve growth factor and acetylene are being investigated.
• 3:43
  SPEAKER_00: However, these are not yet standard care, and more work is needed to translate them to patients.
• 3:49
  SPEAKER_00: A 2025 review warns that neuroprotective glaucoma therapies are a future treatment needing further trials, reflecting an unmet need.
• 3:58
  SPEAKER_00: RGC regeneration and optic nerve regeneration.
• 4:01
  SPEAKER_00: Once RGCs and their axons die, current medicine has no way to reverse that.
• 4:06
  SPEAKER_00: Some animal studies use gene therapies to reprogram RGCs or stimulate regrowth.
• 4:11
  SPEAKER_00: For example, CRISPR-based repression of P10, a negative growth regulator, has promoted axon regrowth in rat neural cells, and experiments co-deleting P10 and SOX-3 drove sustained optic nerve regeneration in mice.
• 4:25
  SPEAKER_00: However, these breakthroughs remain in lab models.
• 4:28
  SPEAKER_00: The underlying biology, e.g., how to recapitulate retinal development or bypass growth inhibitors, is complex.
• 4:35
  SPEAKER_00: There is a huge demand for modalities, small molecules, genes, biomaterials, that could stimulate RGC survival or axon regrowth, but progress to human trials is slow.
• 4:45
  SPEAKER_00: Gene and cell therapies.
• 4:47
  SPEAKER_00: New technologies like CRISPR viral vectors and stem cell-derived RGCs hold promise for glaucoma.
• 4:53
  SPEAKER_00: Strategies include gene editing to reduce IOP, e.g., targeting aqueous humor production, or modulate neurodegenerative pathways.
• 5:01
  SPEAKER_00: Stem cells could, theoretically, replace lost trabecular meshwork cells or RGCs and secrete protective factors.
• 5:08
  SPEAKER_00: Early work has shown that certain transcription factors, e.g.
• 5:11
  SPEAKER_00: Oct4, SOX2K4, can reprogram non-RGCs into RGC-like neurons in mice, restoring vision and optic nerve injury.
• 5:20
  SPEAKER_00: Yet these approaches face safety and delivery challenges before reaching patients.
• 5:26
  SPEAKER_00: Several recent reviews highlight gene therapy as an exciting but not yet clinical frontier for glaucoma.
• 5:32
  SPEAKER_00: In sum, molecular and cell innovations are advancing, but resources and trial data are limited, creating an opportunity for computational exploration, e.g., designing optimal viral constructs or predicting effective gene edits.
• 5:46
  SPEAKER_00: Electrical and optogenetic stimulation for vision restoration for patients with advanced glaucoma or combined diseases like retinitis pigmentosa, artificial vision prosthesis or optogenetic therapies aimed to bypass damaged RGCs, retinal implants, epiretinal or subretinal electrode arrays, and cortical implants have generated artificial percepts, phosphenes, but resolution is low and results vary widely.
• 6:12
  SPEAKER_00: A recent 2025 review on AI in visual prosthesis notes that AI algorithms show promise in optimizing prosthetic vision, particularly through enhanced image saliency extraction and stimulation strategies, though so far most studies are simulations.
• 6:28
  SPEAKER_00: In other words, machine learning can help transform camera images into patterns of stimulation that are most informative given the device's limits.
• 6:37
  SPEAKER_00: Optogenetics, making surviving retinal cells light-sensitive, and transcorneal electrical stimulation, TES pulses, are also being trial for glaucoma-related vision loss.
• 6:48
  SPEAKER_00: All these areas need extensive parameter tuning, e.g., spatiotemporal patterns of stimulation, gene expression vectors, tasks potentially suitable for autonomous ML search.
• 6:59
  SPEAKER_00: IOP-independent mechanisms.
• 7:01
  SPEAKER_00: Many people continue to lose vision despite well-controlled IOP.
• 7:05
  SPEAKER_00: Factors like impaired ocular blood flow, neurovascular dysfunction, or metabolic stress in the optic nerve head are recognized but not fully understood.
• 7:14
  SPEAKER_00: Genetic studies suggest significant IOP-independent components of glaucoma risk.
• 7:19
  SPEAKER_00: Biomarkers of these processes beyond pressure are urgently needed.
• 7:24
  SPEAKER_00: Also, half of glaucoma patients have normal tension disease, highlighting that high IOP is not the only culprit.
• 7:31
  SPEAKER_00: Research into vascular factors or other damage pathways is ongoing but fragmented.
• 7:36
  SPEAKER_00: Computational modeling or mining of large data sets, e.g., genome-wide association studies, could help identify novel mechanisms or therapeutic targets in this domain.
• 7:46
  SPEAKER_00: Biomarker discovery via imaging in fields.
• 7:49
  SPEAKER_00: Early detection and monitoring of glaucoma often rely on imaging, fundus photos, OCT, and functional tests, visual fields.
• 7:57
  SPEAKER_00: Advanced algorithms could uncover subtle biomarkers that human clinicians miss.
• 8:02
  SPEAKER_00: For example, deep learning has begun to detect pre-parametric visual field loss, changes in visible to standard field analysis.
• 8:10
  SPEAKER_00: Similarly, AI has been used to analyze OCT layer thickness profiles to predict glaucoma before overt damage.
• 8:17
  SPEAKER_00: However, there are not yet widely accepted AI biomarkers that are used clinically for screening or risk stratification.
• 8:24
  SPEAKER_00: Computational bottlenecks here include the need for large, well-labeled data sets and robust validation protocols.
• 8:31
  SPEAKER_00: Public challenges, refuge, airogs, etc., have begun to standardize data, but coverage of early stage disease is thin.
• 8:38
  SPEAKER_00: Further machine-driven discovery of multimodal biomarkers, combining OCT, fields, genetics, etc., remains an open frontier.
• 8:47
  SPEAKER_00: Where can small model ML help?
• 8:49
  SPEAKER_00: Many of the above describe high-level problems.
• 8:52
  SPEAKER_00: The bottlenecks often are data scarcity, many interacting variables, and slowly moving biology.
• 8:59
  SPEAKER_00: Where an auto research agent shines is in automating small-scale experiments on available data.
• 9:04
  SPEAKER_00: For example, if there is a modest dataset of OCT scans with and without early glaucoma, a citizen scientist can set up a rapid model testing loop to find what architecture best distinguishes them.
• 9:16
  SPEAKER_00: Likewise, small transformers on genomics or literature could suggest novel gene or drug candidates.
• 9:22
  SPEAKER_00: The key is focusing on narrow tasks with defined metrics, classification accuracy, AUC loss, and iterating quickly.
• 9:29
  SPEAKER_00: Areas with limited public data, e.g.
• 9:31
  SPEAKER_00: TS parameters or novel gene cocktails, might rely on synthetic data or proxies.
• 9:37
  SPEAKER_00: In the next section, we map specific ML tasks in glaucoma to the autoresearch approach.
• 9:42
  SPEAKER_00: Mapping autoresearch to glaucoma problems.
• 9:45
  SPEAKER_00: Carpathy's autoresearch framework is domain agnostic.
• 9:48
  SPEAKER_00: It can run experiments in any ML task provided by a prepare.py and train.py with a well-defined evaluation metric.
• 9:56
  SPEAKER_00: We identify several concrete glaucoma-related tasks and specify how an agent could tackle each.
• 10:02
  SPEAKER_00: Each use case below includes a publicly available dataset, if possible, a starting model or architecture, an evaluation metric, and a sketch of programmed MD instructions.
• 10:12
  SPEAKER_00: 2.1 OCT image analysis, structural detection and segmentation.
• 10:16
  SPEAKER_00: Task, early glaucoma detection from OCT scans.
• 10:20
  SPEAKER_00: OCT imaging provides cross-sectional views of retinal layers.
• 10:24
  SPEAKER_00: Thinning of the retinal nerve fiber layer, RNFL, and ganglion cell complex GCC can precede visual field loss.
• 10:30
  SPEAKER_00: We can treat this as a classification task, glaucoma vs.
• 10:33
  SPEAKER_00: Healthy, or regression, e.g.
• 10:35
  SPEAKER_00: output RNFL thickness.
• 10:37
  SPEAKER_00: Data set, a recent release SinoCet, is a synthetic dataset of 200,000 circumpapillary OCT images, 100K glaucoma, 100K normal, generated by GANs.
• 10:47
  SPEAKER_00: Each image has associated RNFL thickness and segmentation masks.
• 10:52
  SPEAKER_00: These are publicly available on Zenodo.
• 10:54
  SPEAKER_00: Though synthetic, they are statistically validated to mimic real OCT.
• 10:59
  SPEAKER_00: Alternatively, one could use the OCT DL dataset, 2064 images of various retinal diseases, or smaller clinical OCT collections.
• 11:08
  SPEAKER_00: Model Start with a small convolutional neural network, CNN.
• 11:12
  SPEAKER_00: For classification, a model with 3 to 5 convolutional layers, e.g.
• 11:16
  SPEAKER_00: analogous to ResNet 18 truncated or a custom small CNN, can work.
• 11:21
  SPEAKER_00: For segmentation of RNFLGCC, an encoder decoder like a tiny UNET with depth 3 to 4 is suitable.
• 11:27
  SPEAKER_00: The initial train.py could implement a simple CNN and training loop with default hyperparameters.
• 11:33
  SPEAKER_00: Metric, if doing glaucoma classification on OCT, use A use area under rock, or accuracy on a validation split.
• 11:40
  SPEAKER_00: For segmentation, use DICE coefficient or IOU on RNFL layer masks.
• 11:44
  SPEAKER_00: SAN OCT provides masks.
• 11:46
  SPEAKER_00: Example Program.
• 11:47
  SPEAKER_00: Goal, maximize validation A for detecting glaucoma from OCT images.
• 11:51
  SPEAKER_00: Allowed modifications, number of conv layers, filter counts, kernel sizes, activation functions, learning rate, optimizer choice, batch size, etc.
• 12:00
  SPEAKER_00: After each five-minute training run, evaluate AUC on the held-out set.
• 12:04
  SPEAKER_00: If AUC improves, keep the change.
• 12:06
  SPEAKER_00: Otherwise revert.
• 12:08
  SPEAKER_00: The agent will thus try variations, e.g.
• 12:10
  SPEAKER_00: adding layers, adjusting width, switching from atom to RMS prop to improve AUC.
• 12:15
  SPEAKER_00: Task RNFL GCC layer segmentation.
• 12:17
  SPEAKER_00: Precisely measuring RNFL thickness is crucial.
• 12:20
  SPEAKER_00: Using synthetic OCT scans with provided segmentations or any real OCT with annotated layers, one can frame this as a segmentation task.
• 12:29
  SPEAKER_00: Dataset, CINAH again provides RNFL segmentation masks.
• 12:33
  SPEAKER_00: Another source.
• 12:34
  SPEAKER_00: Some academic groups have labeled OCTB scans, though often proprietary.
• 12:38
  SPEAKER_00: If needed, one might use generic OCT segmentation datasets like Duke Retina OCT Fluid Challenge as proxies.
• 12:45
  SPEAKER_00: Model, a small UNET-like CNN, perhaps even channel trimmed from a baseline, e.g., use three down-up blocks starting with 16 filters.
• 12:53
  SPEAKER_00: Agent is allowed to change depth and width.
• 12:56
  SPEAKER_00: Metric, dice score, or mean IOU of the predicted RNFL mask versus truth.
• 13:01
  SPEAKER_00: Example Program.md.
• 13:03
  SPEAKER_00: Goal Maximize the Dice score for RNFL layer segmentation on OCT.
• 13:07
  SPEAKER_00: The base model is a three-block UNET.
• 13:09
  SPEAKER_00: The agent may vary the number of filters, add dropout, or change learning rate.
• 13:13
  SPEAKER_00: Train for five minutes each trial and compute dice on validation.
• 13:17
  SPEAKER_00: Keep modifications that increase dice.
• 13:20
  SPEAKER_00: Task Progression Prediction via serial OCT.
• 13:23
  SPEAKER_00: Using sequential OCT, predict future thinning.
• 13:26
  SPEAKER_00: If longitudinal OCT data exist, e.g.
• 13:28
  SPEAKER_00: UK Biobank or private clinic data, the goal could be to predict RNFL change or a binary fast progressor label.
• 13:34
  SPEAKER_00: Data set, public longitudinal OCT data specific to glaucoma are scarce.
• 13:39
  SPEAKER_00: However, one could repurpose SROCT challenge data or SYN OCT images with simulated progression to simulate this task.
• 13:46
  SPEAKER_00: Alternatively, use UK Biobank OCT images, though not glaucoma-specific and not easily accessible to citizen scientists.
• 13:54
  SPEAKER_00: For illustration, assume a dataset of OCT scans at time zero and time one with labels.
• 14:00
  SPEAKER_00: Model, a Siamese or concatenated CNN taking pairs of OCT images, outputting probability of progression.
• 14:06
  SPEAKER_00: Start with feeding time zero and predicting time one cutoff.
• 14:10
  SPEAKER_00: Metric, AUC for binary progression classification, or MSE if trying to predict thickness change.
• 14:15
  SPEAKER_00: Example program dot goal?
• 14:17
  SPEAKER_00: Identify eyes that will have rapid RNFL loss.
• 14:20
  SPEAKER_00: Input, baseline OCT, label 5mm thinning after one year.
• 14:24
  SPEAKER_00: We use a CNN classifier.
• 14:26
  SPEAKER_00: Allowed changes include network depth, learning rate, augmentation.
• 14:30
  SPEAKER_00: Use validation AUC as the metric.
• 14:32
  SPEAKER_00: 2.2 visual field VF analysis task predict future visual field loss.
• 14:37
  SPEAKER_00: Given one or more past Humphrey visual field tests, pointwise sensitivity values, forecast future sensitivity or rate of progression.
• 14:45
  SPEAKER_00: This is a classic glaucoma management problem.
• 14:47
  SPEAKER_00: Data set, the GRAPE dataset 2023, provides longitudinal follow-up of 263 eyes, 115 records with VF and Fundus OCT, including annotated progression.
• 14:58
  SPEAKER_00: Another resource is the U.S.
• 15:00
  SPEAKER_00: UH Visual Field, U2HVF longitudinal database, 28,943 fields for many patients.
• 15:07
  SPEAKER_00: However, GRAPE is well curated and public with both VF and outcomes.
• 15:11
  SPEAKER_00: Model, a simple approach is a feedforward network, fully connected on the 54-point VF data or compressed to global indices.
• 15:18
  SPEAKER_00: For progression prediction, a smaller MLP or 1D CNN can handle the 54 or 30 input features.
• 15:25
  SPEAKER_00: Another idea, treat the 898 grid as a tiny image and use a small CNN, e.g.
• 15:30
  SPEAKER_00: 3.3 kernels.
• 15:31
  SPEAKER_00: Metric, if predicting future mean deviation or point values, use MSE, lower is better.
• 15:37
  SPEAKER_00: If classifying fast progressor versus not, use AUC.
• 15:40
  SPEAKER_00: Example program.md Goal, minimize MSE of predicted visual field.
• 15:45
  SPEAKER_00: Alternatively, maximize AUC for classifying rapid loss.
• 15:48
  SPEAKER_00: Base model, two layer perceptron on 54 VF values.
• 15:52
  SPEAKER_00: Agent can adjust hidden size, activation, or add dropout.
• 15:55
  SPEAKER_00: After each 5 min train, compute metric on val set.
• 15:59
  SPEAKER_00: Task, identify fast progressors.
• 16:02
  SPEAKER_00: Using a series of past VFs classify which eyes will lose vision quickly.
• 16:05
  SPEAKER_00: Data set, use the annotated progression status in GRAPE.
• 16:08
  SPEAKER_00: They marked eyes as progressed, or take UWH VF and label top decile of MD loss as fast.
• 16:15
  SPEAKER_00: Model could concatenate features from two or three consecutive fields or differences into a small network.
• 16:20
  SPEAKER_00: Possibly include baseline IOP and age if available.
• 16:23
  SPEAKER_00: Metric AUC for distinguishing fast versus slow progressors.
• 16:27
  SPEAKER_00: Example program MD Goal Maximize AUC for predicting rapid field progression.
• 16:33
  SPEAKER_00: Input features second order differences of VF1 and VF2 plus IOP.
• 16:38
  SPEAKER_00: Use small FC network agent may tune layer widths, learning rate, batch size.
• 16:43
  SPEAKER_00: 2.3 Drug compound screening in silico candidate discovery.
• 16:47
  SPEAKER_00: Task predict candidate neuroprotective regenerative compounds.
• 16:50
  SPEAKER_00: Use ML to find small molecules that might protect RGCs or encourage regeneration.
• 16:55
  SPEAKER_00: For example, many known compounds like nicotinamide, valproate show neuroprotective effects.
• 17:01
  SPEAKER_00: We can train models to recognize chemotypes correlated with known efficacy and then search chemical space.
• 17:07
  SPEAKER_00: Data set.
• 17:08
  SPEAKER_00: This is challenging due to lack of a dedicated glaucoma drug database.
• 17:12
  SPEAKER_00: As a proxy one could use MOLNET datasets, e.g.
• 17:15
  SPEAKER_00: HIV inhibition, BBB permeability, or any bioactivity dataset.
• 17:20
  SPEAKER_00: Alternatively, compile a list of compounds tested in optic nerve injury models from literature mining with labels.
• 17:26
  SPEAKER_00: In practice, one might start with a more generic property e.g.
• 17:29
  SPEAKER_00: blood brain barrier penetration data from molecule net.
• 17:32
  SPEAKER_00: Model a small transformer or graph neural network on SMILE strings.
• 17:36
  SPEAKER_00: A transformer like GPT2 style with few layers or a simple graph convolutional net, e.g.
• 17:42
  SPEAKER_00: 3 GCN layers, can be implemented in the train.py metric.
• 17:46
  SPEAKER_00: If we treat as classification, active vs inactive, use OROC.
• 17:49
  SPEAKER_00: If predicting affinity or log P, use RMSE.
• 17:53
  SPEAKER_00: Example Program dot MD.
• 17:55
  SPEAKER_00: Goal Maximize classification ROC A for identifying neuroprotective like compounds.
• 18:00
  SPEAKER_00: Base model small transformer on SMILES.
• 18:03
  SPEAKER_00: Agent may adjust number of transformer layers, dropout, learning rate, or use alternative featurizations, e.g., fingerprint input.
• 18:11
  SPEAKER_00: After each five min evaluate AUC on VAL molecules.
• 18:14
  SPEAKER_00: Note, because public data for actual neuroprotection is scarce, this task is more illustrative.
• 18:20
  SPEAKER_00: In practice, citizen scientists could create a custom dataset of known neuroprotective compounds versus controls and follow this pattern.
• 18:28
  SPEAKER_00: 2.4 Gene Regulatory Network Modeling, single cell RGC task, identify regenerative TF combinations.
• 18:35
  SPEAKER_00: Use single cell RNA-seq data from RGCs to learn transcriptional patterns of regenerative growth.
• 18:41
  SPEAKER_00: For example, some RGC subtypes regenerate better than others.
• 18:45
  SPEAKER_00: An ML model might predict a regenerative state label and one could inspect which transcription factors are important.
• 18:52
  SPEAKER_00: Data set.
• 18:53
  SPEAKER_00: A 2018 study provides RGC single cell transcriptomes, Geoaccession GSE 15404, identifying distinct RGC subtypes.
• 19:02
  SPEAKER_00: We can use this dataset or a subset where cells are labeled by subtype or by experimental condition, e.g.
• 19:08
  SPEAKER_00: pre-versus post-injury.
• 19:10
  SPEAKER_00: Model, a small transformer or MLP operating on gene expression vectors, each cell has thousands of gene abundances.
• 19:17
  SPEAKER_00: Practically, one would pre-select top 500 genes, e.g.
• 19:21
  SPEAKER_00: highly variable genes.
• 19:23
  SPEAKER_00: The train.py might implement a mini transformer, e.g.
• 19:26
  SPEAKER_00: four layers embedding 256, or simple two-layer perceptron.
• 19:30
  SPEAKER_00: Metric, if using unsupervised analysis, one could use silhouette score, but more simply, if labeling cells as regenerating versus non, if labels exist, use classification accuracy AUC.
• 19:40
  SPEAKER_00: Example program dot MD.
• 19:42
  SPEAKER_00: Goal Build a model distinguishing regenerating versus non-regenerating RGC gene expression profiles.
• 19:48
  SPEAKER_00: Start with a three-layer transformer.
• 19:50
  SPEAKER_00: Agent can change embed DIM, depth, learning rate, or add batch norm.
• 19:55
  SPEAKER_00: Optimize validation accuracy.
• 19:57
  SPEAKER_00: After runs, the best model's attention weights or learned features might highlight key transcription factors for experimentation.
• 20:04
  SPEAKER_00: 2.5 Electrophysiology signal analysis task detect subclinical RGC dysfunction via ERG.
• 20:11
  SPEAKER_00: Pattern electroretinogram, PERG, or other electrophysiological signals can reveal RGC health.
• 20:17
  SPEAKER_00: For example, delayed or reduced ERG responses may precede visual field defects.
• 20:22
  SPEAKER_00: We can attempt to classify signals as normal versus glaucoma suspect.
• 20:26
  SPEAKER_00: Data set ERG datasets in glaucoma are rare.
• 20:30
  SPEAKER_00: One could use a surrogate, a dataset from animals, retinal degeneration, or synthetic signals.
• 20:35
  SPEAKER_00: If unavailable, even generic 1D electrophysiology datasets, e.g.
• 20:39
  SPEAKER_00: ECG, could illustrate the pipeline.
• 20:41
  SPEAKER_00: Model, a 1D CNN, e.g.
• 20:44
  SPEAKER_00: two conveyers followed by FC on the time series data.
• 20:47
  SPEAKER_00: Alternatively, an LSTM can be used if sequences are longer.
• 20:50
  SPEAKER_00: Metric, accuracy or AUC in classifying a subtle dysfunction versus normal.
• 20:55
  SPEAKER_00: Possibly F1 if classes are imbalanced.
• 20:57
  SPEAKER_00: Example program.nem Goal Maximize validation accuracy for classifying ERG traces, healthy versus early glaucoma pattern.
• 21:04
  SPEAKER_00: Use a 1D CNN agent may adjust filter sizes, stride, or add recurrent layer.
• 21:10
  SPEAKER_00: Keep any changes that improve accuracy.
• 21:13
  SPEAKER_00: 2.6 Literature Mining, Hypothesis Generation.
• 21:16
  SPEAKER_00: Task Fine-tune a small language model to surface novel insights.
• 21:20
  SPEAKER_00: With thousands of glaucoma research papers in PubMed, an ML agent could look for connections or repurpose candidates.
• 21:27
  SPEAKER_00: For instance, link neuroprotective pathways to existing drugs.
• 21:30
  SPEAKER_00: We can treat this as a language modeling problem or as a retrieval problem.
• 21:34
  SPEAKER_00: Data set, compile a corpus of glaucoma-related abstracts, e.g.
• 21:39
  SPEAKER_00: use PubMed search for glaucoma gene therapy, etc.
• 21:42
  SPEAKER_00: One can download 10,000 abstracts via NCBI APIs.
• 21:46
  SPEAKER_00: For a simpler start, use PMC open access glaucoma articles.
• 21:50
  SPEAKER_00: Model a small transformer language model, e.g.
• 21:53
  SPEAKER_00: six layer GPT2 or even BERT fine tuned.
• 21:55
  SPEAKER_00: For autoresearch purposes, we likely fine tune a causal model GPT.
• 22:00
  SPEAKER_00: On the text.
• 22:01
  SPEAKER_00: Metrics.
• 22:01
  SPEAKER_00: Standardly, validation loss perplexity is optimized.
• 22:04
  SPEAKER_00: If doing a classification, e.g., give an abstract, predict a label for a drug or pathway, use accuracy AUC.
• 22:11
  SPEAKER_00: Example Program.md Goal Minimize validation perplexity of a small GPT2 on the glaucoma literature corpus.
• 22:18
  SPEAKER_00: Use five-minute fine-tuning runs.
• 22:20
  SPEAKER_00: Agent can vary number of layers, hidden size, learning rate, context length.
• 22:24
  SPEAKER_00: Keep changes that reduce perplexity.
• 22:26
  SPEAKER_00: Once trained, one can prompt this model to generate hypotheses, e.g., top candidate repurposable drugs for neuroprotection in glaucoma.
• 22:35
  SPEAKER_00: In each of these domains, the key is that a single GPU and brief runs allow many trials.
• 22:41
  SPEAKER_00: We are not expecting the agent to code new algorithms from scratch, but to tweak an existing training script.
• 22:47
  SPEAKER_00: The human role is writing program.md to guide the agent's search towards a glaucoma-specific goal, like maximizing AUC on a fundus dataset or predicting RNFL thickness.
• 22:58
  SPEAKER_00: The examples above illustrate how Train.py could be set up initially and how Program.md prompts to improve a chosen metric.
• 23:06
  SPEAKER_00: Practical Citizen Science Implementation Guide.
• 23:09
  SPEAKER_00: How can motivated individuals with limited resources, e.g., a single RTX 3060 or a MacBook with Apple Silicon, actually apply auto research to glaucoma problems?
• 23:20
  SPEAKER_00: The good news is Carpathy's repo is small and has guidance for scaling down.
• 23:24
  SPEAKER_00: Here are key steps and tips.
• 23:26
  SPEAKER_00: Environment setup.
• 23:27
  SPEAKER_00: Clone the Carpathi Autoresearch Repo.
• 23:29
  SPEAKER_00: You'll need a modern Python and ideally an LLM access.
• 23:32
  SPEAKER_00: The agent itself is typically a pre-trained LLM like GPT-4 or Claude that edits the code.
• 23:38
  SPEAKER_00: For GPUs, install PyTorch with proper CUDA metal support.
• 23:42
  SPEAKER_00: For Apple Silicon, use one of the forks, e.g.
• 23:45
  SPEAKER_00: MLX, or a PyTorch build for M1M2, see the repos docs.
• 23:50
  SPEAKER_00: On Windows Linux with a 3060 or 4070, normal PyTorch CUDA works.
• 23:55
  SPEAKER_00: Configuring for small GPU, the default autoresearch uses a 50 map parameter GPT-like model and sequences of length 1024, which may be heavy.
• 24:04
  SPEAKER_00: For a GTX 3060, 12GB, you should reduce model size and sequence length.
• 24:09
  SPEAKER_00: In train.py, set max sequel any U5012 or even 256.
• 24:14
  SPEAKER_00: Drop the number of layers and width.
• 24:16
  SPEAKER_00: The medium GPT is 8 layers.
• 24:19
  SPEAKER_00: Try four layers, 256 width.
• 24:22
  SPEAKER_00: The instructions in the community mention lowering depth, width, etc.
• 24:26
  SPEAKER_00: You can also reduce the optimizer's memory by using smaller batch sizes, even 16 or 8.
• 24:32
  SPEAKER_00: The agent can still mutate these parameters, but giving it a smaller starting point ensures runs 5 minutes.
• 24:38
  SPEAKER_00: The auto research GitHub README and issue discussions also note that Mac M1 chips can handle shorter sequences, e.g., 256 tokens, due to limited memory.
• 24:49
  SPEAKER_00: Similar scaling applies to any GPU.
• 24:51
  SPEAKER_00: Preparing glaucoma data.
• 24:53
  SPEAKER_00: Each task's data must be loaded and split.
• 24:56
  SPEAKER_00: Public glaucoma datasets include fundus datasets, Origa Lite, 650 labeled images, RIM1DL, 485 images with CUP DISC segmentations, Refuge, 1200 plus images with training test splits, the new Hillel Yaf glaucoma dataset, HYD, with twice 1200 fundus images and high-quality labels.
• 25:15
  SPEAKER_00: IPAC's AROGS, tens of thousands of retinal images, is also publicly accessible via registration, e.g.
• 25:21
  SPEAKER_00: Kaggle.
• 25:22
  SPEAKER_00: OCT datasets, SYNOC, 200K synthetic B scans with RNFL masks, OCTDL 2064 images of various retinal diseases, and others from public challenges.
• 25:33
  SPEAKER_00: Visual field data, grape, 263 eyes longitudinal VF plus images.
• 25:37
  SPEAKER_00: UWHVF 28K VF tests is open if you download from University of Washington repository.
• 25:44
  SPEAKER_00: Some Kaggle challenges include VF data.
• 25:47
  SPEAKER_00: Electrophysiology, no large open glaucoma ERG dataset is known, but one could start with any accessible norm versus glaucoma signal data.
• 25:54
  SPEAKER_00: Chemical gene data.
• 25:56
  SPEAKER_00: Standard datasets like moleculeNet for compounds or Geo for genes can be repurposed, e.g., download GSE15404 raw counts via GeoQuery and preprocess to expression matrices.
• 26:08
  SPEAKER_00: For each, you need a prepare.py that loads data and defines trainset, valset, and an evaluation function.
• 26:15
  SPEAKER_00: Carpathy's template expects prepare.py to output training data and an evaluation routine that returns a loss or metric.
• 26:22
  SPEAKER_00: For example, prepare.py for RIM 1 might load images and CC labeled as glaucoma split into train val folders and define a function computing validation ache.
• 26:32
  SPEAKER_00: Refer to FOIN2L79 for how RIM1 is structured.
• 26:37
  SPEAKER_00: Adjusting data for small scale, if datasets are large like iPacks or CINO, you can subsample to create a tiny dataset of a few hundred examples.
• 26:46
  SPEAKER_00: The model can still learn something valuable on a small corpus.
• 26:50
  SPEAKER_00: The autoresearch repo even mentions using tiny stories, style tiny datasets to run on tiny hardware.
• 26:57
  SPEAKER_00: For example, pick 500 images from Origa, Balanced, or 1,000 VF fields from Grape.
• 27:03
  SPEAKER_00: Likewise, for language, one could use a 5,000 abstract subset of PubMed glaucoma papers.
• 27:09
  SPEAKER_00: The key is a fixed dataset that the agent iterates over.
• 27:12
  SPEAKER_00: Ensure to pre-shuffle and split 80-20 so each 5-min run sees the same train train valve split.
• 27:19
  SPEAKER_00: Writing program.md strategies.
• 27:21
  SPEAKER_00: The community should share different program.md prompts, like recipes, inversion control.
• 27:27
  SPEAKER_00: Each file could encode a research strategy.
• 27:30
  SPEAKER_00: For instance, one strategy might say increase network depth if depth 6, else reduce learning rate, while another might say focus on data augmentation changes.
• 27:39
  SPEAKER_00: Over time, groups can compare which strategies yielded better metrics on leaderboards.
• 27:43
  SPEAKER_00: A good program.md includes a goal, e.g., maximize AUC or minimize validation loss, and hints at allowable mutations, layers, filters, LR.
• 27:53
  SPEAKER_00: The agent's LLM uses these instructions to propose code edits.
• 27:57
  SPEAKER_00: Keep metrics standardized, e.g., always report AUC for glaucoma classification tasks, so experiments are comparable.
• 28:04
  SPEAKER_00: Community collaboration.
• 28:06
  SPEAKER_00: To make this effort scalable, a citizen science community should organize shared experiment logs.
• 28:11
  SPEAKER_00: Post each experiment's results, e.g., run 27 of program V1 achieved val AU equals 0.82 with width equals 4, depth equals 3.
• 28:19
  SPEAKER_00: Standardized metrics.
• 28:20
  SPEAKER_00: Define metrics for each task, e.g.
• 28:22
  SPEAKER_00: OCT glaucoma AUC, VF progression AUC, Attribute AUC, etc.
• 28:27
  SPEAKER_00: A shared leaderboard, akin to Auto Research's Val BPB, can track top scores.
• 28:31
  SPEAKER_00: For example, a Slack or GitHub Actions might collect each agent's best AUC weekly.
• 28:37
  SPEAKER_00: Version controlled program.md, host all program.md in a GitHub repo.
• 28:41
  SPEAKER_00: Members can fork and propose new strategies via pull requests while keeping historical versions.
• 28:47
  SPEAKER_00: This way multiple approaches can be tested in parallel, e.g.
• 28:50
  SPEAKER_00: programmer2vec.md is programtransformer.md.
• 28:54
  SPEAKER_00: Data and code sharing.
• 28:56
  SPEAKER_00: Use public repos or notebooks for data prep scripts and share train.
• 29:00
  SPEAKER_00: PI modifications found by the agent to reproduce in standard ML frameworks.
• 29:05
  SPEAKER_00: Linking to the original dataset sources Kaggle, PhysioNet, Zenodo ensures others can download the same data.
• 29:12
  SPEAKER_00: By lowering technical barriers, the agent edits code, user edits instructions in Markdown, and by coordinating efforts, shared logs, leaderboards, citizen scientists can collectively explore hyperparameter model choices for these glaucoma ML problems.
• 29:27
  SPEAKER_00: In essence, they invest human creativity in defining goals and let the agent run the grind of 100 experiments overnight per goal.
• 29:36
  SPEAKER_00: Vision restoration, specifically vision restoration, regaining sight after damage, is a particularly exciting target for AI-driven optimization.
• 29:45
  SPEAKER_00: Current AI-assisted vision restoration research includes retinal implants, cortical prosthesis and optogenetics.
• 29:52
  SPEAKER_00: Here's how an auto-research loop could fit in.
• 29:55
  SPEAKER_00: Optimizing visual prosthesis encoding, modern prosthesis, retinal implants or cameras linked to electrode arrays, try to translate a camera image into electrical stimulation patterns that the brain interprets as sight.
• 30:08
  SPEAKER_00: The challenge is that the bandwidth of electrodes is very limited, often just tends to a few hundred points.
• 30:15
  SPEAKER_00: An ML model, a small CNN or transformer, can be trained to map input images to ideal stimulation maps, but the best hyperparameters or architectures for this translation are unknown.
• 30:27
  SPEAKER_00: An auto research agent could run 100 variations of a neural encoder model in hours.
• 30:34
  SPEAKER_00: For example, set up a dataset of image stimulation pairs, either simulated phosphenes or patient data, and have the agent optimize the encoder network to minimize a reconstruction loss or maximize a utility metric, contrast intactness, recognition accuracy.
• 30:50
  SPEAKER_00: The agent might try adding attention layers, changing convolution sizes, or tuning learning rates.
• 30:56
  SPEAKER_00: Over many runs, one could find small networks that deliver more salient prosthetic outputs.
• 31:01
  SPEAKER_00: Some recent work already uses AI to extract visual saliency for prosthesis.
• 31:06
  SPEAKER_00: Autoresearch could automate the tuning of such pipelines.
• 31:10
  SPEAKER_00: Optogenetic stimulation patterns in optogenetic therapy, survivors of RGCs or other retinal cells are made light sensitive via introduced genes.
• 31:19
  SPEAKER_00: The inputs from a camera must then be encoded into light pulses.
• 31:22
  SPEAKER_00: Here again an ML model can control patterns.
• 31:26
  SPEAKER_00: One could frame a toy task small network transforms camera image to a light intensity map, same dimensions as cells.
• 31:33
  SPEAKER_00: The agent's objective could be to maximize some metric of effective stimulation, e.g.
• 31:39
  SPEAKER_00: maximize activation of target cells in a simulated retina.
• 31:42
  SPEAKER_00: Each trial might run a quick simulation of the response.
• 31:46
  SPEAKER_00: Over iterations the agent might explore pulse durations or spatial filters.
• 31:51
  SPEAKER_00: For instance, adjusting the aggressiveness of a highpass filter on the camera input might be beneficial for some patterns.
• 31:58
  SPEAKER_00: The point is that many analog parameters filter kernels, nonlinearity can be swept automatically.
• 32:05
  SPEAKER_00: Pulse pattern optimization, TES and implants, even non-machine learning domains can benefit from quick search.
• 32:12
  SPEAKER_00: For example, a recent study, SHIE et al.
• 32:17
  SPEAKER_00: found that shorter pulse durations and insertion of interphase intervals significantly improved cortical activation for retinal implants.
• 32:25
  SPEAKER_00: This suggests the parameter space of electrical stimulation has strong, non-intuitive effects.
• 32:31
  SPEAKER_00: An auto research agent could treat the stimulation protocol parameters, phase duration, frequency, interval as network parameters and run many small experiments, each simulated or empirical, to maximize cortical response.
• 32:45
  SPEAKER_00: For instance, set up a simplified electrical model or use recorded evoke potential data in prepare.py and let the agent tweak train.py parameters like pulse timing to maximize a defined response amplitude.
• 32:59
  SPEAKER_00: This is akin to automating what aficionado neuroscientists do manually viral vector design and scaffold geometry.
• 33:06
  SPEAKER_00: In more exploratory therapy development, the agent's looping approach could also tackle biomedical optimizations.
• 33:13
  SPEAKER_00: For example, design of AAV viral capsids or promoters to target RGCs could be guided by small predictive models, e.g.
• 33:21
  SPEAKER_00: logistic regression on sequence features.
• 33:24
  SPEAKER_00: Autoresearch could repeatedly try modifying a model that predicts tropism or expression, trained on E.G.
• 33:29
  SPEAKER_00: small viral libraries to improve that prediction.
• 33:33
  SPEAKER_00: Similarly, if someone has simulation code for growth in nerve scaffolds, for optic nerve repair, the agent could tweak geometric parameters to maximize axon extension.
• 33:43
  SPEAKER_00: These are advanced but conceptually fit, the agent as experimenter could adjust model or simulation parameters for improved outcomes.
• 33:52
  SPEAKER_00: In summary, any aspect of vision prosthesis or restoration that relies on parameterized algorithms could be improved via rapid iterations.
• 34:00
  SPEAKER_00: Importantly, the limitation is we generally only have simulational data for many of these tasks.
• 34:06
  SPEAKER_00: Actual patient testing of hundreds of variants isn't possible, but autoresearch can operate in silico to propose the best candidates for later clinical testing.
• 34:16
  SPEAKER_00: As the prosthesis review noted, ensuring phosphenes are reliably generated at precise locations is an important challenge, and AI-driven models have shown potential in this area.
• 34:28
  SPEAKER_00: Autoresearch could significantly accelerate finding those AI models best configurations.
• 34:33
  SPEAKER_00: Bridging to clinical impact computational results must ultimately connect back to real glaucoma research and care.
• 34:40
  SPEAKER_00: How can ideas generated by patient-led autoresearch be validated and advanced?
• 34:46
  SPEAKER_00: Collaboration with research groups citizen scientists should reach out to established glaucoma research consortia.
• 34:53
  SPEAKER_00: Examples include the International Glaucoma Genetics Consortium and the Neighborhood Consortium which pool genetic and clinical data.
• 35:02
  SPEAKER_00: Findings from auto research e.g.
• 35:04
  SPEAKER_00: a novel candidate gene or drug repurposing hypothesis could be shared with such groups for experimental follow-up.
• 35:11
  SPEAKER_00: Tissue culture labs, e.g.
• 35:13
  SPEAKER_00: at major universities or sleep researchers might test compounds on RGC survival.
• 35:18
  SPEAKER_00: Academic clinicians can correlate any biomarker or image classifier with their patient data under IRB.
• 35:25
  SPEAKER_00: Starting dialogues between hackathon-style groups and formal labs is key.
• 35:30
  SPEAKER_00: Engaging patient advocacy organizations groups like the Glaucoma Research Foundation or Cure Glaucoma Foundation often fund patient-centered innovation.
• 35:39
  SPEAKER_00: They could sponsor proof of concept projects or citizen competitions using auto research.
• 35:45
  SPEAKER_00: These organizations have clinician networks and could help route promising model leads to the clinic.
• 35:50
  SPEAKER_00: For example, if an agent flags an existing FDA approved drug as neuroprotective, an advocacy group could assist in setting up a small trial under proper protocols.
• 36:01
  SPEAKER_00: Highlighting successes will require framing outputs as hypotheses, not medical advice and ensuring transparency.
• 36:08
  SPEAKER_00: Ethical and safety guardrails citizen scientists must use only de-identified public data or fully synthetic data.
• 36:15
  SPEAKER_00: Any use of actual patient records requires an IRB approved protocol and likely patient consent.
• 36:21
  SPEAKER_00: Output from autoresearch loops should be clearly labeled as hypothesis generating.
• 36:26
  SPEAKER_00: For instance, this model suggests drug X may protect RGCs, experimental validation needed.
• 36:33
  SPEAKER_00: Critical medical decisions must remain with doctors.
• 36:36
  SPEAKER_00: Risks include inadvertently distributing models that predict personal outcomes, glaucoma progression.
• 36:42
  SPEAKER_00: Explicit disclaimers are necessary not to treat these as diagnostic tools.
• 36:47
  SPEAKER_00: Data privacy best practices, e.g.
• 36:49
  SPEAKER_00: using aggregated or anonymized fields, are a must.
• 36:53
  SPEAKER_00: Precedence in citizen science it is not unprecedented for amateurs to contribute to medical neuroscience research.
• 36:59
  SPEAKER_00: The iWire project MIT's crowdsourced neuron mapping game mobilized volunteers to reconstruct retinal neural circuits.
• 37:07
  SPEAKER_00: In ophthalmology, non-experts have helped annotate images in open AI funded challenges, e.g.
• 37:13
  SPEAKER_00: labeled datasets for eye disease.
• 37:15
  SPEAKER_00: Outside eye care, games like Fold It, Protein Folding Puzzles, and Galaxy Zoo, classifying galaxies show that citizen participation can solve hard scientific problems.
• 37:26
  SPEAKER_00: These successes encourage the idea that many hands, and now AIs, can indeed aid complex research.
• 37:32
  SPEAKER_00: The auto research approach is like giving each person an AI-powered lab assistant.
• 37:37
  SPEAKER_00: Previous crowdsourced efforts only used humans to analyze fixed tasks, whereas here the human sets the goal and the AI does the iteration.
• 37:46
  SPEAKER_00: By being transparent, cautious and collaborative, a citizen science auto research initiative can earn trust.
• 37:52
  SPEAKER_00: It should emphasize generating leads, not prescriptions.
• 37:56
  SPEAKER_00: If the community documents methods and shares code openly, professional researchers can reproduce findings.
• 38:02
  SPEAKER_00: For example, if someone finds a new combination of RGC protective factors, they could publish it in a preprint or alert a lab.
• 38:10
  SPEAKER_00: Citation style references as we do here help bridge, e.g., we treated your list of candidate drugs in context of known pathways.
• 38:19
  SPEAKER_00: Ultimately this is a form of open science, patient-driven but scientifically rigorous.
• 38:24
  SPEAKER_00: If ethical standards are maintained, such grassroots innovation has great potential to spark new collaborations and ultimately feed into peer-reviewed ophthalmology research.
• 38:34
  SPEAKER_00: A concrete 90-day roadmap a focused, time-boxed plan can rally a community of 10 to 50 people with at least one GPU or Apple Silicon each to launch an auto research for glaucoma effort.
• 38:47
  SPEAKER_00: Here is a suggested phased plan.
• 38:49
  SPEAKER_00: Week 1-2, formation and setup recruitment and kickoff.
• 38:53
  SPEAKER_00: Create a communication channel, e.g.
• 38:56
  SPEAKER_00: Slack or Discord, and a GitHub repo for the project.
• 38:59
  SPEAKER_00: Publicize to glaucoma patient forums, biohacker groups and AI meetups.
• 39:04
  SPEAKER_00: Hardware check.
• 39:05
  SPEAKER_00: Ensure everyone can install PyTorch and clone Carpathi's repo, or the Maple Fork.
• 39:10
  SPEAKER_00: Hold a setup session where each member runs a sample auto research loop on a toy dataset, e.g.
• 39:15
  SPEAKER_00: CFAR10 subset, to verify the environment.
• 39:17
  SPEAKER_00: Dataset selection.
• 39:18
  SPEAKER_00: Decide on one to three initial tasks, e.g.
• 39:21
  SPEAKER_00: OCT classification, VF progression.
• 39:24
  SPEAKER_00: For each, assign a small team to prepare data, e.g.
• 39:28
  SPEAKER_00: one team downloads RIM1 images, another retrieves grapefields, another collects literature abstracts.
• 39:33
  SPEAKER_00: Teams should split data 8020 and create prepare dot pie stubs.
• 39:37
  SPEAKER_00: Baseline models.
• 39:39
  SPEAKER_00: For each task finalize a simple train pie, e.g.
• 39:41
  SPEAKER_00: a tiny CNN for RIM1 and MLP for VFs.
• 39:44
  SPEAKER_00: Choose evaluation metrics, AUS DICE, MSE.
• 39:48
  SPEAKER_00: Initial program.md.
• 39:50
  SPEAKER_00: Drafting.
• 39:50
  SPEAKER_00: Each team writes an initial instruction file stating the goal and allowed changes.
• 39:55
  SPEAKER_00: E.g.
• 39:55
  SPEAKER_00: for RIM 1, maximize glaucoma detection AUC.
• 39:58
  SPEAKER_00: For grape, minimize VFM.
• 40:00
  SPEAKER_00: Week 3-6, first experiment cycles run auto research loops.
• 40:04
  SPEAKER_00: Each subgroup runs the agent on their task overnight, roughly 105 min runs.
• 40:09
  SPEAKER_00: Use a single program.md to start, then let participants add variations, e.g.
• 40:14
  SPEAKER_00: program temp1.md collect results.
• 40:17
  SPEAKER_00: Each morning, teams examine the logs the repo auto logs each run.
• 40:21
  SPEAKER_00: Record the best metric achieved, the model parameters at that time, and any notable changes the agent found.
• 40:27
  SPEAKER_00: For transparency, push these results to the shared GitHub, perhaps in CSV or JSON.
• 40:32
  SPEAKER_00: Iteration and feedback.
• 40:34
  SPEAKER_00: Compare runs.
• 40:35
  SPEAKER_00: Did any strategy beat the baseline significantly?
• 40:38
  SPEAKER_00: If a sub-team sees little progress, they should tweak program.md, e.g.
• 40:42
  SPEAKER_00: being more aggressive with learning rate changes.
• 40:45
  SPEAKER_00: Each weekend, synthesize findings in a community meeting.
• 40:48
  SPEAKER_00: Tools.
• 40:49
  SPEAKER_00: Use Git for version control on program.md and on the code templates.
• 40:53
  SPEAKER_00: Consider a shared Google Sheet or Wiki table for leaderboards, e.g.
• 40:57
  SPEAKER_00: OCTA Bestie.85 by Alice, VFRMSE Bestie 2.1 by Bob.
• 41:03
  SPEAKER_00: This motivates healthy competition and transparency.
• 41:05
  SPEAKER_00: Week 712, refinement and outreach.
• 41:08
  SPEAKER_00: Refine experiments.
• 41:10
  SPEAKER_00: Based on early results refine promising tasks.
• 41:12
  SPEAKER_00: For example, perhaps the RIM1 classifier topped zero.
• 41:15
  SPEAKER_00: 9DAUC, now try adding data augmentation or a slightly deeper net.
• 41:20
  SPEAKER_00: Encourage branching.
• 41:21
  SPEAKER_00: Some can try different architectures, e.g.
• 41:23
  SPEAKER_00: vision transformer tiny instead of CNN.
• 41:26
  SPEAKER_00: Agents can run multiple programMD variants in parallel.
• 41:30
  SPEAKER_00: Result synthesis, create short reports on each domain, OCT, VF, etc, summarizing what worked.
• 41:36
  SPEAKER_00: For instance, we improve GCC segmentation dice from.60 to 0.75 by switching from Relue to GLU activation.
• 41:44
  SPEAKER_00: Use lay language so non-experts can follow, glossary for ML terms.
• 41:48
  SPEAKER_00: Community presentation.
• 41:50
  SPEAKER_00: By week 10, write a blog post or slide deck summarizing the initiative so far.
• 41:55
  SPEAKER_00: Highlight any non-trivial findings, even null results are useful to share.
• 42:00
  SPEAKER_00: Invite feedback from online forums.
• 42:02
  SPEAKER_00: Perhaps contact a researcher asking for comments.
• 42:04
  SPEAKER_00: We found X Neural Network tweaks help classify early glaucoma.
• 42:08
  SPEAKER_00: Any ideas if this aligns with physiology?
• 42:11
  SPEAKER_00: Plan outreach.
• 42:12
  SPEAKER_00: Identify one or two opt ophthalmology labs or clinicians interested in collaborating.
• 42:18
  SPEAKER_00: Reach out with the initial results.
• 42:20
  SPEAKER_00: For example, connect with authors of the HIGD dataset or the Grape team on Twitter, LinkedIn, mention your citizen findings.
• 42:28
  SPEAKER_00: Explore possibilities for co-validation, e.g.
• 42:30
  SPEAKER_00: send them the trained model weights to test on their data.
• 42:34
  SPEAKER_00: Beyond 12 weeks, next steps.
• 42:36
  SPEAKER_00: Continue looping on the most promising tasks and new ones.
• 42:40
  SPEAKER_00: For example, if RIM 1 yields good results, next tackle refuge.
• 42:44
  SPEAKER_00: Perhaps build composite models ensemble of CNNs.
• 42:48
  SPEAKER_00: Officialize a project page or preprint describing the effort.
• 42:52
  SPEAKER_00: Consider organizing a hackathon to bring in more minds, possibly in partnership with a glaucoma charity.
• 42:58
  SPEAKER_00: By structuring this way, the community can make steady progress, learn together, and start bridging to experts by the end of 90 days.
• 43:06
  SPEAKER_00: Risks, limitations and honest assessment.
• 43:09
  SPEAKER_00: The autoresearch for glaucoma idea is ambitious, so it requires honesty about potential pitfalls, risk of overfitting and spurious patterns.
• 43:18
  SPEAKER_00: Small models on small, noisy datasets often latch onto coincidences.
• 43:22
  SPEAKER_00: An agent might find a tweak that improves validation AUC simply by overfitting to idiosyncrasies.
• 43:28
  SPEAKER_00: For example, if a subset of images had a subtle annotation mark, the network might use that instead of true glaucoma features.
• 43:35
  SPEAKER_00: This leads to gradient descent foolery.
• 43:38
  SPEAKER_00: To mitigate, always use held out test sets completely separate from any tuning for final evaluation.
• 43:44
  SPEAKER_00: Limit complexity, keep models modest, and watch if the agent excessively deepens or widens the net beyond reason.
• 43:51
  SPEAKER_00: If a model achieves near perfect score too quickly, question it.
• 43:55
  SPEAKER_00: Use sanity checks, e.g.
• 43:56
  SPEAKER_00: scramble labels and see if AUC drops to random, if If not, there is leakage.
• 44:01
  SPEAKER_00: Bias in data quality.
• 44:03
  SPEAKER_00: Public glaucoma datasets often come from narrow populations, e.g., orga from Singapore.
• 44:09
  SPEAKER_00: A model tuned to those may not generalize.
• 44:12
  SPEAKER_00: Citizen experiments should note this limitation.
• 44:14
  SPEAKER_00: Ideally, multiple datasets from different cohorts are used to check if findings are robust.
• 44:20
  SPEAKER_00: False leads, research theater.
• 44:23
  SPEAKER_00: Running tons of experiments feels productive, but if every improvement is only on synthetic or trivial datasets, it might not benefit patients.
• 44:31
  SPEAKER_00: To avoid this, focus on tasks with clinical relevance, e.g., early detection from routine OCT.
• 44:37
  SPEAKER_00: Tie outcomes to real measures when possible, e.g.
• 44:40
  SPEAKER_00: AUC for progression, not just tiny loss delta.
• 44:43
  SPEAKER_00: Prioritize interpretability.
• 44:45
  SPEAKER_00: If the agent finds a new biomarker, try to ensure it makes sense, e.g., is it focusing on known anatomical changes?
• 44:52
  SPEAKER_00: No clinical guarantee.
• 44:53
  SPEAKER_00: It must be crystal clear.
• 44:55
  SPEAKER_00: Output from these loops is hypothesis generation, not medical advice.
• 44:59
  SPEAKER_00: A model suggesting a new drug must be vetted in the lab before any patient use.
• 45:04
  SPEAKER_00: Overclaiming is dangerous.
• 45:06
  SPEAKER_00: Label all shared results with disclaimers.
• 45:09
  SPEAKER_00: This is an AI exploration and not a peer-reviewed finding.
• 45:12
  SPEAKER_00: Small model, limitation.
• 45:14
  SPEAKER_00: Very small networks have limited capacity, they may miss complex patterns.
• 45:19
  SPEAKER_00: In contrast, big models often see breakthroughs but require huge data.
• 45:23
  SPEAKER_00: Here we accept limited scope.
• 45:25
  SPEAKER_00: Hope is that even small improvements can guide research.
• 45:28
  SPEAKER_00: But we should not expect these models to replace deep learning on massive data.
• 45:33
  SPEAKER_00: They're best at quickly trying obvious ideas.
• 45:36
  SPEAKER_00: Agent trustworthiness.
• 45:38
  SPEAKER_00: The agent, e.g.
• 45:39
  SPEAKER_00: GPT-4, might hallucinate or deviate.
• 45:42
  SPEAKER_00: It's important that results are reproducible.
• 45:45
  SPEAKER_00: After an agent run, a human should check what changes were kept and rerun training to confirm the metric.
• 45:50
  SPEAKER_00: Keep the agent honest by include statements in program.md like only accept actual improvements in evaluation metric.
• 45:57
  SPEAKER_00: Despite these challenges, the key safeguard is transparency and critical follow-up.
• 46:02
  SPEAKER_00: Document everything.
• 46:04
  SPEAKER_00: When a model shows a pattern, verify it.
• 46:06
  SPEAKER_00: If many citizen scientists see the same anomaly, e.g., all high AUC models for an OCT task emphasize the nasal retina region, that strengthens the case.
• 46:16
  SPEAKER_00: The goal is accelerating the idea generation phase, not avoiding careful science afterwards.
• 46:22
  SPEAKER_00: Conclusion: glaucoma is a complex, silent, blinding disease with many unmet research needs, from protecting neurons to restoring vision.
• 46:31
  SPEAKER_00: At the same time, AI has democratized experimentation.
• 46:34
  SPEAKER_00: One person with a GPU and some determination can run automated hyperparameter searches that would take teams weeks manually.
• 46:42
  SPEAKER_00: Carpathy's autoresearch framework essentially hands each citizen an AI lab assistant.
• 46:47
  SPEAKER_00: By writing clear, high-level goals in Markdown, community researchers can let an agent churn through products and cut straight to promising leads.
• 46:56
  SPEAKER_00: We have outlined how this can be done in practice, identifying glaucoma ML tasks, selecting data, fundus and OCT images, visual fields, molecular data sets, defining models and metrics, and using program instructions to guide the search.
• 47:11
  SPEAKER_00: We sketched a 90-day community roadmap and noted bridges to clinicians to ensure that valuable output can inform actual glaucoma science.
• 47:20
  SPEAKER_00: The approach is very much citizen science, opening up scientific discovery tools in an accessible way while still relying on expert oversight where it matters.
• 47:30
  SPEAKER_00: Citations.
• 47:32
  SPEAKER_00: We have referenced the latest resources in both glaucoma research and AI, key facts, disease prevalence half-undiagnosed, promising therapies, CNTF implants, gene editing, and shady pitfalls, AI and imaging, are grounded in current literature.
• 47:48
  SPEAKER_00: Autoresearch itself is described in Carpathi's walkthrough and review.
• 47:53
  SPEAKER_00: These should lend credibility to the vision outlined here.
• 47:56
  SPEAKER_00: By the end of it all, we hope the reader feels empowered.
• 47:59
  SPEAKER_00: If you're a patient, caregiver, or passionate hobbyist, you could be part of driving glaucoma research forward.
• 48:06
  SPEAKER_00: The tools and data exist, the problems are clear, and with coordination and an AI agent, we can accelerate learning.
• 48:14
  SPEAKER_00: As with any research, the journey will have false starts, but even failures teach us something, often steering human minds toward the right approaches.
• 48:23
  SPEAKER_00: With eyes wide open to both the possibilities and the pitfalls, citizen-led auto research could become a powerful complement to traditional glaucoma science.
• 48:33
  SPEAKER_00: Start here.
• 48:34
  SPEAKER_00: The easiest way to dip your toes into autoresearch for glaucoma today, run a tiny classification on Origa fundus images.
• 48:40
  SPEAKER_00: Get the data, download the Origa Lite dataset, 650 retinal fundus images labeled normal versus glaucoma.
• 48:47
  SPEAKER_00: Split 80% train, 20% validation.
• 48:50
  SPEAKER_00: Initial model, user adapt the sample script from Carpathy Auto Research for image classification.
• 48:56
  SPEAKER_00: For example, a bit of code to load orga images and train a small CNN 2-3 conv layers to distinguish glaucoma versus healthy.
• 49:04
  SPEAKER_00: Write program.md.
• 49:06
  SPEAKER_00: In text, set the goal to maximize validation AUC for glaucoma detection and instruct the agent it may tweak model depth, learning rate, etc.
• 49:14
  SPEAKER_00: For instance, run the loop.
• 49:16
  SPEAKER_00: Launch auto research.
• 49:18
  SPEAKER_00: Point it to your prepare.py, train.py, and programmed MD.
• 49:21
  SPEAKER_00: Let it run for several hours or overnight on your RTX 3060.
• 49:25
  SPEAKER_00: It will perform 100 experiments automatically.
• 49:28
  SPEAKER_00: Check results.
• 49:29
  SPEAKER_00: Examine the console or log to see the best validation AUC achieved.
• 49:33
  SPEAKER_00: Should begin at 0.8 if all goes well.
• 49:36
  SPEAKER_00: You now have a model and training script that the AI agent refined.
• 49:40
  SPEAKER_00: This simple weekend experiment already gives you firsthand experience with building an ML pipeline without writing new code by hand.
• 49:47
  SPEAKER_00: Document what you tried and share your program.md and results with the community.
• 49:53
  SPEAKER_00: Each small success, AUC bumps, interesting network changes, is a building block.
• 49:58
  SPEAKER_00: You're literally instructing an AI to do research on your glaucoma problem of choice.
• 50:03
  SPEAKER_00: And in doing so, you learn both glaucoma data science and have hope to make a difference in understanding or treating vision loss.
• 50:12
  SPEAKER_00: Good luck.
• 50:13
  SPEAKER_00: Keep questions and findings open source, and remember, this is research toy tools, not medical advice.
• 50:19
  SPEAKER_00: Check your runs carefully and enjoy the process of discovery.
• 50:22
  SPEAKER_00: All links to sources are available in the text version of this article.
• 50:26
  SPEAKER_00: You can find the full article at visualfieldtest.com.
• 50:30
  SPEAKER_00: Thanks for listening.
• 50:31
  SPEAKER_00: To check your visual field, click the link at the bottom of this article or visit visualfieldtest.com.