Variability in interpolated channels between RANSAC runs?

[a-hurst]

I've been using PyPREP to set up an EEG preprocessing pipeline for a project I'm working on (~40 minute sessions, 1000Hz, 32 channels), and for most of it I've been using a fixed random seed. However, I got curious about the variability in RANSAC between runs with random seeds, so I went through my full dataset a few times with a script, writing out the names and numbers of initial bad, interpolated, and remaining bad channels per session to a .csv. On some files, I saw differences as big as 4 channels between two consecutive runs. Overall, there was at least one difference in interpolated channels on a majority of the 85 files.

Given that RANSAC is based on thresholds and random sample consensus, I'm not necessarily surprised by this, but I was wondering if there were any parameters I could adjust to make RANSAC more stable between runs (presumably at the cost of speed/RAM)?

[sappelhoff]

Hi @a-hurst that sounds like too much variation to me, are you sure that it's not just due to that particular dataset?

If it's also the case for other datasets, do you find the same variability in the original PREP (matlab/EEGLAB)?

Finally, there is another RANSAC implementation in https://github.com/autoreject/autoreject --> perhaps you could run all steps of PYPREP except RANSAC, then run the autoreject RANSAC and append the results to pyprep, and then finish running pyprep, pretending the autoreject ransac was the pyprep ransac ... 🙂 sounds like overkill, but I am trying to find a potential bug.

[a-hurst]

It very well could be my dataset being wonky, but then again I guess there wouldn’t be much need for RANSAC in a world without wonky datasets. Is there an open EEG dataset you trust to be relatively normal that you’d like me to run the same tests on? My script would be easily adapted to any BIDS dataset.

I have no serious MATLAB experience so I’m probably not the best person to check the results against that, but I can certainly try subbing in autoreject’s implementation in my script! I’m calling all the PREP functions separately anyway instead of using the Pipeline object, so it wouldn’t be much effort.

[yjmantilla]

I can confirm having seen that issue in a local dataset. I do know the RANSAC of matlab has a fixed seed but I remember trying to get rid of that seed and it still gave more consistent results than the pyprep implementation. Nevertheless I did those tests a long time ago so I don't quite remember all the details so take that with a pinch of salt.

Im really curious of knowing if autoreject's implementation shows the same variability because if it does what really mesmerizes me is what the matlab's ransac does to be so consistent.

This was also a bit discussed in #21 (not in the main big post but on the following comments).

[a-hurst]

@sappelhoff Okay, I found an open EEG dataset I thought would be a good test candidate, and hooooo boy there is quite a bit of variation in rejected channels between runs. I'm not sure if some of this is the lower sample rate (256 Hz) or higher channel count (64ch) vs my own dataset (32ch @ 1000 Hz), but PyPREP really has issues with it.

I've only run it twice so far, and only on the first session for the first 10 ids (running it locally so CPU/RAM consumption is an issue), but I've attached the output files from the two runs as well as a CSV detailing the differences between the two runs. Note that this latter file is counting and reporting all channels that were different between the two runs, not the differences in numbers of channels flagged per run:
ransac_compare.zip

As a quick summary of the data:

• Mean difference in initial bad channels between runs: 2.3 (range: 0 - 6)
• Mean difference in interpolated channels between runs: 14.9 (range: 6 - 29)
• Mean difference in remaining bad channels between runs: 12.3 (range: 4 - 26)

The data doesn't even look particularly bad: apart from a few seconds of major noise around 250 seconds in, the data for sub-007 look extremely clean and the only channel flagged as bad by RANSAC on either run was A30. After robust referencing, however, that somehow balloons to 34 (!!!) interpolated channels by the end of one of my runs.

Here's my code for running the pipeline and logging the results:

### Import required libraries #################################################

import os
import csv
import shutil
import binascii

import mne
import numpy as np

from mne_bids import BIDSPath, read_raw_bids
from pyprep.prep_pipeline import PrepPipeline
from pyprep.find_noisy_channels import NoisyChannels
from pyprep.removeTrend import removeTrend
from pyprep.reference import Reference


### Set general parameters ####################################################

mne.set_log_level("WARNING")
seed = None

session = '01'
task = 'meditation'
datatype = 'eeg'
bids_root = 'ds001787'
info_file = 'prep_info.csv'

ch_non_eeg = [
    'EXG1', 'EXG2', 'EXG3', 'EXG4', 'EXG5', 'EXG6', 'EXG7', 'EXG8',
    'GSR1', 'GSR2',
    'Erg1', 'Erg2',
    'Resp', 'Plet', 'Temp'
]
ch_type_overrides = {}
for ch in ch_non_eeg:
    ch_type_overrides[ch] = 'misc'


def preprocess_eeg(id_num, random_seed=None):
    
    # Set important variables
    bids_path = BIDSPath(id_num, task=task, datatype=datatype, root=bids_root,
                         session=session)
    if not random_seed:
        random_seed = int(binascii.b2a_hex(os.urandom(4)), 16)
    id_info = {"id": id_num, "random_seed": random_seed}
    

    ### Load and prepare EEG data #############################################
    
    header = "### Processing sub-{0} (seed: {1}) ###".format(id_num, random_seed)
    print("\n" + "#" * len(header))
    print(header)
    print("#" * len(header) + "\n")

    # Load EEG data
    raw = read_raw_bids(bids_path, verbose=True)
    raw.set_channel_types(ch_type_overrides)

    # Add a montage to the data
    montage_kind = "biosemi128"
    montage = mne.channels.make_standard_montage(montage_kind)
    mne.datasets.eegbci.standardize(raw)
    raw.set_montage(montage)

    # Extract some info
    eeg_index = mne.pick_types(raw.info, eeg=True, eog=False, meg=False)
    ch_names = raw.info["ch_names"]
    ch_names_eeg = list(np.asarray(ch_names)[eeg_index])
    sample_rate = raw.info["sfreq"]

    # Make a copy of the data
    raw_copy = raw.copy()
    raw_copy.load_data()

    # Prepare copy of raw data for PREP
    raw_copy.pick_types(eeg=True)


    ### Run components of PREP manually #######################################
    
    print("\n\n=== Performing CleanLine... ===")
    
    # Try to remove line noise using CleanLine approach
    linenoise = np.arange(60, sample_rate / 2, 60)
    EEG_raw = raw_copy.get_data() * 1e6
    EEG_new = removeTrend(EEG_raw, sample_rate=sample_rate)
    EEG_clean = mne.filter.notch_filter(
        EEG_new,
        Fs=sample_rate,
        freqs=linenoise,
        filter_length="10s",
        method="spectrum_fit",
        mt_bandwidth=2,
        p_value=0.01,
    )
    EEG_final = EEG_raw - EEG_new + EEG_clean
    raw_copy._data = EEG_final * 1e-6
    del linenoise, EEG_raw, EEG_new, EEG_clean, EEG_final
    
    # Perform robust re-referencing
    prep_params = {
        "ref_chs": ch_names_eeg,
        "reref_chs": ch_names_eeg
    }
    reference = Reference(
        raw_copy,
        prep_params,
        ransac=True,
        random_state=seed
    )
    print("\n\n=== Performing Robust Re-referencing... ===\n")
    reference.perform_reference()
    
    # Get info
    initial_bad = reference.noisy_channels_original["bad_all"]
    id_info['initial_bad'] = " ".join(initial_bad)
    id_info['num_initial_bad'] = len(initial_bad)
    
    interpolated = reference.interpolated_channels
    id_info['interpolated'] = " ".join(interpolated)
    id_info['num_interpolated'] = len(interpolated)
    
    remaining_bad = reference.still_noisy_channels
    id_info['remaining_bad'] = " ".join(remaining_bad)
    id_info['num_remaining_bad'] = len(remaining_bad)

    # Print re-referencing info
    print("\nRe-Referencing Info:")
    print(" - Bad channels original: {0}".format(initial_bad))
    print(" - Bad channels after re-referencing: {0}".format(interpolated))
    print(" - Bad channels after interpolation: {0}".format(remaining_bad))
    
    print("\n\n### sub-{0} complete! ###\n\n".format(id_num))
    
    return id_info
    


### Run loop for all IDs ######################################################

ids = []
for sub in os.listdir(bids_root):
    if "sub-" in sub:
        ids.append(sub.split("-")[1])

processed_ids = []
if not os.path.isfile(info_file):
    open(info_file, 'w').close()
elif os.path.getsize(info_file) > 0:
    with open(info_file, 'r') as f:
        info_csv = csv.DictReader(f)
        processed_ids = [row['id'] for row in info_csv]                      

first_id = len(processed_ids) == 0
with open(info_file, 'a', newline='') as outfile:
    writer = csv.writer(outfile)
    print("")
    for sub in ids[:10]:
        if sub in processed_ids:
            print(" - sub-{0} already processed, skipping...\n".format(sub))
            continue
        info = preprocess_eeg(sub, random_seed=seed)
        if first_id:
            writer.writerow(list(info.keys()))
            first_id = False
        writer.writerow(list(info.values()))

And here's my code for generating the comparison file. It's not very flexible in that it only supports comparing two runs, but it's at least something:

hdr = [
    'id', 'ndiff_init_bad', 'ndiff_interpolated', 'ndiff_still_bad',
    'diff_init_bad', 'diff_interpolated', 'diff_still_bad'
]
with open('prep_info.csv', 'r') as f1:
    with open('prep_info1.csv', 'r') as f2:
        with open('prep_diffs.csv', 'w') as out:
            info_csv1 = csv.DictReader(f1)
            info_csv2 = csv.DictReader(f2)
            out_csv = csv.writer(out)
            out_csv.writerow(hdr)
            info1 = [row for row in info_csv1]
            info2 = [row for row in info_csv2]
            for i in range(len(info1)):
                id_num = info1[i]['id']
                init_bad1 = set(info1[i]['initial_bad'].split(' '))
                init_bad2 = set(info2[i]['initial_bad'].split(' '))
                init_diffs = list(init_bad1 - init_bad2) + list(init_bad2 - init_bad1)
                interp1 = set(info1[i]['interpolated'].split(' '))
                interp2 = set(info2[i]['interpolated'].split(' '))
                interp_diffs = list(interp1 - interp2) + list(interp2 - interp1)
                remain1 = set(info1[i]['remaining_bad'].split(' '))
                remain2 = set(info2[i]['remaining_bad'].split(' '))
                remain_diffs = list(remain1 - remain2) + list(remain2 - remain1)
                out_csv.writerow([
                    id_num, len(init_diffs), len(interp_diffs), len(remain_diffs),
                    " ".join(init_diffs), " ".join(interp_diffs), " ".join(remain_diffs)
                ])

[sappelhoff]

Hey @a-hurst thanks a lot for your tests. I have taken a brief look at the code and was wondering why you are using the PREP components individually instead of PrePPipeline.fit()?

In any case, this warrants a serious investigation of the PyPrep codebase ... unfortunately I don't have the time for that at all, and don't expect to have time to do that myself either :-(

I'd very much welcome contributions though and I would be happy to either:

1. transfer this repo to a separate GitHub organization, where it can be maintained by several people
2. give you (and @yjmantilla) maintainer rights for this repo (hosted on my personal GH account)

In the meantime, I hope that the current warning in the README suffices:

ALPHA SOFTWARE. This package is currently in its early stages of iteration. It may change both its internals or its user-facing API in the near future. Any feedback and ideas on how to improve either of these is more than welcome! Use this software at your own risk.

[a-hurst]

@sappelhoff I think the first thing to do would be to run a couple people from this dataset through the MATLAB PREP pipeline two or three times and see if we get similar variability. Given that we already have pretty good comparison tests between PyPREP and MATLAB PREP, and that I'm pretty confident in the quality of your code given your careful
consideration of my recent PR in mne-bids, I have a hunch MATLAB PREP will have similar problems.

I have basically zero MATLAB/Octave experience, though, so would you or @yjmantilla be willing to let sub-007, ses-01 run twice in the background with MATLAB PREP and see what the consistency between runs is like? If it'd be reasonably straightforward for a beginner I can give it a shot too, I just don't want to spend a few hours struggling through what should be a 5-minute process. Once we know whether it's a Python implementation issue or an original implementation issue we can sort how to investigate: I don't have a ton of free time either, but I can try to set some aside for this since I'm sure this software will come in handy more than once during my PhD.

As for the weirdness of my script: I'm using the individual functions instead of the normal API because I adapted this from a larger and more involved pipeline script, where I save PSD and channel plots after each step of the pipeline so I can do a visual sanity check of the cleaning process for each file.

[sappelhoff]

I'm pretty confident in the quality of your code given your careful consideration of my recent PR in mne-bids

that's very nice of you to say, but to provide a little historical perspective: I initially wrote the code for pyprep's "find noisy channels" (up to version 0.2.3 of this package), and everything that's on top here (which is a lot!) was written as part of a student project supervised by @adam2392 (please correct me if I am wrong Adam!), and I am not 100% confident with all of the aspects. Meanwhile, @yjmantilla and @christian-oreilly have patched a few things -- but pyprep is still not in a "good shape" I think.

Regarding your proposal to test matlab PREP and pyprep in comparison --> that's a good idea. I hope @yjmantilla can find some time.

I don't have a ton of free time either, but I can try to set some aside for this since I'm sure this software will come in handy more than once during my PhD.

yep

As for the weirdness of my script: I'm using the individual functions instead of the normal API because I adapted this from a larger and more involved pipeline script, where I save PSD and channel plots after each step of the pipeline so I can do a visual sanity check of the cleaning process for each file.

Ah, nice - of course that'd be a nice feature to have in pyprep as well :) ... but first things first.

[a-hurst]

Regarding your proposal to test matlab PREP and pyprep in comparison --> that's a good idea. I hope @yjmantilla can find some time.

That would be great! I downloaded Octave myself just to get a sense of the difficulty and can't even figure out how to import the .bdf files. Coming from R and Python, MATLAB's package management system and weird GUI/CLI hybrid leave a lot to be desired!

[a-hurst]

Also figured I should tag @christian-oreilly since they did some previous tests for PyPREP comparing cleanline between PyPrep and MATLAB PREP: I'm sure you're as busy as the rest of us, but if @yjmantilla doesn't have time would you be willing to run a subject or two from the above dataset through MATLAB PREP to see whether you get similar variability between runs?

[yjmantilla]

Ok, Im running some tests for [sub-007, ses-01]

My output will be csvs with the following info but across runs:

• interpolated channels numbers

• still_noisy_channels numbers

• for each in [noisyStatisticsOriginal,noisyStatisticsBeforeInterpolation,noisyStatistics]

• • channels marked as bad in each of these categories {'badChannelsFromDropOuts' 'all' 'badChannelsFromNaNs' 'badChannelsFromNoData' 'badChannelsFromLowSNR' 'badChannelsFromHFNoise' 'badChannelsFromCorrelation' 'badChannelsFromDeviation' 'badChannelsFromRansac'}

All channel indexes starting @ 1

Hopefully this will be informative enough to pinpoint where is the problem in pyprep.

Now, currently pyprep doesn't output the bad_channels along each of the criteria, I think it would be nice to provide that functionality to compare the values directly . See #20

I would be willing to test more subjects but for now this test will be clarifying enough.

P.S: I hate matlab too.

Example Code (i think i initialized everything just like @a-hurst but if anyone spots anything, please do tell me):

%% PREP TEST

%% Libraries
clc, clear all ,close all;
dir = pwd;

eeglab_path = 'Y:\code\gica_paper\resources\eeglab2020_0';
cfg.path.resources = 'Y:\code\gica_paper\resources\';
rmpath(genpath(eeglab_path));
%eeglab_path = 'Y:/code/preprocessing-flow/resources/eeglab2019_1_prep';
prep_path = 'Y:\code\gica_paper\resources\PrepPipeline';
rmpath(genpath(prep_path));
cd(eeglab_path)
eeglab
%addpath(genpath(eeglab_path));
addpath(genpath(prep_path));
cd(dir)
close all
%% Preprocessing with PREP 

% Routes 
% channels location
file_url = 'Y:\datasets\New folder\sub-007_ses-01_eeg_sub-007_ses-01_task-meditation_eeg.bdf';
EEG = pop_biosig(file_url);
EEG = eeg_checkset(EEG);

chans = {'Fp1' 'AF7' 'AF3' 'F1' 'F3' 'F5' 'F7' 'FT7' 'FC5' 'FC3' 'FC1' 'C1' 'C3' 'C5' 'T7' 'TP7' 'CP5' 'CP3' 'CP1' 'P1' 'P3' 'P5' 'P7' 'P9' 'PO7' 'PO3' 'O1' 'Iz' 'Oz' 'POz' 'Pz' 'CPz' 'Fpz' 'Fp2' 'AF8' 'AF4' 'AFz' 'Fz' 'F2' 'F4' 'F6' 'F8' 'FT8' 'FC6' 'FC4' 'FC2' 'FCz' 'Cz' 'C2' 'C4' 'C6' 'T8' 'TP8' 'CP6' 'CP4' 'CP2' 'P2' 'P4' 'P6' 'P8' 'P10' 'PO8' 'PO4' 'O2' 'EXG1' 'EXG2' 'EXG3' 'EXG4' 'EXG5' 'EXG6' 'EXG7' 'EXG8' 'GSR1' 'GSR2' 'Erg1' 'Erg2' 'Resp' 'Plet' 'Temp'};

for i= 1:EEG.nbchan
    EEG.chanlocs(i).labels = chans{i};
end

%EEG = eeg_checkset(EEG);


noChan = {'EXG1' 'EXG2' 'EXG3' 'EXG4' 'EXG5' 'EXG6' 'EXG7' 'EXG8' 'GSR1' 'GSR2' 'Erg1' 'Erg2' 'Resp' 'Plet' 'Temp'};

EEG = pop_select(EEG,'nochannel',noChan);%{'NAS' 'LVEOG' 'RVEOG' 'LHEOG' 'RHEOG' 'NFPZ' 'VEOG' 'HEOG'});   
EEG = eeg_checkset(EEG);

EEG = pop_chanedit(EEG, 'lookup',fullfile(cfg.path.resources,'standard-10-5-cap385.elp'));%maybe try this
EEG = eeg_checkset(EEG);

nb_channels = EEG.nbchan;

% PREP approach
params = struct();
params.referenceChannels = 1:nb_channels;
params.evaluationChannels = 1:nb_channels;
params.rereferencedChannels = 1:nb_channels;
params.detrendChannels = 1:nb_channels;
params.lineNoiseChannels = 1:nb_channels;
params.lineFrequencies = 60:60:EEG.srate/2;
params.detrendType = 'high pass';
params.detrendCutoff = 1;
params.referenceType = 'robust';
params.keepFiltered = false;

bad_types = {'badChannelsFromDropOuts' 'all' 'badChannelsFromNaNs' 'badChannelsFromNoData' 'badChannelsFromLowSNR' 'badChannelsFromHFNoise' 'badChannelsFromCorrelation' 'badChannelsFromDeviation' 'badChannelsFromRansac'};
stats_types = {'noisyStatisticsOriginal' 'noisyStatisticsBeforeInterpolation' 'noisyStatistics'};
for i=1:10
    [EEG2, computationTimes] = prepPipeline(EEG, params);
    EEG2.setname = [EEG.setname '_' num2str(i) '_PREP'];
    %pop_saveset( EEG, 'filepath',fullfile(cfg.path.output,groups{g}), 'filename',EEG.setname);
    data = EEG2.etc;
    
    save(strcat(EEG2.setname,'_etc'),'data');
    
    for j = 1:length(stats_types)
        for k = 1:length(bad_types)
            dummy = eval(['EEG2.etc.noiseDetection.reference.' stats_types{j} '.noisyChannels.' bad_types{k}]);
            dlmwrite([EEG.setname '_MATLAB_' stats_types{j} '_' bad_types{k} '.csv'],dummy,'-append')
        end
    end
    dlmwrite([EEG.setname '_MATLAB_interpolated.csv'],EEG2.etc.noiseDetection.interpolatedChannelNumbers,'-append')
    dlmwrite([EEG.setname '_MATLAB_stillNoisy.csv'],EEG2.etc.noiseDetection.stillNoisyChannelNumbers,'-append')
 
end

[a-hurst]

@yjmantilla Thanks so much, looking forward to the results of this! The data from sub-007 should tell us a lot, but in case we want to try any other files the two most variable IDs were sub-003 and sub-005 (I mainly suggested 007 for their massive and surprising jump in channels marked as bad, which happened on both my runs).

EDIT: Regarding differences between your pipeline and mine, the one thing that came to mind was that @christian-oreilly found that the MATLAB cleanline didn’t seem to do anything at all for some of the files they tested. Can you check that it’s working properly for this file in case that’s a confound?

[yjmantilla]

Ok so here are the results:

https://drive.google.com/drive/folders/10ZRnaUBs6VF8n1obVBp4TeXInK6_OZ1n?usp=sharing

In the folder you will find the following files:

• _prep files are the outputs of the verbatim prep
• _noSeed files are the outputs of the prep with a ransac that wasn't initialized with a particular seed

Basically I just changed the following line in findNoisyChannels.m (matlab prep):

 %stream = RandStream('mt19937ar', 'Seed', 435656);
 stream = RandStream('mt19937ar','Seed','shuffle');

This no seed test was done because as far as I know in pyprep we are not giving a particular seed to the random number generator (except for pytest tests)

So as to the other patterns in the name:
summary --> interpolated and still noisy channels
noisyStatisticsOriginal-->bad channels identified before robust referencing
noisyStatisticsBeforeInterpolation-->bad channels just before interpolation (after robust referencing, determines interpolated)
noisyStatistics--> bad channels after interpolation (determines still noisy channels)

• The noisyStatistics ones will have bad channels identified by each criteria.
• The rows in the files represent the runs --> 1 row : 1 run, 10 runs in total

Some early conclusions:

• verbatim matlab prep is stable across runs
• matlab prep with no seed is not as stable but some channels are (they keep appearing across runs)

PS:

The code to generate these csvs files starting from the matlab code i posted above is this one, in case any soul out there tries to replicate:

import os
import pandas as pd

directory = r'Y:\code\gica_paper\prep_validation\sub-007_ses-01_noSeed'
#directory = r'Y:\code\gica_paper\prep_validation\sub-007_ses-01_prep'

sub = os.path.basename(os.path.normpath(directory))

def filter_files(filelist,formats = ['.edf','.set','.cnt','.bdf','.mat','.vhdr']):
    filtered = []
    for x in filelist:
        valid_file = []
        for format in formats:
            valid_file.append(format in x)
        if any(valid_file):
            filtered.append(x)
    return filtered

files = [os.path.join(r,file) for r,d,f in os.walk(directory) for file in f]
files = filter_files(files,['.csv'])
# print(files)

noisyStatisticsBeforeInterpolation = []
noisyStatistics = []
noisyStatisticsOriginal = []
summary = []
for f in files:
    if 'noisyStatisticsBeforeInterpolation' in f:
        noisyStatisticsBeforeInterpolation.append(f)
    elif 'noisyStatisticsOriginal' in f:
        noisyStatisticsOriginal.append(f)
    elif 'noisyStatistics' in f:
        noisyStatistics.append(f)
    elif 'interpolated' in f:
        summary.append(f)
    elif 'stillNoisy' in f:
        summary.append(f)
    else:
        pass

def findChar(c,string):
    idx = [x for x, v in enumerate(string) if v == c]
    return idx

# for x in [noisyStatisticsBeforeInterpolation , noisyStatistics , noisyStatisticsOriginal , interpolated , stillNoisy]:
#     print(x)


def get_field(file):
    idxs = findChar('_',file)
    idxs.sort()
    return file[idxs[-1]+1:].replace('.csv','')

import copy
import numpy as np

for current in ['noisyStatisticsBeforeInterpolation','noisyStatistics','noisyStatisticsOriginal','summary']:
    fields = []
    data = []

    for file in eval(current):
        f = open(file, 'r') 
        Lines = f.readlines()
        Lines = [x.replace('\n','').replace(',',';') for x in Lines]
        #print(Lines)
        field = get_field(file)
        fields.append(field)
        data.append(copy.deepcopy(Lines))


    data = np.array(data)
    print('iterations',data.shape[1])

    for i in range(data.shape[1]):
        print(data[:,i])

    print(data.T)
    df = pd.DataFrame(data=data.T,columns=fields)
    print(df)
    df.to_csv(sub+'_'+current+'.csv',sep=',')
    df.to_excel(sub+'_'+current+'.xlsx')

[yjmantilla]

@a-hurst just saw your zip results. That many channels interpolated is kind of weird. Makes me remember how pyprep was acting before fixing a detrending bug.

I guess I should run this subject with pyprep too to check if I get the same degree of interpolated channels but that will be for another day.

BTW, another confounding variable is the montage. I used the channel names in task-meditation_channels.tsv . I see you seem to use the original ones in the bdf file and that mne managed to find the locations in their montage files. I was not so lucky in matlab so I had to find some more standard names (FPz ,and such), my luck came back since the tsv had that notation.

I guess there must be some montage differences between the default montages of mne and eeglab but I doubt thats the source of our problems.

[a-hurst]

@yjmantilla Fantastic, will look at this later today! For whatever reason, MNE-BIDS doesn't use the channel names in the _channels.tsv file so I had to go with the biosemi montage. All the MNE montages are available as individual text files in the source code, would it be possible to import one of them into EEGLAB?