diff --git a/CHANGELOG.md b/CHANGELOG.md
index 467ca28..b6d94f6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,9 @@
+# task_predict_modality 0.1.1
+
+## NEW FUNCTIONALITY
+
+* Added Simple MLP method (PR #3).
+
 # task_predict_modality 0.1.0
 
 Initial release after migrating the codebase.
diff --git a/README.md b/README.md
index 00f01fc..11451c0 100644
--- a/README.md
+++ b/README.md
@@ -41,6 +41,8 @@ data shows that this is not trivial.
 | Kaiwen Deng        | contributor        |
 | Louise Deconinck   | author             |
 | Robrecht Cannoodt  | author, maintainer |
+| Xueer Chen         | contributor        |
+| Jiwei Liu          | contributor        |
 
 ## API
 
diff --git a/_viash.yaml b/_viash.yaml
index 1584b62..6952bf5 100644
--- a/_viash.yaml
+++ b/_viash.yaml
@@ -73,7 +73,18 @@ authors:
     info:
       github: rcannood
       orcid: "0000-0003-3641-729X"
-    
+  - name: Xueer Chen
+    roles: [ contributor ]
+    info:
+      github: xuerchen
+      email: xc2579@columbia.edu
+  - name: Jiwei Liu
+    roles: [ contributor ]
+    info:
+      github: daxiongshu
+      email: jiweil@nvidia.com
+      orcid: "0000-0002-8799-9763"
+
 links:
   issue_tracker: https://github.com/openproblems-bio/task_predict_modality/issues
   repository: https://github.com/openproblems-bio/task_predict_modality
@@ -84,8 +95,8 @@ info:
 
   test_resources:
     - type: s3
-      path: s3://openproblems-data/resources_test/common/
-      dest: resources_test/common
+      path: s3://openproblems-data/resources_test/common/openproblems_neurips2021
+      dest: resources_test/common/openproblems_neurips2021
     - type: s3
       path: s3://openproblems-data/resources_test/task_predict_modality/
       dest: resources_test/task_predict_modality
diff --git a/common b/common
index 65e05af..b505fd6 160000
--- a/common
+++ b/common
@@ -1 +1 @@
-Subproject commit 65e05af68a11ee87853fcf7a3c6b579001f21abe
+Subproject commit b505fd616154190db807490589cb42b5e8b32192
diff --git a/scripts/create_datasets/test_resources.sh b/scripts/create_datasets/test_resources.sh
index a913e88..d869d00 100755
--- a/scripts/create_datasets/test_resources.sh
+++ b/scripts/create_datasets/test_resources.sh
@@ -29,31 +29,25 @@ nextflow run . \
 
 echo "Run one method"
 
-viash run src/methods/knnr_py/config.vsh.yaml -- \
-  --input_train_mod1 $OUTPUT_DIR/openproblems_neurips2021/bmmc_cite/normal/train_mod1.h5ad \
-  --input_train_mod2 $OUTPUT_DIR/openproblems_neurips2021/bmmc_cite/normal/train_mod2.h5ad \
-  --input_test_mod1 $OUTPUT_DIR/openproblems_neurips2021/bmmc_cite/normal/test_mod1.h5ad \
-  --output $OUTPUT_DIR/openproblems_neurips2021/bmmc_cite/normal/prediction.h5ad
-
-viash run src/methods/knnr_py/config.vsh.yaml -- \
-  --input_train_mod1 $OUTPUT_DIR//openproblems_neurips2021/bmmc_cite/swap/train_mod1.h5ad \
-  --input_train_mod2 $OUTPUT_DIR//openproblems_neurips2021/bmmc_cite/swap/train_mod2.h5ad \
-  --input_test_mod1 $OUTPUT_DIR//openproblems_neurips2021/bmmc_cite/swap/test_mod1.h5ad \
-  --output $OUTPUT_DIR//openproblems_neurips2021/bmmc_cite/swap/prediction.h5ad
-
-viash run src/methods/knnr_py/config.vsh.yaml -- \
-  --input_train_mod1 $OUTPUT_DIR/openproblems_neurips2021/bmmc_multiome/normal/train_mod1.h5ad \
-  --input_train_mod2 $OUTPUT_DIR/openproblems_neurips2021/bmmc_multiome/normal/train_mod2.h5ad \
-  --input_test_mod1 $OUTPUT_DIR/openproblems_neurips2021/bmmc_multiome/normal/test_mod1.h5ad \
-  --output $OUTPUT_DIR/openproblems_neurips2021/bmmc_multiome/normal/prediction.h5ad
-
-viash run src/methods/knnr_py/config.vsh.yaml -- \
-  --input_train_mod1 $OUTPUT_DIR/openproblems_neurips2021/bmmc_multiome/swap/train_mod1.h5ad \
-  --input_train_mod2 $OUTPUT_DIR/openproblems_neurips2021/bmmc_multiome/swap/train_mod2.h5ad \
-  --input_test_mod1 $OUTPUT_DIR/openproblems_neurips2021/bmmc_multiome/swap/test_mod1.h5ad \
-  --output $OUTPUT_DIR/openproblems_neurips2021/bmmc_multiome/swap/prediction.h5ad
+for name in bmmc_cite/normal bmmc_cite/swap bmmc_multiome/normal bmmc_multiome/swap; do
+  viash run src/methods/knnr_py/config.vsh.yaml -- \
+    --input_train_mod1 $OUTPUT_DIR/openproblems_neurips2021/$name/train_mod1.h5ad \
+    --input_train_mod2 $OUTPUT_DIR/openproblems_neurips2021/$name/train_mod2.h5ad \
+    --input_test_mod1 $OUTPUT_DIR/openproblems_neurips2021/$name/test_mod1.h5ad \
+    --output $OUTPUT_DIR/openproblems_neurips2021/$name/prediction.h5ad
+
+  # pre-train simple_mlp
+  rm -r $OUTPUT_DIR/openproblems_neurips2021/$name/models/simple_mlp/
+  mkdir -p $OUTPUT_DIR/openproblems_neurips2021/$name/models/simple_mlp/
+  viash run src/methods/simple_mlp/train/config.vsh.yaml -- \
+    --input_train_mod1 $OUTPUT_DIR/openproblems_neurips2021/$name/train_mod1.h5ad \
+    --input_train_mod2 $OUTPUT_DIR/openproblems_neurips2021/$name/train_mod2.h5ad \
+    --input_test_mod1 $OUTPUT_DIR/openproblems_neurips2021/$name/test_mod1.h5ad \
+    --output $OUTPUT_DIR/openproblems_neurips2021/$name/models/simple_mlp/
+done
 
 # only run this if you have access to the openproblems-data bucket
 aws s3 sync --profile op \
-  "$DATASET_DIR" s3://openproblems-data/resources_test/task_predict_modality \
+  resources_test/task_predict_modality \
+  s3://openproblems-data/resources_test/task_predict_modality \
   --delete --dryrun
diff --git a/src/methods/simple_mlp/predict/config.vsh.yaml b/src/methods/simple_mlp/predict/config.vsh.yaml
new file mode 100644
index 0000000..4fc47e0
--- /dev/null
+++ b/src/methods/simple_mlp/predict/config.vsh.yaml
@@ -0,0 +1,28 @@
+__merge__: /src/api/comp_method_predict.yaml
+name: simplemlp_predict
+
+info:
+  test_setup:
+    with_model:
+      input_model: resources_test/task_predict_modality/openproblems_neurips2021/bmmc_cite/swap/models/simple_mlp
+
+resources:
+  - type: python_script
+    path: script.py
+  - path: ../resources/
+
+engines:
+  - type: docker
+    image: openproblems/base_pytorch_nvidia:1.0.0
+    # run_args: ["--gpus all --ipc=host"]
+    setup:
+      - type: python
+        pypi:
+          - scikit-learn
+          - scanpy
+          - pytorch-lightning
+runners:
+  - type: executable
+  - type: nextflow
+    directives:
+      label: [highmem, hightime, midcpu, gpu, highsharedmem]
diff --git a/src/methods/simple_mlp/predict/script.py b/src/methods/simple_mlp/predict/script.py
new file mode 100644
index 0000000..f95aada
--- /dev/null
+++ b/src/methods/simple_mlp/predict/script.py
@@ -0,0 +1,112 @@
+from glob import glob
+import sys
+import numpy as np
+from scipy.sparse import csc_matrix
+import anndata as ad
+import torch
+from torch.utils.data import TensorDataset,DataLoader
+
+## VIASH START
+par = {
+    'input_train_mod1': 'resources_test/task_predict_modality/openproblems_neurips2021/bmmc_multiome/swap/train_mod1.h5ad',
+    'input_train_mod2': 'resources_test/task_predict_modality/openproblems_neurips2021/bmmc_multiome/swap/train_mod2.h5ad',
+    'input_test_mod1': 'resources_test/task_predict_modality/openproblems_neurips2021/bmmc_multiome/swap/test_mod1.h5ad',
+    'input_model': 'output/model',
+    'output': 'output/prediction'
+}
+meta = {
+    'config': 'target/executable/methods/simplemlp_predict/.config.vsh.yaml',
+    'resources_dir': 'target/executable/methods/simplemlp_predict',
+    'cpus': 10
+}
+## VIASH END
+
+resources_dir = f"{meta['resources_dir']}/resources"
+sys.path.append(resources_dir)
+from models import MLP
+import utils
+
+def _predict(model,dl):
+    if torch.cuda.is_available():
+        model = model.cuda()
+    else:
+        model = model.cpu()
+    model.eval()
+    yps = []
+    for x in dl:
+        with torch.no_grad():
+            if torch.cuda.is_available():
+                x0 = x[0].cuda()
+            else:
+                x0 = x[0].cpu()
+            yp = model(x0)
+            yps.append(yp.detach().cpu().numpy())
+    yp = np.vstack(yps)
+    return yp
+
+
+print('Load data', flush=True)
+input_train_mod2 = ad.read_h5ad(par['input_train_mod2'])
+input_test_mod1 = ad.read_h5ad(par['input_test_mod1'])
+
+# determine variables
+mod_1 = input_test_mod1.uns['modality']
+mod_2 = input_train_mod2.uns['modality']
+
+task = f'{mod_1}2{mod_2}'
+
+print('Load ymean', flush=True)
+ymean_path = f"{par['input_model']}/{task}_ymean.npy"
+ymean = np.load(ymean_path)
+
+print('Start predict', flush=True)
+if task == 'GEX2ATAC':
+    y_pred = ymean*np.ones([input_test_mod1.n_obs, input_test_mod1.n_vars])
+else:
+    folds = [0, 1, 2]
+
+    ymean = torch.from_numpy(ymean).float()
+    yaml_path=f"{resources_dir}/yaml/mlp_{task}.yaml"
+    config = utils.load_yaml(yaml_path)
+    X = input_test_mod1.layers["normalized"].toarray()
+    X = torch.from_numpy(X).float()
+
+    te_ds = TensorDataset(X)
+
+    yp = 0
+    for fold in folds:
+        # load_path = f"{par['input_model']}/{task}_fold_{fold}/version_0/checkpoints/*"
+        load_path = f"{par['input_model']}/{task}_fold_{fold}/**.ckpt"
+        print(load_path)
+        ckpt = glob(load_path)[0]
+        model_inf = MLP.load_from_checkpoint(
+            ckpt,
+            in_dim=X.shape[1],
+            out_dim=input_test_mod1.n_vars,
+            ymean=ymean,
+            config=config
+        )
+        te_loader = DataLoader(
+            te_ds,
+            batch_size=config.batch_size,
+            num_workers=0,
+            shuffle=False,
+            drop_last=False
+        )
+        yp = yp + _predict(model_inf, te_loader)
+
+    y_pred = yp/len(folds)
+
+y_pred = csc_matrix(y_pred)
+
+adata = ad.AnnData(
+    layers={"normalized": y_pred},
+    shape=y_pred.shape,
+    uns={
+        'dataset_id': input_test_mod1.uns['dataset_id'],
+        'method_id': meta['functionality_name'],
+    },
+)
+
+print('Write data', flush=True)
+adata.write_h5ad(par['output'], compression = "gzip") 
diff --git a/src/methods/simple_mlp/resources/models.py b/src/methods/simple_mlp/resources/models.py
new file mode 100644
index 0000000..cf3af25
--- /dev/null
+++ b/src/methods/simple_mlp/resources/models.py
@@ -0,0 +1,71 @@
+import torch
+import pytorch_lightning as pl
+import torch.nn as nn
+import torch.nn.functional as F
+
+class MLP(pl.LightningModule):
+    def __init__(self,in_dim,out_dim,ymean,config):
+        super(MLP, self).__init__()
+        if torch.cuda.is_available():
+            self.ymean = ymean.cuda()
+        else:
+            self.ymean = ymean
+        H1 = config.H1
+        H2 = config.H2
+        p = config.dropout
+        self.config = config
+        self.fc1 = nn.Linear(in_dim, H1)
+        self.fc2 = nn.Linear(H1,H2)
+        self.fc3 = nn.Linear(H1+H2, out_dim)
+        self.dp2 = nn.Dropout(p=p)
+
+    def forward(self, x):
+        x0 = x
+        x1 = F.relu(self.fc1(x))
+        x1 = self.dp2(x1)
+        x = F.relu(self.fc2(x1))
+        x = torch.cat([x,x1],dim=1)
+        x = self.fc3(x)
+        x = self.apply_mask(x)
+        return x
+
+    def apply_mask(self,yp):
+        tmp = torch.ones_like(yp).float()*self.ymean
+        mask = tmp<self.config.threshold
+        mask = mask.float()
+        return yp*(1-mask) + tmp*mask
+
+    def training_step(self, batch, batch_nb):
+        x,y = batch
+        yp = self(x)
+        criterion = nn.MSELoss()
+        loss = criterion(yp, y)
+        self.log('train_loss', loss, prog_bar=True)
+        return loss
+
+    def validation_step(self, batch, batch_idx):
+        x,y = batch
+        yp = self(x)
+        criterion = nn.MSELoss()
+        loss = criterion(yp, y)
+        self.log('valid_RMSE', loss**0.5, prog_bar=True)
+        return loss
+
+    def predict_step(self, batch, batch_idx):
+        if len(batch) == 2:
+            x,_ = batch
+        else:
+            x = batch
+        return self(x)
+
+    def configure_optimizers(self):
+        lr = self.config.lr
+        wd = float(self.config.wd)
+        adam = torch.optim.Adam(self.parameters(), lr=lr, weight_decay=wd)
+        if self.config.lr_schedule == 'adam':
+            return adam
+        elif self.config.lr_schedule == 'adam_cosin':
+            slr = torch.optim.lr_scheduler.CosineAnnealingLR(adam, self.config.epochs)
+            return [adam], [slr]
+        else:
+            assert 0
diff --git a/src/methods/simple_mlp/resources/utils.py b/src/methods/simple_mlp/resources/utils.py
new file mode 100644
index 0000000..d001b8e
--- /dev/null
+++ b/src/methods/simple_mlp/resources/utils.py
@@ -0,0 +1,37 @@
+import yaml
+from collections import namedtuple
+
+
+def to_site_donor(data):
+    df = data.obs['batch'].copy().to_frame().reset_index()
+    df.columns = ['index','batch']
+    df['site'] = df['batch'].apply(lambda x: x[:2])
+    df['donor'] = df['batch'].apply(lambda x: x[2:]) 
+    return df
+
+
+def split(tr1, tr2, fold):
+    df = to_site_donor(tr1) 
+    mask = df['site'] == f's{fold+1}'
+    maskr = ~mask
+
+    Xt = tr1[mask].layers["normalized"].toarray()
+    X = tr1[maskr].layers["normalized"].toarray()
+
+    yt = tr2[mask].layers["normalized"].toarray()
+    y = tr2[maskr].layers["normalized"].toarray()
+
+    print(f"{X.shape}, {y.shape}, {Xt.shape}, {yt.shape}")
+
+    return X,y,Xt,yt
+
+
+def load_yaml(path):
+    with open(path) as f:
+        x = yaml.safe_load(f)
+    res = {}
+    for i in x:
+        res[i] = x[i]['value']
+    config = namedtuple('Config', res.keys())(**res)
+    print(config)
+    return config
diff --git a/src/methods/simple_mlp/resources/yaml/mlp_ADT2GEX.yaml b/src/methods/simple_mlp/resources/yaml/mlp_ADT2GEX.yaml
new file mode 100644
index 0000000..e3a0b73
--- /dev/null
+++ b/src/methods/simple_mlp/resources/yaml/mlp_ADT2GEX.yaml
@@ -0,0 +1,29 @@
+
+# sample config defaults file
+epochs:
+  desc: Number of epochs to train over
+  value: 10
+batch_size:
+  desc: Size of each mini-batch
+  value: 512
+H1:
+  desc: Number of hidden neurons in 1st layer of MLP
+  value: 256
+H2:
+  desc: Number of hidden neurons in 2nd layer of MLP
+  value: 128
+dropout:
+  desc: probs of zeroing values
+  value: 0
+lr:
+  desc: learning rate
+  value: 0.001
+wd:
+  desc: weight decay
+  value: 1e-5
+threshold:
+  desc: threshold to set values to zero
+  value: 0
+lr_schedule:
+  desc: learning rate scheduler
+  value: adam 
diff --git a/src/methods/simple_mlp/resources/yaml/mlp_ATAC2GEX.yaml b/src/methods/simple_mlp/resources/yaml/mlp_ATAC2GEX.yaml
new file mode 100644
index 0000000..486338d
--- /dev/null
+++ b/src/methods/simple_mlp/resources/yaml/mlp_ATAC2GEX.yaml
@@ -0,0 +1,28 @@
+# sample config defaults file
+epochs:
+  desc: Number of epochs to train over
+  value: 10
+batch_size:
+  desc: Size of each mini-batch
+  value: 512
+H1:
+  desc: Number of hidden neurons in 1st layer of MLP
+  value: 256
+H2:
+  desc: Number of hidden neurons in 2nd layer of MLP
+  value: 128
+dropout:
+  desc: probs of zeroing values
+  value: 0.5
+lr:
+  desc: learning rate
+  value: 0.001
+wd:
+  desc: weight decay
+  value: 1e-5
+threshold:
+  desc: threshold to set values to zero
+  value: 0
+lr_schedule:
+  desc: learning rate scheduler
+  value: adam 
diff --git a/src/methods/simple_mlp/resources/yaml/mlp_GEX2ADT.yaml b/src/methods/simple_mlp/resources/yaml/mlp_GEX2ADT.yaml
new file mode 100644
index 0000000..27a3bdc
--- /dev/null
+++ b/src/methods/simple_mlp/resources/yaml/mlp_GEX2ADT.yaml
@@ -0,0 +1,28 @@
+# sample config defaults file
+epochs:
+  desc: Number of epochs to train over
+  value: 10 
+batch_size:
+  desc: Size of each mini-batch
+  value: 512
+H1:
+  desc: Number of hidden neurons in 1st layer of MLP
+  value: 1024 
+H2:
+  desc: Number of hidden neurons in 2nd layer of MLP
+  value: 512
+dropout:
+  desc: probs of zeroing values
+  value: 0
+lr:
+  desc: learning rate
+  value: 0.001
+wd:
+  desc: weight decay
+  value: 1e-5
+threshold:
+  desc: threshold to set values to zero
+  value: 0.05
+lr_schedule:
+  desc: learning rate scheduler
+  value: adam_cosin
diff --git a/src/methods/simple_mlp/run/config.vsh.yaml b/src/methods/simple_mlp/run/config.vsh.yaml
new file mode 100644
index 0000000..53a68c2
--- /dev/null
+++ b/src/methods/simple_mlp/run/config.vsh.yaml
@@ -0,0 +1,27 @@
+__merge__: /src/api/wf_method.yaml
+name: simple_mlp
+label: Simple MLP
+summary: Ensemble of MLPs trained on different sites (team AXX)
+description: |
+  This folder contains the AXX solution to the OpenProblems-NeurIPS2021 Single-Cell Multimodal Data Integration.
+  Team took the 4th place of the modality prediction task in terms of overall ranking of 4 subtasks: namely GEX
+  to ADT, ADT to GEX, GEX to ATAC and ATAC to GEX. Specifically, our methods ranked 3rd in GEX to ATAC and 4th
+  in GEX to ADT. More details about the task can be found in the
+  [competition webpage](https://openproblems.bio/events/2021-09_neurips/documentation/about_tasks/task1_modality_prediction).
+references:
+  doi: 10.1101/2022.04.11.487796
+links:
+  documentation: https://github.com/openproblems-bio/neurips2021_multimodal_topmethods/tree/main/src/predict_modality/methods/AXX
+  repository: https://github.com/openproblems-bio/neurips2021_multimodal_topmethods/tree/main/src/predict_modality/methods/AXX
+info:
+  preferred_normalization: log_cp10k
+  competition_submission_id: 170812
+resources:
+  - path: main.nf
+    type: nextflow_script
+    entrypoint: run_wf
+dependencies:
+  - name: methods/simplemlp_train
+  - name: methods/simplemlp_predict
+runners:
+  - type: nextflow
diff --git a/src/methods/simple_mlp/run/main.nf b/src/methods/simple_mlp/run/main.nf
new file mode 100644
index 0000000..595a241
--- /dev/null
+++ b/src/methods/simple_mlp/run/main.nf
@@ -0,0 +1,21 @@
+workflow run_wf {
+  take: input_ch
+  main:
+  output_ch = input_ch
+
+    | simplemlp_train.run(
+      fromState: ["input_train_mod1", "input_train_mod2"],
+      toState: ["input_model": "output"]
+    )
+
+    | simplemlp_predict.run(
+      fromState: ["input_train_mod2", "input_test_mod1", "input_model", "input_transform"],
+      toState: ["output": "output"]
+    )
+
+    | map { tup ->
+      [tup[0], [output: tup[1].output]]
+    }
+
+  emit: output_ch
+}
diff --git a/src/methods/simple_mlp/train/config.vsh.yaml b/src/methods/simple_mlp/train/config.vsh.yaml
new file mode 100644
index 0000000..3a78e4a
--- /dev/null
+++ b/src/methods/simple_mlp/train/config.vsh.yaml
@@ -0,0 +1,21 @@
+__merge__: /src/api/comp_method_train.yaml
+name: simplemlp_train
+resources:
+  - type: python_script
+    path: script.py
+  - path: ../resources/
+engines:
+  - type: docker
+    image: openproblems/base_pytorch_nvidia:1.0.0
+    setup:
+      - type: python
+        pypi:
+          - scikit-learn
+          - scanpy
+          - pytorch-lightning
+runners:
+  - type: executable
+    # docker_run_args: ["--gpus all --ipc=host"]
+  - type: nextflow
+    directives:
+      label: [highmem, hightime, midcpu, gpu, highsharedmem]
diff --git a/src/methods/simple_mlp/train/script.py b/src/methods/simple_mlp/train/script.py
new file mode 100644
index 0000000..1fbd646
--- /dev/null
+++ b/src/methods/simple_mlp/train/script.py
@@ -0,0 +1,154 @@
+import os
+import math
+import logging
+from pathlib import Path
+
+import anndata as ad
+import numpy as np
+
+import torch
+import pytorch_lightning as pl
+from torch.utils.data import TensorDataset, DataLoader
+from pytorch_lightning.callbacks import ModelCheckpoint
+from pytorch_lightning.loggers import TensorBoardLogger,WandbLogger
+
+logging.basicConfig(level=logging.INFO)
+
+## VIASH START
+par = {
+    'input_train_mod1': 'resources_test/task_predict_modality/openproblems_neurips2021/bmmc_multiome/swap/train_mod1.h5ad',
+    'input_train_mod2': 'resources_test/task_predict_modality/openproblems_neurips2021/bmmc_multiome/swap/train_mod2.h5ad',
+    'input_test_mod1': 'resources_test/task_predict_modality/openproblems_neurips2021/bmmc_multiome/swap/test_mod1.h5ad',
+    'output': 'output/model'
+}
+meta = {
+    'resources_dir': 'src/tasks/predict_modality/methods/simple_mlp',
+    'cpus': 10
+}
+## VIASH END
+
+resources_dir = f"{meta['resources_dir']}/resources"
+
+import sys
+sys.path.append(resources_dir)
+from models import MLP
+import utils
+
+def _train(X, y, Xt, yt, logger, config, num_workers):
+
+    X = torch.from_numpy(X).float()
+    y = torch.from_numpy(y).float()
+    ymean = torch.mean(y, dim=0, keepdim=True)
+
+    tr_ds = TensorDataset(X,y)
+    tr_loader = DataLoader(
+        tr_ds,
+        batch_size=config.batch_size,
+        num_workers=num_workers,
+        shuffle=True,
+        drop_last=True
+    )
+
+    Xt = torch.from_numpy(Xt).float()
+    yt = torch.from_numpy(yt).float()
+    te_ds = TensorDataset(Xt,yt)
+    te_loader = DataLoader(
+        te_ds,
+        batch_size=config.batch_size,
+        num_workers=num_workers,
+        shuffle=False,
+        drop_last=False
+    )
+
+    checkpoint_callback = ModelCheckpoint(
+        monitor='valid_RMSE',
+        dirpath=logger.save_dir,
+        save_top_k=1,
+    )
+
+    trainer = pl.Trainer(
+        devices="auto",
+        enable_checkpointing=True,
+        logger=logger, 
+        max_epochs=config.epochs, 
+        callbacks=[checkpoint_callback],
+        default_root_dir=logger.save_dir,
+        # progress_bar_refresh_rate=5
+    )
+
+    net = MLP(X.shape[1], y.shape[1], ymean, config)
+    trainer.fit(net, tr_loader, te_loader)
+
+    yp = trainer.predict(net, te_loader, ckpt_path='best')
+    yp = torch.cat(yp, dim=0)
+
+    score = ((yp-yt)**2).mean()**0.5
+    print(f"VALID RMSE {score:.3f}")
+    del trainer
+    return score,yp.detach().numpy()
+
+
+
+input_train_mod1 = ad.read_h5ad(par['input_train_mod1'])
+input_train_mod2 = ad.read_h5ad(par['input_train_mod2'])
+
+mod_1 = input_train_mod1.uns["modality"]
+mod_2 = input_train_mod2.uns["modality"]
+
+task = f'{mod_1}2{mod_2}'
+yaml_path = f'{resources_dir}/yaml/mlp_{task}.yaml'
+
+obs_info = utils.to_site_donor(input_train_mod1)
+# TODO: if we want this method to work for other datasets, resolve dependence on site notation
+sites = obs_info.site.unique()
+
+os.makedirs(par['output'], exist_ok=True)
+
+print('Compute ymean', flush=True)
+ymean = np.asarray(input_train_mod2.layers["normalized"].mean(axis=0))
+path = f"{par['output']}/{task}_ymean.npy"
+np.save(path, ymean)
+
+
+if task == "GEX2ATAC":
+    logging.info(f"No training required for this task ({task}).")
+    sys.exit(0)
+
+if not os.path.exists(yaml_path):
+    logging.error(f"No configuration file found for task '{task}'")
+    sys.exit(1)
+
+yaml_path = f'{resources_dir}/yaml/mlp_{task}.yaml'
+yps = []
+scores = []
+
+msgs = {}
+# TODO: if we want this method to work for other datasets, dont use hardcoded range
+for fold in range(3):
+
+    run_name = f"{task}_fold_{fold}"
+    save_path = f"{par['output']}/{run_name}"
+    num_workers = meta["cpus"] or 0
+
+    Path(save_path).mkdir(parents=True, exist_ok=True)   
+
+    X,y,Xt,yt = utils.split(input_train_mod1, input_train_mod2, fold)
+
+    logger = TensorBoardLogger(save_path, name='') 
+
+    config = utils.load_yaml(yaml_path)
+
+    if config.batch_size > X.shape[0]:
+        config = config._replace(batch_size=math.ceil(X.shape[0] / 2))
+
+    score, yp = _train(X, y, Xt, yt, logger, config, num_workers)
+    yps.append(yp)
+    scores.append(score)
+    msg = f"{task} Fold {fold} RMSE {score:.3f}"
+    msgs[f'Fold {fold}'] = f'{score:.3f}'
+    print(msg)
+
+yp = np.concatenate(yps)
+score = np.mean(scores)
+msgs['Overall'] = f'{score:.3f}'
+print('Overall', f'{score:.3f}')
diff --git a/src/workflows/run_benchmark/config.vsh.yaml b/src/workflows/run_benchmark/config.vsh.yaml
index e225f2c..75a7429 100644
--- a/src/workflows/run_benchmark/config.vsh.yaml
+++ b/src/workflows/run_benchmark/config.vsh.yaml
@@ -71,6 +71,7 @@ dependencies:
   - name: methods/lm
   - name: methods/guanlab_dengkw_pm
   - name: methods/novel
+  - name: methods/simple_mlp
   - name: metrics/correlation
   - name: metrics/mse
 runners:
diff --git a/src/workflows/run_benchmark/main.nf b/src/workflows/run_benchmark/main.nf
index 4038e0c..a032696 100644
--- a/src/workflows/run_benchmark/main.nf
+++ b/src/workflows/run_benchmark/main.nf
@@ -15,7 +15,8 @@ methods = [
   knnr_r,
   lm,
   guanlab_dengkw_pm,
-  novel
+  novel,
+  simple_mlp
 ]
 
 // construct list of metrics