def test_global_fit(self): kf = KineticsFitting(self.series_apo, bounds=(1e-2, 800), temperature=self.temperature, pH=self.pH) initial_rates = csv_to_protein( os.path.join(directory, 'test_data', 'ecSecB_guess.txt')) t0 = time.time() # Very crude benchmarks fr_global = kf.global_fit(initial_rates, epochs=1000) t1 = time.time() assert t1 - t0 < 5 out_deltaG = fr_global.output check_deltaG = csv_to_protein( os.path.join(directory, 'test_data', 'ecSecB_torch_fit.txt')) assert np.allclose(check_deltaG['deltaG'], out_deltaG['deltaG'], equal_nan=True, rtol=0.01) assert np.allclose(check_deltaG['covariance'], out_deltaG['covariance'], equal_nan=True, rtol=0.01)
def reload_dashboard(): data_objs = {k: load_from_yaml(v, data_dir=data_dir) for k, v in yaml_dicts.items()} for k, v in data_objs.items(): v.metadata['name'] = k ctrl.data_objects = data_objs rates = csv_to_protein(test_dir / 'rates.txt', column_depth=3).df fit = csv_to_protein(test_dir / 'global_fit.txt', column_depth=3).df colors = csv_to_protein(test_dir / 'colors.txt', column_depth=3).df peptides = csv_to_dataframe(test_dir / 'peptides.txt', column_depth=2, index_col=0) source = ctrl.sources['dataframe'] source.add_df(rates, 'rates') source.add_df(peptides, 'peptides') #source.add_df(fit, 'global_fit') source.add_df(colors, 'colors') ctrl.sources['dataframe'].updated = True fit_control = ctrl.control_panels['FitControl'] fit_control.epochs = 100 fit_control.fit_mode = 'Single' fit_control.fit_name = 'new_global_fit_test_123' ngl = ctrl.views['protein'] ngl.ngl_view.pdb_string = Path(test_dir / '1qyn.pdb').read_text()
def test_batch_fit(self, tmp_path): hdx_set = HDXMeasurementSet([self.hdxm_apo, self.hdxm_dimer]) guess = csv_to_dataframe(output_dir / 'ecSecB_guess.csv') # Create rates dataframe rates_df = pd.DataFrame( {name: guess['rate'] for name in hdx_set.names}) gibbs_guess = hdx_set.guess_deltaG(rates_df) fr_global = fit_gibbs_global_batch(hdx_set, gibbs_guess, epochs=1000) fpath = Path(tmp_path) / 'fit_result_batch.csv' fr_global.to_file(fpath) df = csv_to_dataframe(fpath) assert df.attrs['metadata'] == fr_global.metadata output = fr_global.output check_protein = csv_to_protein(output_dir / 'ecSecB_batch.csv') states = ['SecB WT apo', 'SecB his dimer apo'] for state in states: from pandas.testing import assert_series_equal result = output[state]['dG'] test = check_protein[state]['dG'] assert_series_equal(result, test, rtol=0.1) errors = fr_global.get_squared_errors() assert errors.shape == (hdx_set.Ns, hdx_set.Np, hdx_set.Nt) mock_alignment = { 'apo': 'MSEQNNTEMTFQIQRIYTKDI------------SFEAPNAPHVFQKDWQPEVKLDLDTASSQLADDVYEVVLRVTVTASLG-------------------EETAFLCEVQQGGIFSIAGIEGTQMAHCLGAYCPNILFPYARECITSMVSRG----TFPQLNLAPVNFDALFMNYLQQQAGEGTEEHQDA', 'dimer': 'MSEQNNTEMTFQIQRIYTKDISFEAPNAPHVFQKDWQPEVKLDLDTASSQLADDVY--------------EVVLRVTVTASLGEETAFLCEVQQGGIFSIAGIEGTQMAHCLGA----YCPNILFPAARECIASMVARGTFPQLNLAPVNFDALFMNYLQQQAGEGTEEHQDA-----------------', } hdx_set.add_alignment(list(mock_alignment.values())) gibbs_guess = hdx_set[0].guess_deltaG( guess['rate']) # Guesses from first measurement aligned_result = fit_gibbs_global_batch_aligned(hdx_set, gibbs_guess, r1=2, r2=5, epochs=1000) output = aligned_result.output check_protein = csv_to_protein(output_dir / 'ecSecB_batch_aligned.csv') states = ['SecB WT apo', 'SecB his dimer apo'] for state in states: from pandas.testing import assert_series_equal result = output[state]['dG'] test = check_protein[state]['dG'] assert_series_equal(result, test, rtol=0.1)
def test_batch_fit(self): hdx_set = HDXMeasurementSet([self.series_apo, self.series_dimer]) guess = csv_to_protein( os.path.join(directory, 'test_data', 'ecSecB_guess.txt')) gibbs_guess = hdx_set.guess_deltaG([guess['rate'], guess['rate']]) result = fit_gibbs_global_batch(hdx_set, gibbs_guess, epochs=1000) output = result.output check_protein = csv_to_protein(os.path.join(directory, 'test_data', 'ecSecB_batch.csv'), column_depth=2) states = ['SecB WT apo', 'SecB his dimer apo'] for state in states: from pandas.testing import assert_series_equal result = output[state]['deltaG'] test = check_protein[state]['deltaG'] assert_series_equal(result, test, rtol=0.1) mock_alignment = { 'apo': 'MSEQNNTEMTFQIQRIYTKDI------------SFEAPNAPHVFQKDWQPEVKLDLDTASSQLADDVYEVVLRVTVTASLG-------------------EETAFLCEVQQGGIFSIAGIEGTQMAHCLGAYCPNILFPYARECITSMVSRG----TFPQLNLAPVNFDALFMNYLQQQAGEGTEEHQDA', 'dimer': 'MSEQNNTEMTFQIQRIYTKDISFEAPNAPHVFQKDWQPEVKLDLDTASSQLADDVY--------------EVVLRVTVTASLGEETAFLCEVQQGGIFSIAGIEGTQMAHCLGA----YCPNILFPAARECIASMVARGTFPQLNLAPVNFDALFMNYLQQQAGEGTEEHQDA-----------------', } hdx_set.add_alignment(list(mock_alignment.values())) gibbs_guess = hdx_set.guess_deltaG([guess['rate'], guess['rate']]) aligned_result = fit_gibbs_global_batch_aligned(hdx_set, gibbs_guess, r1=2, r2=5, epochs=1000) output = aligned_result.output check_protein = csv_to_protein(os.path.join( directory, 'test_data', 'ecSecB_batch_aligned.csv'), column_depth=2) states = ['SecB WT apo', 'SecB his dimer apo'] for state in states: from pandas.testing import assert_series_equal result = output[state]['deltaG'] test = check_protein[state]['deltaG'] assert_series_equal(result, test, rtol=0.1)
def setup_class(cls): dtype = [('r_number', int), ('apple', float)] array1 = np.empty(15, dtype=dtype) array1['r_number'] = np.arange(15) + 3 array1['apple'] = np.ones(15) * 12 cls.array1 = array1 dtype = [('r_number', int), ('apple', float), ('grapes', float)] array2 = np.empty(17, dtype=dtype) array2['r_number'] = np.arange(17) + 6 array2['apple'] = np.ones(17) * 10 array2['grapes'] = np.ones(17) * 15 + np.random.rand(17) cls.array2 = array2 dtype = [('r_number', int), ('pear', float), ('banana', float)] array3 = np.empty(10, dtype=dtype) array3['r_number'] = np.arange(10) + 1 array3['pear'] = np.random.rand(10) + 20 array3['banana'] = -(np.random.rand(10) + 20) cls.array3 = array3 metadata = { 'temperature': 273.15, 'pH': 7.5, 'mutations': ['V123S', 'P234S'] } cls.protein = csv_to_protein(output_dir / 'ecSecB_info.csv') cls.protein.metadata = metadata fpath = input_dir / 'ecSecB_apo.csv' pf1 = PeptideMasterTable(read_dynamx(fpath)) cls.series = HDXMeasurement(pf1.get_state('SecB WT apo'), c_term=200)
def setup_class(cls): dtype = [('r_number', int), ('apple', float)] array1 = np.empty(15, dtype=dtype) array1['r_number'] = np.arange(15) + 3 array1['apple'] = np.ones(15) * 12 cls.array1 = array1 dtype = [('r_number', int), ('apple', float), ('grapes', float)] array2 = np.empty(17, dtype=dtype) array2['r_number'] = np.arange(17) + 6 array2['apple'] = np.ones(17) * 10 array2['grapes'] = np.ones(17) * 15 + np.random.rand(17) cls.array2 = array2 dtype = [('r_number', int), ('pear', float), ('banana', float)] array3 = np.empty(10, dtype=dtype) array3['r_number'] = np.arange(10) + 1 array3['pear'] = np.random.rand(10) + 20 array3['banana'] = -(np.random.rand(10) + 20) cls.array3 = array3 cls.protein = csv_to_protein(directory / 'test_data' / 'ecSecB_info.csv', column_depth=1) fpath = directory / 'test_data' / 'ecSecB_apo.csv' pf1 = PeptideMasterTable(read_dynamx(fpath)) #states = pf1.groupby_state(c_term=200) cls.series = HDXMeasurement(pf1.get_state('SecB WT apo'), c_term=200)
def test_initial_guess_wt_average(self): result = fit_rates_weighted_average(self.reduced_hdxm) output = result.output assert output.size == 100 check_rates = csv_to_protein(output_dir / 'ecSecB_reduced_guess.csv') pd.testing.assert_series_equal(check_rates['rate'], output['rate'])
def test_to_file(self): with tempfile.TemporaryDirectory() as tempdir: fpath = Path(tempdir) / 'protein.csv' self.protein.to_file(fpath) protein_read = csv_to_protein(fpath) pd.testing.assert_frame_equal(self.protein.df, protein_read.df) assert self.protein.metadata == protein_read.metadata
def test_read_write_tables(self, tmp_path): # Single-index columns df = pd.DataFrame(np.random.randn(25, 4), columns=list('ABCD')) df.index.name = 'singlecolumnindex' sio = StringIO() dataframe_to_stringio(df, sio) sio.seek(0) df_read = csv_to_dataframe(sio) pd.testing.assert_frame_equal(df, df_read) fpath = Path(tmp_path) / 'single_index.csv' dataframe_to_file(fpath, df) csv_to_dataframe(fpath) pd.testing.assert_frame_equal(df, df_read) # multi-index column cols = pd.MultiIndex.from_product([('a', 'b'), ('x', 'y')]) df = pd.DataFrame(np.random.randn(25, 4), columns=cols) df.index.name = 'multicolumnindex' sio = StringIO() dataframe_to_stringio(df, sio) sio.seek(0) df_read = csv_to_dataframe(sio) pd.testing.assert_frame_equal(df, df_read) fpath = Path(tmp_path) / 'multi_index.csv' dataframe_to_file(fpath, df) df_read = csv_to_dataframe(fpath) pd.testing.assert_frame_equal(df, df_read) protein = csv_to_protein(fpath) assert protein.index.name == 'r_number' assert isinstance(protein, Protein) metadata = { 'instrumuent': 'LCMS', 'settings': {'pressure': '5 kPa', 'temperature': '400K'} } df.attrs['metadata'] = metadata fpath = Path(tmp_path) / 'multi_index_with_metadata.csv' dataframe_to_file(fpath, df) df_read = csv_to_dataframe(fpath) pd.testing.assert_frame_equal(df, df_read) assert df_read.attrs['metadata'] == metadata fpath = Path(tmp_path) / 'multi_index_with_metadata.txt' dataframe_to_file(fpath, df, fmt='pprint', include_version=True) lines = Path(fpath).read_text().split('\n') assert len(lines) == 38 assert lines[0].strip() == pyhdx.VERSION_STRING
def test_methods(self): path = directory / 'test_data' / 'ecSecB_guess.txt' # testing csv_to_protein ret = csv_to_protein(path) assert type(ret) == Protein assert ret.index.name == 'r_number' # testing txt_to_np with open(path, mode='r') as f: ret = csv_to_np(StringIO(f.read())) assert 'r_number' in ret.dtype.names
def test_batch_fit(self): kfs = [ KineticsFitting(series, temperature=self.temperature, pH=self.pH) for series in [self.series_apo, self.series_dimer] ] guess = csv_to_protein( os.path.join(directory, 'test_data', 'ecSecB_guess.txt')) bf = BatchFitting(kfs, [guess, guess]) result = bf.global_fit(epochs=1000) output = result.output check_protein = csv_to_protein( os.path.join(directory, 'test_data', 'ecSecB_batch.csv')) states = ['SecB WT apo', 'SecB his dimer apo'] for state in states: assert np.allclose(output[state]['deltaG'], check_protein[state]['deltaG'], equal_nan=True, rtol=0.01)
def reload_dashboard(): data_objs = {k: yaml_to_hdxm(v, data_dir=data_dir) for k, v in yaml_dict.items()} for k, v in data_objs.items(): v.metadata['name'] = k source = ctrl.sources['dataframe'] for ds in ['peptides', 'peptides_mse', 'd_calc', 'rfu', 'rates', 'global_fit', 'losses']: df = csv_to_protein(test_dir / f'{ds}.csv') source.add_df(df, ds) #Temporary workaround for comment characters in csv files ds = 'colors' df = pd.read_csv(test_dir / f'{ds}.csv', header=[0, 1, 2], index_col=0, skiprows=3) source.add_df(df, ds)
def test_dtype_cuda(self): check_deltaG = csv_to_protein(output_dir / 'ecSecB_torch_fit.csv') initial_rates = csv_to_dataframe(output_dir / 'ecSecB_guess.csv') cfg.set('fitting', 'device', 'cuda') gibbs_guess = self.hdxm_apo.guess_deltaG( initial_rates['rate']).to_numpy() if torch.cuda.is_available(): fr_global = fit_gibbs_global(self.hdxm_apo, gibbs_guess, epochs=1000, r1=2) out_deltaG = fr_global.output for field in ['dG', 'k_obs', 'covariance']: assert_series_equal(check_deltaG[field], out_deltaG[self.hdxm_apo.name, field], rtol=0.01, check_dtype=False, check_names=False) else: with pytest.raises(AssertionError, match=r".* CUDA .*"): fr_global = fit_gibbs_global(self.hdxm_apo, gibbs_guess, epochs=1000, r1=2) cfg.set('fitting', 'device', 'cpu') cfg.set('fitting', 'dtype', 'float32') fr_global = fit_gibbs_global(self.hdxm_apo, gibbs_guess, epochs=1000, r1=2) dg = fr_global.model.dG assert dg.dtype == torch.float32 out_deltaG = fr_global.output for field in ['dG', 'k_obs']: assert_series_equal(check_deltaG[field], out_deltaG[self.hdxm_apo.name, field], rtol=0.01, check_dtype=False, check_names=False) cfg.set('fitting', 'dtype', 'float64')
def setup_class(cls): cls.fpath = directory / 'test_data' / 'ecSecB_apo.csv' cls.pmt = PeptideMasterTable(read_dynamx(cls.fpath)) cls.state = 'SecB WT apo' cls.control = ('Full deuteration control', 0.167) cls.pmt.set_control(cls.control) state_data = cls.pmt.get_state(cls.state) cls.temperature, cls.pH = 273.15 + 30, 8. cls.series = HDXMeasurement(state_data, temperature=cls.temperature, pH=cls.pH) cls.prot_fit_result = csv_to_protein(directory / 'test_data' / 'ecSecB_torch_fit.txt') cfg = ConfigurationSettings() cfg.set('cluster', 'port', str(test_port))
def do_fitting_from_yaml(yaml_dict, kf_obj): raise NotImplementedError('Fitting from yaml not implemented') yaml_dict = copy.deepcopy( yaml_dict) # Make local copy to not affect the supplied dict by pop guess = yaml_dict['initial_guess'] if 'file_path' in guess.keys(): try: # todo update when txt files are no longer in existence initial_guess = txt_to_protein(guess['file_path']) except KeyError: initial_guess = csv_to_protein(guess['file_path']) else: raise NotImplementedError('only guesses by file currently') global_fit = yaml_dict['global_fit'] optimizer_kwargs = global_fit.pop('optimizer_kwargs') fit_result = kf_obj.global_fit(initial_guess, **global_fit, **optimizer_kwargs) return fit_result
def setup_class(cls): cls.fpath = directory / 'test_data' / 'ecSecB_apo.csv' cls.pmt = PeptideMasterTable(read_dynamx(cls.fpath)) cls.state = 'SecB WT apo' cls.control = ('Full deuteration control', 0.167) cls.pmt.set_control(cls.control) states = cls.pmt.groupby_state() cls.series = states[cls.state] cls.prot_fit_result = csv_to_protein(directory / 'test_data' / 'ecSecB_torch_fit.txt') cls.ds_fit = DataSource(cls.prot_fit_result, name='global_fit', x='r_number', tags=['mapping', 'pfact', 'deltaG'], renderer='circle', size=10)
def test_global_fit_extended(self): check_deltaG = csv_to_protein(output_dir / 'ecSecB_torch_fit_epochs_20000.csv') initial_rates = csv_to_dataframe(output_dir / 'ecSecB_guess.csv') gibbs_guess = self.hdxm_apo.guess_deltaG(initial_rates['rate']) t0 = time.time() # Very crude benchmarks fr_global = fit_gibbs_global(self.hdxm_apo, gibbs_guess, epochs=20000, r1=2) t1 = time.time() assert t1 - t0 < 50 out_deltaG = fr_global.output for field in ['dG', 'k_obs', 'covariance']: assert_series_equal(check_deltaG[self.hdxm_apo.name, field], out_deltaG[self.hdxm_apo.name, field], rtol=0.01, check_dtype=False) errors = fr_global.get_squared_errors() assert errors.shape == (1, self.hdxm_apo.Np, self.hdxm_apo.Nt)
def test_global_fit_extended_cuda(self): check_deltaG = csv_to_protein(output_dir / 'ecSecB_torch_fit_epochs_20000.csv') initial_rates = csv_to_dataframe(output_dir / 'ecSecB_guess.csv') gibbs_guess = self.hdxm_apo.guess_deltaG(initial_rates['rate']) # todo allow contextmanger? cfg.set('fitting', 'device', 'cuda') cfg.set('fitting', 'dtype', 'float32') fr_global = fit_gibbs_global(self.hdxm_apo, gibbs_guess, epochs=20000, r1=2) out_deltaG = fr_global.output for field in ['dG', 'k_obs']: assert_series_equal(check_deltaG[self.hdxm_apo.name, field], out_deltaG[self.hdxm_apo.name, field], rtol=0.01, check_dtype=False) cfg.set('fitting', 'device', 'cpu') cfg.set('fitting', 'dtype', 'float64')
current_dir = Path(__file__).parent #current_dir = Path().cwd() / 'templates' # pycharm scientific compat output_dir = current_dir / 'output' output_dir.mkdir(exist_ok=True) data_dir = current_dir.parent / 'tests' / 'test_data' data = read_dynamx(data_dir / 'input' / 'ecSecB_apo.csv', data_dir / 'input' / 'ecSecB_dimer.csv') pmt = PeptideMasterTable(data) pmt.set_control(('Full deuteration control', 0.167*60)) st1 = HDXMeasurement(pmt.get_state('SecB his dimer apo'), pH=8, temperature=273.15 + 30) st2 = HDXMeasurement(pmt.get_state('SecB WT apo'), pH=8, temperature=273.15 + 30) hdx_set = HDXMeasurementSet([st1, st2]) guess = csv_to_protein(data_dir / 'output' / 'ecSecB_guess.csv') gibbs_guess = hdx_set[0].guess_deltaG(guess['rate']) # Example fit with only 5000 epochs and high learning rate # Checkpoint stores model history every `epoch_step` epochs checkpoint = CheckPoint(epoch_step=250) result = fit_gibbs_global_batch(hdx_set, gibbs_guess, r1=0.5, r2=0.1, epochs=5000, lr=1e5, callbacks=[checkpoint]) print(f"MSE loss: {result.mse_loss:.2f}, " f"Reg loss: {result.reg_loss:.2f}, " f"Reg percent: {result.regularization_percentage:.0f}%") df = checkpoint.to_dataframe(hdx_set.names) dataframe_to_file(output_dir / 'model_history.csv', df) dataframe_to_file(output_dir / 'model_history.txt', df, fmt='pprint')
from pyhdx import VERSION_STRING current_dir = Path(__file__).parent data_dir = current_dir.parent / 'tests' / 'test_data' yaml_stream = Path(current_dir / 'yaml_files' / 'SecB.yaml').read_text() data_dict = yaml.safe_load(yaml_stream) output_dir = current_dir / 'fit' output_dir.mkdir(exist_ok=True) hdxm_list = [ load_from_yaml(dic, data_dir=data_dir, name=name) for name, dic in data_dict.items() ] rates_list = [ csv_to_protein(current_dir / 'guesses' / f'{name}_rates_guess.txt')['rate'] for name in data_dict.keys() ] hdx_set = HDXMeasurementSet(hdxm_list) gibbs_guess = hdx_set.guess_deltaG(rates_list) log_file = output_dir / f"fitting_log.txt" now = datetime.now() date = f'# {now.strftime("%Y/%m/%d %H:%M:%S")} ({int(now.timestamp())})' lines = [VERSION_STRING, date] r2 = 0.5 for r1 in [0, 0.01, 0.25, 0.5, 1]: t0 = time.time()
'MSEQNNTEMTFQIQRIYTKDI------------SFEAPNAPHVFQKDWQPEVKLDLDTASSQLADDVYEVVLRVTVTASLG-------------------EETAFLCEVQQGGIFSIAGIEGTQMAHCLGAYCPNILFPYARECITSMVSRG----TFPQLNLAPVNFDALFMNYLQQQAGEGTEEHQDA', } current_dir = Path(__file__).parent data_dir = current_dir.parent / 'tests' / 'test_data' data = read_dynamx(data_dir / 'ecSecB_apo.csv', data_dir / 'ecSecB_dimer.csv') pmt = PeptideMasterTable(data) pmt.set_control(('Full deuteration control', 0.167)) st1 = HDXMeasurement(pmt.get_state('SecB his dimer apo'), pH=8, temperature=273.15 + 30) st2 = HDXMeasurement(pmt.get_state('SecB WT apo'), pH=8, temperature=273.15 + 30) guess = csv_to_protein(data_dir / 'ecSecB_guess.txt') hdx_set = HDXMeasurementSet([st1, st2]) gibbs_guess = hdx_set.guess_deltaG([guess['rate'], guess['rate']]) hdx_set.add_alignment(list(mock_alignment.values())) result = fit_gibbs_global_batch_aligned(hdx_set, gibbs_guess, r1=2, r2=5, epochs=1000) print(result.output)
guess = False epochs = 1000 root_dir = Path().resolve().parent test_data_dir = root_dir / 'tests' / 'test_data' input_file_path = test_data_dir / 'ecSecB_apo.csv' # Load the data of two Dynamx files, and combine the result to one table data = read_dynamx(test_data_dir / 'ecSecB_apo.csv', test_data_dir / 'ecSecB_dimer.csv') pmt = PeptideMasterTable(data, drop_first=1, ignore_prolines=True, remove_nan=False) pmt.set_control(('Full deuteration control', 0.167)) temperature, pH = 273.15 + 30, 8. series = HDXMeasurement(pmt.get_state('SecB WT apo'), temperature=temperature, pH=pH) if guess: client = default_client() wt_avg_result = fit_rates_weighted_average(series, client=client) init_guess = wt_avg_result.output else: init_guess = csv_to_protein(test_data_dir / 'ecSecB_guess.txt') gibbs_guess = series.guess_deltaG(init_guess['rate']) fr_torch = fit_gibbs_global(series, gibbs_guess, epochs=epochs) print(fr_torch.metadata['total_loss'])
data = read_dynamx(test_data_dir / 'ecSecB_apo.csv', test_data_dir / 'ecSecB_dimer.csv') pmt = PeptideMasterTable(data, drop_first=1, ignore_prolines=True, remove_nan=False) pmt.set_control(control) temperature, pH = 273.15 + 30, 8. hdxm = HDXMeasurement(pmt.get_state('SecB WT apo'), sequence=sequence, temperature=temperature, pH=pH) if guess: client = default_client() wt_avg_result = fit_rates_weighted_average(hdxm, bounds=(1e-2, 800)) output = wt_avg_result.output output.to_file(directory / 'test_data' / 'ecSecB_guess.txt') else: output = csv_to_protein(directory / 'test_data' / 'ecSecB_guess.txt') gibbs_guess = hdxm.guess_deltaG(output['rate']) fr_torch = fit_gibbs_global(hdxm, gibbs_guess, epochs=epochs, r1=2) fr_torch.output.to_file(directory / 'test_data' / 'ecSecB_torch_fit.txt') hdxm_dimer = HDXMeasurement(pmt.get_state('SecB his dimer apo'), sequence=sequence_dimer, temperature=temperature, pH=pH) hdx_set = HDXMeasurementSet([hdxm_dimer, hdxm]) gibbs_guess = hdx_set.guess_deltaG([output['rate'], output['rate']]) batch_result = fit_gibbs_global_batch(hdx_set, gibbs_guess, epochs=epochs) batch_result.output.to_file(directory / 'test_data' / 'ecSecB_batch.csv') batch_result.output.to_file(directory / 'test_data' / 'ecSecB_batch.txt', fmt='pprint')