# 🧠 drosophila-brain-docker
### High-Performance Containerized *Drosophila* Whole-Brain Spiking Simulation
**Reproducible, zero-setup, multi-Python packaging of the FlyWire connectome LIF model**
`English` · [`Русский`](#-русская-версия)
---
## 📖 What this is
This repository packages the **[Drosophila brain model](https://github.com/philshiu/Drosophila_brain_model)**
by Philip Shiu et al. — a leaky integrate-and-fire spiking simulation built on the
complete adult fruit-fly connectome — into **self-contained Docker images**.
Instead of fighting GCC/Cython/NumPy toolchain breakage on your host, you get a
one-command, bit-reproducible environment that runs the **entire 127k-neuron brain
model on CPU**, out of the box.
```bash
docker run --rm fly-model:3.10 scripts/verify_fly_pipeline.py # ~25 s, prints PASS
```
---
## 💡 Why this exists (the value)
### 🐛 It fixes a real crash that breaks the original code on modern Python
The published model pins `brian2` with a loose lower bound. On any modern stack
that resolves to **brian2 2.9.0**, which dies at import time:
```
File "brian2/units/fundamentalunits.py", line 1661, in Quantity
ptp = wrap_function_keep_dimensions(np.ndarray.ptp)
AttributeError: type object 'numpy.ndarray' has no attribute 'ptp'
```
`np.ndarray.ptp` was **removed in NumPy 2.0**. The constraints `brian2>=2.9.0` and
`numpy>=2.0.0` are therefore **mutually exclusive** — a trap that silently breaks
every 3.12+ environment.
✅ **Fixed here** by pinning `brian2>=2.10.0` (and `>=2.10.1` on 3.14), the first
release that uses `np.ptp(...)` correctly.
### ⚡ 8 s cached execution instead of a slow, fragile rebuild
Compiling brian2's generated C++ dominates every cold run. Because the codegen
cache lives at `/root/.cython`, a **named volume** turns a repeated run into an
almost instant one:
| Run | Simulated time | Wall clock |
|-----|----------------|------------|
| ❄️ Cold (never built before) | 10 ms | **~65 s** |
| 🔥 Warm (cache volume mounted) | 10 ms | **~5 s** |
That is an **~8× reduction**, and it compounds across every experiment you launch.
*(For scale: the upstream project notes the full 30-trial paper experiment takes
roughly 20 minutes on Google Colab and is "substantially faster on a local install".)*
### 📦 Zero setup — no toolchain archaeology
No `apt-get install build-essential`, no `g++` version roulette, no `-march=native`
surprises, no `pkg_resources` vanishment, no conda solver purgatory. Both the
C++ compiler **and** the exact scientific stack are already inside the image.
### 🧪 A verified compatibility matrix, not a guess
Every image below was actually **built, run, and validated** — 3.10 through 3.14.
Where the upstream code needed fixes to work on 3.12+ (the `ptp` crash) or 3.11
(brian2 has no `cp311` wheel, so it must be compiled from source), those fixes are
baked in and documented rather than left as an exercise for you.
---
## 🚀 Quickstart
### 1. Build an image
```bash
git clone https://github.com//drosophila-brain-docker.git
cd drosophila-brain-docker
docker build --build-arg PYTHON_VERSION=3.10 -t fly-model:3.10 .
```
### 2. Verify the pipeline (Cython → C++ → spikes)
```bash
docker run --rm fly-model:3.10 scripts/verify_fly_pipeline.py
```
Expected tail:
```
-> Simulation completed. Generated 3000 spikes across 50ms.
[3/3] PASS: Spiking engine and C++ compiler working properly.
RESULT: PASS
```
### 3. Run the real connectome micro-simulation
Create the outputs directory and the persistent Cython cache volume, then run:
```bash
mkdir -p ./results/docker_310
docker volume create fly-brian2-cache-310
docker run --rm \
-v fly-brian2-cache-310:/root/.cython \
-v "$(pwd)/results/docker_310:/app/results/smoke" \
fly-model:3.10 \
scripts/smoke_connectome.py 630 --t-run-ms 10
```
The container loads **127,400 neurons / 14,687,178 synapses**, builds the brian2
network, simulates, and writes `smoke_630_10ms.parquet` **onto your host**.
### 4. Run a real experiment and export a spike raster
```bash
mkdir -p ./results/prod
docker run --rm \
--cpus 10 --memory 20g \
-v fly-brian2-cache-310:/root/.cython \
-v "$(pwd)/results/prod:/app/results/run" \
fly-model:3.10 \
scripts/run_full.py --exp-name sugarR --t-run-ms 500 --n-run 2 --n-proc 10 --raster
```
Produces `results/prod/sugarR.parquet` (spike events) **and**
`results/prod/sugarR_raster.png` (spike raster + firing-rate histogram).
> **Full paper reproduction** — omit `--t-run-ms` / `--n-run` to use the model
> defaults (30 trials × 1000 ms):
> ```bash
> docker run --rm -v fly-brian2-cache-310:/root/.cython \
> -v "$(pwd)/results/prod:/app/results/run" \
> fly-model:3.10 scripts/run_full.py --exp-name sugarR --n-proc 10 --raster
> ```
### 5. …or use Docker Compose
```bash
docker compose up --build
```
---
## 🧬 Image matrix
| Image | Python | brian2 | Cython | NumPy | Stack | Image size | Verified |
|-------|--------|--------|--------|-------|-------|-----------|----------|
| `fly-model:3.10` | 3.10.19 | 2.5.1 | 0.29.36 | 1.24.4 | 📜 paper-exact | 1.75 GB | ✅ |
| `fly-model:3.11` | 3.11.14 | 2.5.1 | 0.29.36 | 1.24.4 | 📜 paper-exact (sdist build) | 1.78 GB | ✅ |
| `fly-model:3.12` | 3.12.12 | 2.10.1 | 3.1.3 | 2.5.3 | 🚀 modern | 1.77 GB | ✅ |
| `fly-model:3.13` | 3.13.11 | 2.10.1 | 3.1.3 | 2.5.3 | 🚀 modern | 1.76 GB | ✅ |
| `fly-model:3.14` | 3.14.2 | 2.10.1 | 3.1.3 | 2.5.3 | ⚡ cutting-edge | 2.03 GB | ✅ |
Build all of them:
```bash
for V in 3.10 3.11 3.12 3.13 3.14; do
docker build --build-arg PYTHON_VERSION=$V -t fly-model:$V .
done
```
> **Which one should I use?**
> Use **`3.10`** to reproduce the published results (it matches the paper's
> brian2 2.5.1 exactly, has the lowest memory footprint, and installs from a
> prebuilt wheel). Use **`3.14`** for new development and future-proofing.
> Use a **separate cache volume per Python version** — compiled `.so` files are
> ABI-specific and must never be shared across major versions.
---
## 🏗️ Architecture & performance
### The model
| | FlyWire v630 *(paper)* | FlyWire v783 *(public)* |
|---|---|---|
| Neurons | **127,400** | **138,639** |
| Synapses | **14,687,178** | **15,091,983** |
| Neuron model | Leaky integrate-and-fire (LIF), alpha synapse | same |
| Integration | `method='linear'`, exact exponential synapse decay | same |
| Simulation engine | brian2 → generated Cython → C++ → native `.so` | same |
### Measured performance (this repo's verification runs)
| Metric | Value |
|--------|-------|
| Peak RAM — full connectome build + run | **≈ 3.4 GB** (3.36 – 3.66 GB) |
| Peak RAM — 1000-neuron pipeline check | ≈ 0.3 GB |
| Connectivity parquet load | ~0.7 s |
| brian2 network construction | 1.5 – 7.5 s |
| Cold run (includes C++ compile) | ~65 – 75 s |
| **Warm run (cached)** | **~5 s** |
| Compiler inside images | g++ 12.2.0 (Debian bookworm) |
| Compile flags | `-O3 -ffast-math -fno-finite-math-only -march=native -std=c++11` |
`-march=native` is enabled, so the generated C++ is tuned to **your** CPU — on the
reference machine (AMD Ryzen 7 3800X, Zen 2 / AVX2) the codegen picks up the
available SIMD width automatically.
### Why the cache volume matters
brian2 emits Cython, compiles it to C++, then links a shared object per code
object. Those artefacts are content-hashed and land in `/root/.cython`. A `--rm`
container throws them away, so **every** run pays the full compile. Mounting a
named volume there pays it **once**:
```
-v fly-brian2-cache-310:/root/.cython
```
### Output format
Results are parquet files with one row per spike:
| column | type | meaning |
|--------|------|---------|
| `t` | float64 | spike time within the trial (s) |
| `trial` | int64 | trial index (0 … n_run-1) |
| `flywire_id` | int64 | FlyWire neuron ID |
| `exp_name` | object | experiment name |
`run_full.py --raster` additionally renders a spike raster and a top-firing-rate
bar chart as a PNG.
---
## 📁 Repository layout
```
.
├── Dockerfile # parameterized multi-Python image (3.10 - 3.14)
├── docker-compose.yml # `docker compose up` convenience wrapper
├── .dockerignore # trims the multi-GB build context to ~190 MB
├── .gitignore
├── .gitattributes
├── LICENSE # MIT (inherits upstream terms)
├── README.md # this file (EN + RU)
├── ruff.toml # lint config — must stay in root for ruff discovery
│
├── model.py # [upstream] LIF network construction + run_exp()
├── utils.py # [upstream] spike loading / firing-rate analysis
│
├── data/ # connectome data + curated reference output (~190 MB)
│ ├── 2023_03_23_connectivity_630_final.parquet # FlyWire v630 links (83 MB)
│ ├── 2023_03_23_completeness_630_final.csv # FlyWire v630 list (3.0 MB)
│ ├── Connectivity_783.parquet # FlyWire v783 links (97 MB)
│ ├── Completeness_783.csv # FlyWire v783 list (3.2 MB)
│ ├── sez_neurons.pickle # SEZ neuron subset
│ └── example/ # reference spike output (shipped)
│
├── scripts/ # CLI tools + verification suites
│ ├── run_full.py # main experiment launcher (+ spike raster export)
│ ├── verify_fly_pipeline.py # Cython/C++ codegen + LIF smoke test
│ ├── smoke_connectome.py # staged real-connectome micro-run
│ ├── make_raster.py # spike-raster plotting
│ ├── prove_codegen.py # codegen backend diagnostics
│ └── check_plots.py # plot integrity checker
│
├── notebooks/ # research notebooks (archival, from upstream)
│ ├── example.ipynb # tutorial
│ └── figures.ipynb # paper figure reproduction
│
├── docs/ # archived reports + upstream metadata
│ ├── UPSTREAM_README.md
│ ├── RUN_REPORT.md
│ ├── MATRIX_REPORT.md
│ ├── DOCKER_MATRIX_REPORT.md
│ ├── PYTHON_314_REPORT.md
│ ├── environment.yml
│ └── environment_full.yml
│
├── results/ # OUTPUT directory (git-ignored, holds only .gitkeep)
└── .github/
└── workflows/
└── docker-test.yml # CI: build + smoke test every Python version
```
---
## 📦 Data
The connectome data is **committed to this repository** (~190 MB total) so that
`docker build` works fully offline and the images are self-contained.
| File | Size | Content |
|------|------|---------|
| `Connectivity_783.parquet` | 97 MB | 15,091,983 connections (v783) |
| `2023_03_23_connectivity_630_final.parquet` | 83 MB | 14,687,178 connections (v630, paper) |
| `Completeness_*.csv` | 6 MB | neuron ID lists |
| `data/example/*.parquet` | 3.6 MB | reference spike output |
> The largest file (97 MB) is just under GitHub's 100 MB per-file limit. If you
> plan to grow the data, migrate these to **Git LFS** first.
### Choosing a FlyWire version
`example.ipynb` and `run_full.py` default to **v630** (the version used in the
paper). To use the newer public **v783** release:
```bash
docker run --rm fly-model:3.10 scripts/run_full.py --version 783 --exp-name sugarR_783 --raster
```
⚠️ **Known upstream issue:** the 21 hard-coded sugar-neuron IDs in `example.ipynb`
are v630-specific. One of them (`720575940620900446`) does **not** exist in v783 and
causes a `KeyError` in `model.py`. `run_full.py` and `smoke_connectome.py` filter
the ID list against the selected completeness table automatically; the raw
notebook does not.
---
## 📚 Citations & attribution
This work is **packaging and reproducibility engineering only**. The scientific
model, connectome processing and analysis code are the work of the original authors.
**Please cite the original paper:**
> Shiu, P.K., Sterne, G.R., Spiller, N., Franconville, R., Sandoval, A., Zhou, J.,
> Simha, N., Scott, C.E., Chen, K., Morris, B.J., Januszewski, M., Blakely, T.,
> Hourihan, K., Berger, S., Bidelman, S., Blanchard, J., Borba, E., Bumbarger, D.,
> Canino, B., … & Seung, H.S.
> **A leaky integrate-and-fire computational model based on the connectome of the
> entire adult *Drosophila* brain reveals insights into sensorimotor processing.**
> *bioRxiv* (2023).
**Connectome data — FlyWire:**
> Dorkenwald, S., Matsliah, A., Sterling, A.R., Schlegel, P., Yu, S., McKellar, C.E.,
> Lin, A., Costa, M., Eichler, K., Yin, Y., … & the FlyWire Consortium.
> **Neuronal wiring diagram of an adult brain.** *Nature* (2024).
>
**Upstream code:**
- 🧬 Original repository:
- 🏛️ **Janelia Research Campus**, HHMI — FlyWire consortium host
- 🔬 **FlyWire**:
- ⚙️ **brian2** simulator:
- 📊 Model output archive (several GB):
**Simulation parameters** are sourced from the literature and documented inline in
`model.py` (Kakaria & de Bivort 2017; Jürgensen et al.; Lazar et al.; Paul et al. 2015).
---
## 📄 License
**MIT** — see [`LICENSE`](LICENSE).
The original model code is © 2023 Philip Shiu and Nico Spiller, released under the
MIT License. The containerization, verification scripts and documentation in this
repository are distributed under the same terms. Connectome data remains subject to
the terms of its original providers (FlyWire / Janelia Research Campus).
---
---
# 🇷🇺 Русская версия
### 🧠 drosophila-brain-docker
**Высокопроизводительная контейнеризованная симуляция спайковой активности всего мозга дрозофилы**
*Воспроизводимая упаковка LIF-модели коннектома FlyWire — без настройки окружения*
---
## 📖 Что это
Этот репозиторий упаковывает **[модель мозга дрозофилы](https://github.com/philshiu/Drosophila_brain_model)**
Филипа Шиу и коллег — спайковую симуляцию на основе модели «leaky integrate-and-fire»
(LIF), построенную на полном коннектоме взрослой плодовой мушки — в
**самодостаточные Docker-образы**.
Вместо того чтобы сражаться с поломками цепочки GCC/Cython/NumPy на своей машине,
вы получаете побитово воспроизводимое окружение, которое запускает **всю модель
мозга из 127 тыс. нейронов на CPU** одной командой.
```bash
docker run --rm fly-model:3.10 scripts/verify_fly_pipeline.py # ~25 с, печатает PASS
```
---
## 💡 Зачем это нужно (ценность)
### 🐛 Исправляется реальный краш, ломающий оригинальный код на современном Python
Опубликованная модель задаёт для `brian2` слишком слабое ограничение снизу. На
любом современном стеке это разрешается в **brian2 2.9.0**, который падает при импорте:
```
File "brian2/units/fundamentalunits.py", line 1661, in Quantity
ptp = wrap_function_keep_dimensions(np.ndarray.ptp)
AttributeError: type object 'numpy.ndarray' has no attribute 'ptp'
```
Атрибут `np.ndarray.ptp` был **удалён в NumPy 2.0**. То есть требования
`brian2>=2.9.0` и `numpy>=2.0.0` **взаимоисключающие** — ловушка, которая тихо
ломает любое окружение на Python 3.12+.
✅ **Здесь это исправлено** пином `brian2>=2.10.0` (и `>=2.10.1` для 3.14) — первым
релизом, где корректно используется `np.ptp(...)`.
### ⚡ 8 секунд из кэша вместо медленной и хрупкой пересборки
Компиляция сгенерированного C++ в brian2 доминирует в каждом «холодном» запуске.
Кэш кодогенерации живёт в `/root/.cython`, поэтому **именованный том** превращает
повторный запуск почти в мгновенный:
| Запуск | Модельное время | Реальное время |
|--------|-----------------|----------------|
| ❄️ Холодный (ещё не собирался) | 10 мс | **~65 с** |
| 🔥 Прогретый (том с кэшем подключён) | 10 мс | **~5 с** |
Это **ускорение примерно в 8 раз**, и оно накапливается с каждым экспериментом.
*(Для масштаба: оригинальный проект указывает, что полный эксперимент на 30 прогонов
занимает около 20 минут в Google Colab и «существенно быстрее на локальной машине».)*
### 📦 Нулевая настройка — никакой «археологии» тулчейна
Никаких `apt-get install build-essential`, никакой рулетки с версией `g++`,
никаких сюрпризов с `-march=native`, исчезающих `pkg_resources` и мучений с
solver'ом conda. И компилятор C++, и точный научный стек **уже внутри образа**.
### 🧪 Проверенная матрица совместимости, а не догадки
Каждый образ ниже был реально **собран, запущен и провалидирован** — с 3.10 по 3.14.
Там, где оригинальному коду нужны были правки для работы на 3.12+ (краш `ptp`) или
на 3.11 (у brian2 нет wheel для `cp311`, нужна сборка из исходников), эти правки
встроены и задокументированы, а не оставлены вам в качестве упражнения.
---
## 🚀 Быстрый старт
### 1. Собрать образ
```bash
git clone https://github.com//drosophila-brain-docker.git
cd drosophila-brain-docker
docker build --build-arg PYTHON_VERSION=3.10 -t fly-model:3.10 .
```
### 2. Проверить пайплайн (Cython → C++ → спайки)
```bash
docker run --rm fly-model:3.10 scripts/verify_fly_pipeline.py
```
Ожидаемое окончание вывода:
```
-> Simulation completed. Generated 3000 spikes across 50ms.
[3/3] PASS: Spiking engine and C++ compiler working properly.
RESULT: PASS
```
### 3. Запустить реальную микрo-симуляцию коннектома
Создайте каталог для результатов и постоянный том кэша Cython:
```bash
mkdir -p ./results/docker_310
docker volume create fly-brian2-cache-310
docker run --rm \
-v fly-brian2-cache-310:/root/.cython \
-v "$(pwd)/results/docker_310:/app/results/smoke" \
fly-model:3.10 \
scripts/smoke_connectome.py 630 --t-run-ms 10
```
Контейнер загружает **127 400 нейронов / 14 687 178 синапсов**, строит сеть brian2,
проводит симуляцию и записывает `smoke_630_10ms.parquet` **прямо на ваш хост**.
### 4. Запустить настоящий эксперимент и выгрузить raster-график
```bash
mkdir -p ./results/prod
docker run --rm \
--cpus 10 --memory 20g \
-v fly-brian2-cache-310:/root/.cython \
-v "$(pwd)/results/prod:/app/results/run" \
fly-model:3.10 \
scripts/run_full.py --exp-name sugarR --t-run-ms 500 --n-run 2 --n-proc 10 --raster
```
На выходе: `results/prod/sugarR.parquet` (события спайков) **и**
`results/prod/sugarR_raster.png` (растр спайков + гистограмма частот).
> **Полное воспроизведение статьи** — уберите `--t-run-ms` / `--n-run`, чтобы
> использовать значения модели по умолчанию (30 прогонов × 1000 мс):
> ```bash
> docker run --rm -v fly-brian2-cache-310:/root/.cython \
> -v "$(pwd)/results/prod:/app/results/run" \
> fly-model:3.10 scripts/run_full.py --exp-name sugarR --n-proc 10 --raster
> ```
### 5. …или используйте Docker Compose
```bash
docker compose up --build
```
---
## 🧬 Матрица образов
| Образ | Python | brian2 | Cython | NumPy | Стек | Размер | Проверен |
|-------|--------|--------|--------|-------|------|--------|----------|
| `fly-model:3.10` | 3.10.19 | 2.5.1 | 0.29.36 | 1.24.4 | 📜 как в статье | 1.75 GB | ✅ |
| `fly-model:3.11` | 3.11.14 | 2.5.1 | 0.29.36 | 1.24.4 | 📜 как в статье (sdist) | 1.78 GB | ✅ |
| `fly-model:3.12` | 3.12.12 | 2.10.1 | 3.1.3 | 2.5.3 | 🚀 современный | 1.77 GB | ✅ |
| `fly-model:3.13` | 3.13.11 | 2.10.1 | 3.1.3 | 2.5.3 | 🚀 современный | 1.76 GB | ✅ |
| `fly-model:3.14` | 3.14.2 | 2.10.1 | 3.1.3 | 2.5.3 | ⚡ передний край | 2.03 GB | ✅ |
Собрать все сразу:
```bash
for V in 3.10 3.11 3.12 3.13 3.14; do
docker build --build-arg PYTHON_VERSION=$V -t fly-model:$V .
done
```
> **Какой выбрать?**
> Для воспроизведения опубликованных результатов — **`3.10`** (точно совпадает с
> brian2 2.5.1 из статьи, минимальное потребление памяти, готовый wheel).
> Для новой разработки и запаса на будущее — **`3.14`**.
> **Используйте отдельный том кэша для каждой версии Python** — собранные `.so`
> ABI-специфичны, их нельзя переносить между мажорными версиями.
---
## 🏗️ Архитектура и производительность
### Модель
| | FlyWire v630 *(статья)* | FlyWire v783 *(публичная)* |
|---|---|---|
| Нейронов | **127 400** | **138 639** |
| Синапсов | **14 687 178** | **15 091 983** |
| Модель нейрона | LIF, альфа-синапс | та же |
| Интегрирование | `method='linear'`, точный экспоненциальный распад | то же |
| Движок | brian2 → Cython → C++ → нативный `.so` | то же |
### Измеренная производительность (проверочные прогоны этого репозитория)
| Метрика | Значение |
|---------|----------|
| Пик ОЗУ — сборка и прогон полного коннектома | **≈ 3.4 ГБ** (3.36 – 3.66 ГБ) |
| Пик ОЗУ — проверка пайплайна (1000 нейронов) | ≈ 0.3 ГБ |
| Загрузка parquet связности | ~0.7 с |
| Построение сети brian2 | 1.5 – 7.5 с |
| Холодный прогон (включая компиляцию C++) | ~65 – 75 с |
| **Прогретый прогон (из кэша)** | **~5 с** |
| Компилятор внутри образов | g++ 12.2.0 (Debian bookworm) |
| Флаги компиляции | `-O3 -ffast-math -fno-finite-math-only -march=native -std=c++11` |
`-march=native` включён, поэтому сгенерированный C++ оптимизируется под **ваш**
процессор — на эталонной машине (AMD Ryzen 7 3800X, Zen 2 / AVX2) кодогенерация
автоматически использует доступную ширину SIMD.
### Почему важен том кэша
brian2 генерирует Cython, компилирует его в C++ и линкует разделяемую библиотеку
для каждого code object. Эти артефакты хешируются по содержимому и попадают в
`/root/.cython`. Контейнер с `--rm` их выбрасывает, поэтому **каждый** запуск платит
полную цену компиляции. Именованный том заставляет заплатить её **один раз**:
```
-v fly-brian2-cache-310:/root/.cython
```
### Формат результатов
Результаты — это parquet-файлы, по одной строке на спайк:
| колонка | тип | смысл |
|---------|-----|-------|
| `t` | float64 | время спайка внутри прогона (с) |
| `trial` | int64 | индекс прогона (0 … n_run-1) |
| `flywire_id` | int64 | ID нейрона FlyWire |
| `exp_name` | object | имя эксперимента |
`run_full.py --raster` дополнительно рисует растр спайков и столбчатую диаграмму
топовых частот в виде PNG.
---
## 📦 Данные
Данные коннектома **включены в репозиторий** (~190 МБ), чтобы `docker build`
работал полностью офлайн и образы были самодостаточными.
> Самый большой файл (97 МБ) вплотную подходит к лимиту GitHub в 100 МБ на файл.
> Если данных станет больше — сначала переезжайте на **Git LFS**.
### Выбор версии FlyWire
`example.ipynb` и `run_full.py` по умолчанию используют **v630** (версия из статьи).
Для более новой публичной **v783**:
```bash
docker run --rm fly-model:3.10 scripts/run_full.py --version 783 --exp-name sugarR_783 --raster
```
⚠️ **Известная проблема в апстриме:** 21 жёстко прописанный ID сахарных нейронов в
`example.ipynb` специфичны для v630. Один из них (`720575940620900446`) **отсутствует**
в v783 и вызывает `KeyError` в `model.py`. `run_full.py` и `smoke_connectome.py`
автоматически фильтруют список ID по выбранной таблице completeness — сырой ноутбук
этого не делает.
---
## 📚 Цитирование и атрибуция
Эта работа — **только упаковка и инженерия воспроизводимости**. Научная модель, код
обработки коннектома и анализа — работа оригинальных авторов.
**Ссылайтесь на оригинальную статью:**
> Shiu, P.K., Sterne, G.R., Spiller, N., Franconville, R., Sandoval, A., Zhou, J.,
> Simha, N., Scott, C.E., Chen, K., Morris, B.J., Januszewski, M., Blakely, T.,
> Hourihan, K., … & Seung, H.S.
> **A leaky integrate-and-fire computational model based on the connectome of the
> entire adult *Drosophila* brain reveals insights into sensorimotor processing.**
> *bioRxiv* (2023).
**Данные коннектома — FlyWire:**
> Dorkenwald, S., Matsliah, A., Sterling, A.R., Schlegel, P., Yu, S., McKellar, C.E.,
> … & the FlyWire Consortium.
> **Neuronal wiring diagram of an adult brain.** *Nature* (2024).
>
**Ссылки:**
- 🧬 Оригинальный репозиторий:
- 🏛️ **Janelia Research Campus**, HHMI — хост консорциума FlyWire
- 🔬 **FlyWire**:
- ⚙️ Симулятор **brian2**:
- 📊 Архив выходных данных модели (несколько ГБ):
---
## 📄 Лицензия
**MIT** — см. [`LICENSE`](LICENSE).
Оригинальный код модели © 2023 Philip Shiu и Nico Spiller, выпущен под лицензией MIT.
Контейнеризация, проверочные скрипты и документация в этом репозитории
распространяются на тех же условиях. Данные коннектома остаются под условиями
их первоначальных поставщиков (FlyWire / Janelia Research Campus).
---
**⭐ If this saved you a day of toolchain pain, star the original paper's repo too.**
**⭐ Если это сэкономило вам день на возне с тулчейном — поставьте звезду и оригинальному репозиторию.**