Development and application of a multi-task fusion model using susceptibility-weighted imaging-based substantia nigra and adjacent structures for prognostic prediction of subthalamic nucleus deep brain stimulation in Parkinson's disease.

Code ↔ Paper

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

The 2 matches

[1] § Materials and methods › Model development ↔ PD_model.py, lines 410–460 · score 0.56 · Conv3d, MaxPool3d, ReLU, layers, softmax, blocks
[2] § Materials and methods › Model development ↔ PD_model.py, lines 113–176 · score 0.52 · logistic regression, MaxPool3d, ReLU, linear, Model

Paper

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

The paper is loaded when this pane is shown.

The paper is loaded by your browser, with JavaScript: read it at doi.org or on Europe PMC.

The authors' code

Python · 561 lines · 19 KB · no license · 2 matches

import torch
import torch.nn as nn
import torch.nn.functional as F
import math
def maxpool_3d1():
pool = nn.MaxPool3d(kernel_size=1, stride=1, padding=0)
return pool
def maxpool_3d2():
pool = nn.MaxPool3d(kernel_size=2, stride=2, padding=0)#
return pool
def conv_block_3dd(in_dim, out_dim,kernel_size,stride):
model = nn.Sequential(
nn.Conv3d(in_dim,out_dim, kernel_size=kernel_size, stride=stride, padding=1),
nn.InstanceNorm3d(out_dim,affine=False),
nn.LeakyReLU(inplace=True)
)
return model
class PD_class_Net2(nn.Module):
def __init__(self,in_dim,out_dim):
super(PD_class_Net2,self).__init__()
self.in_dim=in_dim
self.out_dim=out_dim
self.level1_Dim=64
self.level3_Dim=128
self.level5_Dim=256
self.conv_3d1=conv_block_3dd(self.in_dim,16,3,1)
self.pool1=nn.MaxPool3d(kernel_size=(1,2,2),stride=(1,2,2),padding=0)
self.conv_3d2=conv_block_3dd(16,32,3,1)
self.pool2=nn.MaxPool3d(kernel_size=(1,2,2),stride=(1,2,2),padding=0)
self.conv_3d3=conv_block_3dd(32,64,3,1)
self.pool3=nn.MaxPool3d(kernel_size=2,stride=2,padding=0)
#self.avgpool = nn.AdaptiveAvgPool3d((1, 1, 1))
self.fc=nn.Sequential(
nn.Dropout(0.2),
nn.Flatten(),
nn.ReLU(),
nn.Linear(16000, 512), # 1124864,512;106496,512
nn.Sigmoid(),
nn.ReLU(),
nn.Linear(512, 64),
nn.Dropout(0.5),
nn.ReLU(),
nn.Linear(64, 2)
)
def forward(self,x):#[10,40,80]
conv1=self.conv_3d1(x)
pool1=self.pool1(conv1)#[10,20,40]
#print(pool1.shape)
conv2=self.conv_3d2(pool1)
pool2=self.pool2(conv2)
#print(pool2.shape)#[10,10,20]
conv3=self.conv_3d3(pool2)
pool3=self.pool3(conv3)#[5,5,10]
#print(pool3.shape)
#x = pool3.view(pool3.size(0), -1)
x=pool3
#x=pool3.view(-1,16000)
#print(x.shape)
out=self.fc(x)#[[-0.3055,-0.2215]]
return out
class PD_reg_Net2(nn.Module):
def __init__(self,in_dim,out_dim):
super(PD_reg_Net2,self).__init__()
self.in_dim=in_dim
self.out_dim=out_dim
self.level1_Dim=64
self.level3_Dim=128
self.level5_Dim=256
self.conv_3d1=conv_block_3dd(self.in_dim,16,3,1)
self.pool1=nn.MaxPool3d(kernel_size=(1,2,2),stride=(1,2,2),padding=0)
self.conv_3d2=conv_block_3dd(16,32,3,1)
self.pool2=nn.MaxPool3d(kernel_size=(1,2,2),stride=(1,2,2),padding=0)
self.conv_3d3=conv_block_3dd(32,64,3,1)
self.pool3=nn.MaxPool3d(kernel_size=2,stride=2,padding=0)
#self.avgpool = nn.AdaptiveAvgPool3d((1, 1, 1))
self.fc=nn.Sequential(
nn.Dropout(0.2),
nn.Flatten(),
nn.ReLU(),
nn.Linear(16000, 512), # 1124864,512;106496,512
nn.Sigmoid(),
nn.ReLU(),
nn.Linear(512, 64),
nn.Dropout(0.5),
nn.ReLU(),
nn.Linear(64, 1)
)
def forward(self,x):#[10,40,80]
conv1=self.conv_3d1(x)
pool1=self.pool1(conv1)#[10,20,40]
#print(pool1.shape)
conv2=self.conv_3d2(pool1)
pool2=self.pool2(conv2)
#print(pool2.shape)#[10,10,20]
conv3=self.conv_3d3(pool2)
pool3=self.pool3(conv3)#[5,5,10]
#print(pool3.shape)
#x = pool3.view(pool3.size(0), -1)
x=pool3
#x=pool3.view(-1,16000)
#print(x.shape)
out=self.fc(x)#[[-0.3055,-0.2215]]
out=torch.sigmoid(out)
return out
class PD_all_Net2(nn.Module):
def __init__(self, in_dim, out_dim):
super(PD_all_Net2, self).__init__()
self.in_dim = in_dim
self.out_dim = out_dim
self.level1_Dim = 64
self.level3_Dim = 128
self.level5_Dim = 256
self.conv_3d1 = conv_block_3dd(self.in_dim, 16, 3, 1)
self.pool1 = nn.MaxPool3d(kernel_size=(1, 2, 2), stride=(1, 2, 2), padding=0)
self.conv_3d2 = conv_block_3dd(16, 32, 3, 1)
self.pool2 = nn.MaxPool3d(kernel_size=(1, 2, 2), stride=(1, 2, 2), padding=0)
self.conv_3d3 = conv_block_3dd(32, 64, 3, 1)
self.pool3 = nn.MaxPool3d(kernel_size=2, stride=2, padding=0)
self.avgpool = nn.AdaptiveAvgPool3d((1, 1, 1))
self.fc1 = nn.Sequential(
nn.Dropout(0.2),
nn.Flatten(),
nn.ReLU(),
nn.Linear(16000, 512), # 1124864,512;106496,512
nn.Sigmoid(),
nn.ReLU(),
nn.Linear(512, 64),
nn.Dropout(0.5),
nn.ReLU(),
nn.Linear(64, 2),
nn.Softmax(dim=1)
)
self.fc2 = nn.Sequential(
nn.Dropout(0.2),
nn.Flatten(),
nn.ReLU(),
nn.Linear(16000, 512), # 1124864,512;106496,512
nn.Sigmoid(),
nn.ReLU(),
nn.Linear(512, 64),
nn.Dropout(0.5),
nn.ReLU(),
nn.Linear(64, 1),
nn.Sigmoid()
)
self.logistic_regression = nn.Sequential(
nn.Linear(2, out_dim),
nn.Softmax(dim=1)
)
def forward(self, x): # [10,40,80]
conv1 = self.conv_3d1(x)
pool1 = self.pool1(conv1) # [10,20,40]
conv2 = self.conv_3d2(pool1)
pool2 = self.pool2(conv2)
conv3 = self.conv_3d3(pool2)
pool3 = self.pool3(conv3) # [5,5,10]
#pool3 = self.avgpool(pool3)
x = pool3#.view(pool3.size(0), -1)
out1 = self.fc1(x) # [[-0.3055,-0.2215]]
out2 = self.fc2(x)
a = out1[:, 1]
b = out2[:, 0]
# print(a,b)
ab = torch.stack((a, b), dim=1)
# print('ab',ab)
out = self.logistic_regression(ab)
return out,out1,out2
#@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
class PD_3dNet(nn.Module):
def __init__(self,in_dim,out_dim):
super(PD_3dNet,self).__init__()
self.in_dim=in_dim
self.out_dim=out_dim
self.level1_Dim=64
self.level2_Dim=96
self.level3_Dim=128
self.level4_Dim=196
self.level5_Dim=256
self.level6_Dim=512
self.conv_3d1=conv_block_3dd(self.in_dim,4,3,2)
self.conv_3d2=conv_block_3dd(4,16,3,2)
self.pool1=maxpool_3d2()
self.conv_3d3=conv_block_3dd(16,64,3,2)
self.pool2=maxpool_3d2()
self.conv_3d5=conv_block_3dd(64,128,2,1)
self.pool3=maxpool_3d1()
self.conv_3d9=conv_block_3dd(128,256,1,1)
self.conv_3d12=conv_block_3dd(256,512,1,1)
self.pool4=maxpool_3d1()
self.fc=nn.Sequential(
nn.Dropout(0.2),
nn.Flatten(),
nn.Linear(200704,512),#1124864,512#150528
nn.Sigmoid(),
nn.Linear(512,256),
nn.Dropout(0.5 ),
nn.Linear(256,128),
nn.Linear(128,2))
#self.out=nn.Softmax(dim=0)#[1,1]
self.out=nn.Softmax(dim=1)
class PD_3d_seg_Net(nn.Module):
def __init__(self,in_dim,out_dim):
super(PD_3d_seg_Net,self).__init__()
self.in_dim=in_dim
self.out_dim=out_dim
self.level1_Dim=64
self.level2_Dim=96
self.level3_Dim=128
self.level4_Dim=196
self.level5_Dim=256
self.level6_Dim=512
self.conv_3d1=conv_block_3dd(self.in_dim,4,3,1)
self.conv_3d2=conv_block_3dd(4,16,3,1)
self.pool1=nn.MaxPool3d(kernel_size=(1,2,2),stride=(1,2,2),padding=0)
self.conv_3d3=conv_block_3dd(16,64,3,1)
self.pool2=nn.MaxPool3d(kernel_size=(1,2,2),stride=(1,2,2),padding=0)
self.conv_3d4=conv_block_3dd(64,128,3,1)
self.conv_3d5=conv_block_3dd(128,256,3,1)
self.pool3=nn.MaxPool3d(kernel_size=2,stride=2,padding=0)
self.fc=nn.Sequential(
nn.Dropout(0.2),
nn.Flatten(),
#nn.ReLU(),
nn.Linear(64000,512),#1124864,512;106496,512
nn.Sigmoid(),
nn.ReLU(),
nn.Linear(512,128),
nn.Dropout(0.5 ),
nn.ReLU(),
nn.Linear(128,1)
)
#self.out=nn.Softmax(dim=0)#[1,1]
#self.out=nn.Softmax(dim=1)
def forward(self,x):
conv1=self.conv_3d1(x)
conv2=self.conv_3d2(conv1)
pool1=self.pool1(conv2)
conv3=self.conv_3d3(pool1)
pool2=self.pool2(conv3)
conv4=self.conv_3d4(pool2)
conv5=self.conv_3d5(conv4)
pool3=self.pool3(conv5)
fc=self.fc(pool3)#[[-0.3055,-0.2215]]
#out=self.out(fc)
return fc
class BasicBlock(nn.Module):
expansion=1
def __init__(self,inplanes,planes,kernel_size=3,stride=1,downsample=None):
super(BasicBlock,self).__init__()
self.conv1=nn.Conv3d(inplanes,planes,kernel_size=kernel_size,stride=stride,padding=1,bias=False)
self.bn1=nn.InstanceNorm3d(planes)
self.relu=nn.LeakyReLU(inplace=True)
self.conv2=nn.Conv3d(planes,planes,kernel_size=kernel_size,stride=stride,padding=1,bias=False)
self.bn2=nn.InstanceNorm3d(planes)
self.downsample=nn.Sequential(nn.Conv3d(inplanes,planes,kernel_size=1,stride=2),nn.InstanceNorm3d(planes))
self.stride=stride
def forward(self, x):
residual=x
out=self.conv1(x)
out=self.bn1(out)
out=self.relu(out)
out=self.conv2(out)
out=self.bn2(out)
#if self.downsample is not None:
# residual=self.downsample(x)
out=F.relu(out)
return out
class PD_3d_seg_resNet(nn.Module):
def __init__(self,in_dim,out_dim):
super(PD_3d_seg_resNet,self).__init__()
self.in_dim=in_dim
self.out_dim=out_dim
self.level1_Dim=64
self.level2_Dim=96
self.level3_Dim=128
self.level4_Dim=196
self.level5_Dim=256
self.level6_Dim=512
self.conv_3d1=conv_block_3dd(self.in_dim,4,3,1)
self.conv_3d2=conv_block_3dd(4,16,3,1)
self.pool1=nn.MaxPool3d(kernel_size=(1,2,2),stride=(1,2,2),padding=0)
self.block1=BasicBlock(16,32)
self.block2=BasicBlock(32,64)
#self.conv_3d3=conv_block_3dd(16,64,3,1)
self.pool2=nn.MaxPool3d(kernel_size=(1,2,2),stride=(1,2,2),padding=0)
self.block3=BasicBlock(64,128)
self.block4=BasicBlock(128,256)
#self.conv_3d4=conv_block_3dd(64,128,3,1)
#self.conv_3d5=conv_block_3dd(128,256,3,1)
self.pool3=nn.MaxPool3d(kernel_size=2,stride=2,padding=0)
self.fc=nn.Sequential(
nn.Dropout(0.2),
nn.Flatten(),
#nn.ReLU(),
nn.Linear(64000,512),#1124864,512;106496,512
nn.Sigmoid(),
nn.ReLU(),
nn.Linear(512,128),
nn.Dropout(0.5 ),
nn.ReLU(),
nn.Linear(128,1)#(128,2)->分类，(128,1)->回归
)
#self.out=nn.Softmax(dim=0)#[1,1]
##self.out=nn.Softmax(dim=1)
def forward(self,x):
conv1=self.conv_3d1(x)
conv2=self.conv_3d2(conv1)
pool1=self.pool1(conv2)
block1=self.block1(pool1)
block2=self.block2(block1)
pool2=self.pool2(block2)
block3=self.block3(pool2)
block4=self.block4(block3)
pool3=self.pool3(block4)
fc=self.fc(pool3)#[[-0.3055,-0.2215]]
#out=self.out(fc)
return fc
#分类+回归
class BasicBlock3D(nn.Module):
expansion = 1
def __init__(self, in_channels, out_channels, stride=1, downsample=None):
super(BasicBlock3D, self).__init__()
self.conv1 = nn.Conv3d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False)
self.bn1 = nn.BatchNorm3d(out_channels)
self.relu = nn.ReLU(inplace=True)
self.conv2 = nn.Conv3d(out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False)
self.bn2 = nn.BatchNorm3d(out_channels)
self.downsample = downsample
self.stride = stride
def forward(self, x):
residual = x
out = self.conv1(x)
out = self.bn1(out)
out = self.relu(out)
out = self.conv2(out)
out = self.bn2(out)
if self.downsample is not None:
residual = self.downsample(x)
out += residual
out = self.relu(out)
return out
class Bottleneck3D(nn.Module):
expansion = 4
def __init__(self, in_channels, out_channels, stride=1, downsample=None):
super(Bottleneck3D, self).__init__()
self.conv1 = nn.Conv3d(in_channels, out_channels, kernel_size=1, bias=False)
self.bn1 = nn.BatchNorm3d(out_channels)
self.conv2 = nn.Conv3d(out_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False)
self.bn2 = nn.BatchNorm3d(out_channels)
self.conv3 = nn.Conv3d(out_channels, out_channels * self.expansion, kernel_size=1, bias=False)
self.bn3 = nn.BatchNorm3d(out_channels * self.expansion)
self.relu = nn.ReLU(inplace=True)
self.downsample = downsample
self.stride = stride
def forward(self, x):
residual = x
out = self.conv1(x)
out = self.bn1(out)
out = self.relu(out)
out = self.conv2(out)
out = self.bn2(out)
out = self.relu(out)
out = self.conv3(out)
out = self.bn3(out)
if self.downsample is not None:
residual = self.downsample(x)
out += residual
out = self.relu(out)
return out
class ResNet3D(nn.Module):
def __init__(self, block, layers, num_classes=2):
super(ResNet3D, self).__init__()
self.in_channels = 64
self.conv1 = nn.Conv3d(1, 64, kernel_size=7, stride=2, padding=3, bias=False)
self.bn1 = nn.BatchNorm3d(64)
self.relu = nn.ReLU(inplace=True)
self.maxpool = nn.MaxPool3d(kernel_size=3, stride=2, padding=1)
self.layer1 = self._make_layer(block, 64, layers[0])
self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
self.layer4 = self._make_layer(block, 512, layers[3], stride=2)
self.avgpool = nn.AdaptiveAvgPool3d((1, 1, 1))
self.fc = nn.Sequential(nn.Linear(64, num_classes))#,nn.Softmax(dim=1))
def _make_layer(self, block, out_channels, blocks, stride=1):
downsample = None
if stride != 1 or self.in_channels != out_channels * block.expansion:
downsample = nn.Sequential(
nn.Conv3d(self.in_channels, out_channels * block.expansion, kernel_size=1, stride=stride, bias=False),
nn.BatchNorm3d(out_channels * block.expansion),
)
layers = []
layers.append(block(self.in_channels, out_channels, stride, downsample))
self.in_channels = out_channels * block.expansion
for _ in range(1, blocks):
layers.append(block(self.in_channels, out_channels))
return nn.Sequential(*layers)
def forward(self, x):
x = self.conv1(x)
x = self.bn1(x)
x = self.relu(x)
x = self.maxpool(x)
x1 = self.layer1(x)
x2 = self.layer2(x1)
x3 = self.layer3(x2)
x4 = self.layer4(x3)
x =self.avgpool(x)
x = x.view(x.size(0), -1)
x = self.fc(x)
return x
class ResNet3D1(nn.Module):
def __init__(self, block, layers, num_classes=2):
super(ResNet3D1, self).__init__()
self.in_channels = 64
self.conv1 = nn.Conv3d(1, 64, kernel_size=7, stride=2, padding=3, bias=False)
self.bn1 = nn.BatchNorm3d(64)
self.relu = nn.ReLU(inplace=True)
self.maxpool = nn.MaxPool3d(kernel_size=3, stride=2, padding=1)
self.layer1 = self._make_layer(block, 64, layers[0])
self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
self.layer4 = self._make_layer(block, 512, layers[3], stride=2)
self.avgpool = nn.AdaptiveAvgPool3d((1, 1, 1))
self.fc = nn.Sequential(nn.Linear(2048, num_classes))#,nn.Softmax(dim=1))
def _make_layer(self, block, out_channels, blocks, stride=1):
downsample = None
if stride != 1 or self.in_channels != out_channels * block.expansion:
downsample = nn.Sequential(
nn.Conv3d(self.in_channels, out_channels * block.expansion, kernel_size=1, stride=stride, bias=False),
nn.BatchNorm3d(out_channels * block.expansion),
)
layers = []
layers.append(block(self.in_channels, out_channels, stride, downsample))
self.in_channels = out_channels * block.expansion
for _ in range(1, blocks):
layers.append(block(self.in_channels, out_channels))
return nn.Sequential(*layers)
def forward(self, x):
x = self.conv1(x)
x = self.bn1(x)
x = self.relu(x)
x = self.maxpool(x)
x1 = self.layer1(x)
x2 = self.layer2(x1)
x3 = self.layer3(x2)
x4 = self.layer4(x3)
x = self.avgpool(x4)
x = x.view(x.size(0), -1)
x = self.fc(x)
return x
class ResNet3D2(nn.Module):
def __init__(self, block, layers, num_classes=2):
super(ResNet3D2, self).__init__()
self.in_channels = 64
self.conv1 = nn.Conv3d(1, 64, kernel_size=7, stride=2, padding=3, bias=False)
self.bn1 = nn.BatchNorm3d(64)
self.relu = nn.ReLU(inplace=True)
self.maxpool = nn.MaxPool3d(kernel_size=3, stride=2, padding=1)
self.avgpool = nn.AdaptiveAvgPool3d((1, 1, 1))
self.fc = nn.Sequential(nn.Linear(64, num_classes))#,nn.Softmax(dim=1))
def forward(self, x):
x = self.conv1(x)
x = self.bn1(x)
x = self.relu(x)
x = self.maxpool(x)
x = self.avgpool(x)
x = x.view(x.size(0), -1)
x = self.fc(x)
return x
def pd_all_net2(num_classes=2):
#return ResNet3D2(Bottleneck3D, [3, 4, 6, 3], num_classes=2)
#return PD_class_Net2(1,2)
#return PD_reg_Net2(1,2)
return PD_all_Net2(1,2)
#return ResNet3D1(Bottleneck3D, [3, 4, 6, 3], num_classes=2)
def pd_resnet3d2(num_classes=2):
return ResNet3D2(Bottleneck3D, [3, 4, 6, 3], num_classes=2)
def pd_class_net2(num_classes=2):
return PD_class_Net2(1,2)
def pd_reg_net2(num_classes=2):
return PD_reg_Net2(1,2)
def pd_resnet3d1(num_classes=2):
return ResNet3D1(Bottleneck3D, [3, 4, 6, 3], num_classes=2)

PD_model.py at commit 8d75c50, no license · at the source

Overview

Authors: Chi Xiong^1,2,3, Kun Wang¹, Erkang Cheng¹, Zhiyong Sun¹, Bin Cai^1,2, Chaoshi Niu^2,3, Bo Song^1,2

Institute of Intelligent Machines, Hefei Institutes of Physical Science, Chinese Academy of Sciences, Hefei 230031, P.R. China
University of Science and Technology of China, Hefei 230026, P.R. China
Department of Neurosurgery, The First Affiliated Hospital of USTC, Division of Life Sciences and Medicine, University of Science and Technology of China, Hefei 230001, P.R. China

Institutions: University of Science and Technology of China (China); Chinese Academy of Sciences (China); Hefei Institutes of Physical Science (China); Institute of Intelligent Machines (China)

Journal: Brain communications, volume 8, issue 5, article fcag333

Dates: received 8 January 2026; accepted 17 August 2026; published online 11 September 2026

Type: Research article · Language: English

License: CC BY

Identifiers: DOI 10.1093/braincomms/fcag333 · PMID 42729974 · PMCID PMC13563298 · OpenAlex W7212136710

Open access: gold, a free copy (OpenAlex)

Status: code verified

Categories: structural MRI / diffusion (modality), human (organism), Parkinson's (population), clinical / translational (subfield)

Methods: Statistics, Machine learning, Connectivity

Keywords: Parkinson’s disease, deep brain stimulation, prognostic prediction, deep learning, susceptibility-weighted imaging

Topic: Neurological disorders and treatments (Neurology, Medicine), according to OpenAlex

Funding: National Natural Science Foundation of China (National Science Foundation of China) (61973294); Anhui Provincial Key R&D Program (2023s07020017, 2022i01020020); University Synergy Innovation Program of Anhui Province (GXXT-2021-030); Anhui Provincial Key Laboratory of Bionic Sensing and Advanced Robot Technology

Citations: not cited yet (Europe PMC); 38 references in the paper

Abstract

We developed and evaluated a deep learning framework using susceptibility-weighted imaging signatures of the substantia nigra and adjacent structures to predict motor outcomes following subthalamic nucleus deep brain stimulation in Parkinson’s disease. This retrospective study included patients undergoing bilateral subthalamic nucleus deep brain stimulation, and motor response was defined as the percentage improvement in the original Unified Parkinson’s Disease Rating Scale Part III score from the preoperative medication-off condition to the 1-year postoperative stimulation-on/medication-off condition. Patients with at least 50% improvement were classified as optimal responders. A multi-task fusion network integrating prognostic classification and complementary regression learning was developed using preoperative susceptibility-weighted imaging data. In the initial 36-patient cohort, the proposed model outperformed baseline models and showed consistent 5-fold cross-validation performance. Substantia nigra and adjacent structures-centred sub-volumes showed better prognostic performance than non-substantia nigra and adjacent structures regions. In the expanded 60-patient cohort, the model achieved 88.3% accuracy. Additional analyses showed greater percentage improvement in the 39-item Parkinson’s Disease Questionnaire in optimal responders and no prognostic association between swallow-tail sign ratings and motor outcome. These findings suggest that preoperative susceptibility-weighted images covering the substantia nigra and adjacent structures may support prognostic prediction of subthalamic nucleus deep brain stimulation and may provide a practical decision-support tool for preoperative patient selection.

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

Repository

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

ceasorcai/PD

License: none: the authors keep all their rights

State: the link answers, verified on 26 September 2026

Evidence: files inventoried

Commit: 8d75c50f0ae0a640a7a3f7e9bc94457f96bd5cd7, 27 May 2026

Languages: Python (3)

Size: 3 files, 3 scripts

Software Heritage: not archived

Found in: “Data availability”

Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation

Tools: NumPy (2 files), PyTorch (2 files)

Availability: 1 check, the latest on 26 September 2026: the link answers

26 September 2026: the link answers

3 files

PD_model.py, Python, 561 lines, 2 matches
config.py, Python, 142 lines
main33.py, Python, 121 lines

At the source: github.com/ceasorcai/PD

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;
3 scripts, each with its path and the digest of its content;
2 matches between paragraphs of the paper and lines of the code (method lexical-v1);
neither the text of the paper nor the code itself.

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

Data

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

Data availability

The clinical and imaging data supporting the findings of this study are available from the corresponding author upon reasonable request, subject to institutional and ethical restrictions. The code used for model training, performance evaluation, statistical analysis, and DBS-related metric extraction is available at https://github.com/ceasorcai/PD. Clinical and imaging data are not publicly available because of institutional and ethical restrictions.

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

Versions

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

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 7 authors, 5 keywords, 4 funders, 38 references.

Cite

This paper

Xiong, C., Wang, K., Cheng, E., Sun, Z., Cai, B., Niu, C., & Song, B. (2026). Development and application of a multi-task fusion model using susceptibility-weighted imaging-based substantia nigra and adjacent structures for prognostic prediction of subthalamic nucleus deep brain stimulation in Parkinson's disease. Brain communications, 8(5), fcag333. https://doi.org/10.1093/braincomms/fcag333

BibTeX

@article{xiong2026development, author = {Xiong, Chi and Wang, Kun and Cheng, Erkang and Sun, Zhiyong and Cai, Bin and Niu, Chaoshi and Song, Bo}, title = {{Development and application of a multi-task fusion model using susceptibility-weighted imaging-based substantia nigra and adjacent structures for prognostic prediction of subthalamic nucleus deep brain stimulation in Parkinson's disease}}, journal = {Brain communications}, year = {2026}, month = sep, volume = {8}, number = {5}, pages = {fcag333}, publisher = {Oxford University Press}, issn = {2632-1297}, doi = {10.1093/braincomms/fcag333}, url = {https://doi.org/10.1093/braincomms/fcag333}, pmid = {42729974}, pmcid = {PMC13563298} }

RIS

TY - JOUR AU - Xiong, Chi AU - Wang, Kun AU - Cheng, Erkang AU - Sun, Zhiyong AU - Cai, Bin AU - Niu, Chaoshi AU - Song, Bo TI - Development and application of a multi-task fusion model using susceptibility-weighted imaging-based substantia nigra and adjacent structures for prognostic prediction of subthalamic nucleus deep brain stimulation in Parkinson's disease T2 - Brain communications J2 - Brain Commun PY - 2026 DA - 2026/09/11 VL - 8 IS - 5 SP - fcag333 SN - 2632-1297 PB - Oxford University Press DO - 10.1093/braincomms/fcag333 UR - https://doi.org/10.1093/braincomms/fcag333 LA - en ER -

CSL-JSON

{ "id": "10.1093/braincomms/fcag333", "type": "article-journal", "title": "Development and application of a multi-task fusion model using susceptibility-weighted imaging-based substantia nigra and adjacent structures for prognostic prediction of subthalamic nucleus deep brain stimulation in Parkinson's disease", "container-title": "Brain communications", "author": [ { "family": "Xiong", "given": "Chi" }, { "family": "Wang", "given": "Kun" }, { "family": "Cheng", "given": "Erkang" }, { "family": "Sun", "given": "Zhiyong" }, { "family": "Cai", "given": "Bin" }, { "family": "Niu", "given": "Chaoshi" }, { "family": "Song", "given": "Bo" } ], "container-title-short": "Brain Commun", "volume": "8", "issue": "5", "page": "fcag333", "DOI": "10.1093/braincomms/fcag333", "PMID": "42729974", "PMCID": "PMC13563298", "ISSN": "2632-1297", "publisher": "Oxford University Press", "URL": "https://doi.org/10.1093/braincomms/fcag333", "language": "en", "issued": { "date-parts": [ [ 2026, 9, 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.1162/imag.a.1241 [code]: Multispectral 7 Tesla MRI as a potential predictor of dopamine transporter deficiency in Parkinson's disease.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: PyTorch, NumPy, Parkinson's, structural MRI / diffusion, 1 reference
[2] doi:10.1038/s41598-026-61801-2 [code]: Detection of early-stage Parkinson's disease using wearable sensors at multiple body locations and convolutional neural networks.
Journal: Scientific reports
In common: PyTorch, NumPy, Parkinson's, clinical / translational, 1 reference
[3] doi:10.1038/s43856-026-01606-6 [code]: Validation of remote multimodal AI screening for Parkinson disease across diverse settings.
Journal: Communications medicine
In common: PyTorch, NumPy, Parkinson's, clinical / translational, 1 reference
[4] doi:10.1038/s41746-026-02828-7: Age, emotional burden and deep brain stimulation electrode location shape Parkinson's disease quality of life.
Journal: NPJ digital medicine
In common: Parkinson's, 2 references
[5] doi:10.1038/s41531-026-01531-4 [code]: Inconsistent subthalamic local field potential beta activity amid in- and antiphasic neuronal bursts.
Journal: NPJ Parkinson's disease
In common: NumPy, Parkinson's, clinical / translational, 1 reference
[6] doi:10.1038/s41591-026-04434-2 [code]: Adaptive deep brain stimulation for dynamic gait control in Parkinson's disease: a randomized feasibility trial.
Journal: Nature medicine
In common: NumPy, Parkinson's, clinical / translational, 1 reference
[7] doi:10.1002/mds.70355 [code]: Gray Matter Microstructure Measured Using Diffusion Imaging as a Biomarker of Severity in Lewy Body Diseases.
Journal: Movement disorders : official journal of the Movement Disorder Society
In common: NumPy, Parkinson's, structural MRI / diffusion, clinical / translational, 1 reference
[8] doi:10.1093/braincomms/fcag328 [code]: Subthalamic stimulation modulates working memory-related cortical dynamics in Parkinson's disease.
Journal: Brain communications
In common: NumPy, Parkinson's, 1 reference
[9] doi:10.1371/journal.pone.0348957 [code]: Steps against the burden of Parkinson's disease (StepuP): Protocol of a randomized controlled trial elucidating the biomechanical and neurophysiological mechanisms of a speed dependent treadmill training intervention.
Journal: PloS one
In common: NumPy, Parkinson's, clinical / translational, 1 reference
[10] doi:10.1002/alz.71649 [code]: Postmortem brain MRI reveals differential associations of subcortical and limbic volumes with cortical thinning and neurodegenerative pathologies.
Journal: Alzheimer's & dementia : the journal of the Alzheimer's Association
In common: PyTorch, NumPy, Parkinson's, structural MRI / diffusion

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.