lazar 0.9.3 → 1.0.0

data/test/model-classification.rb

@@ -0,0 +1,106 @@
+require_relative "setup.rb"
+
+class LazarClassificationTest < MiniTest::Test
+
+  def test_classification_default
+    algorithms = {
+      :descriptors => {
+        :method => "fingerprint",
+        :type => "MP2D"
+      },
+      :similarity => {
+        :method => "Algorithm::Similarity.tanimoto",
+        :min => 0.1
+      },
+      :prediction => {
+        :method => "Algorithm::Classification.weighted_majority_vote",
+      },
+      :feature_selection => nil,
+    }
+    training_dataset = Dataset.from_csv_file File.join(DATA_DIR,"hamster_carcinogenicity.csv")
+    model = Model::Lazar.create  training_dataset: training_dataset
+    assert_kind_of Model::LazarClassification, model
+    assert_equal algorithms, model.algorithms
+    substance = training_dataset.substances[10]
+    prediction = model.predict substance
+    assert_equal "false", prediction[:value]
+    [ {
+      :compound => OpenTox::Compound.from_inchi("InChI=1S/C6H6/c1-2-4-6-5-3-1/h1-6H"),
+      :prediction => "false",
+    },{
+      :compound => OpenTox::Compound.from_smiles("c1ccccc1NN"),
+      :prediction => "false",
+    } ].each do |example|
+      prediction = model.predict example[:compound]
+      assert_equal example[:prediction], prediction[:value]
+    end
+
+    compound = Compound.from_smiles "CCO"
+    prediction = model.predict compound
+    assert_equal "true", prediction[:value]
+    assert_equal ["false"], prediction[:measurements]
+
+    # make a dataset prediction
+    compound_dataset = OpenTox::Dataset.from_csv_file File.join(DATA_DIR,"EPAFHM.mini_log10.csv")
+    prediction_dataset = model.predict compound_dataset
+    assert_equal compound_dataset.compounds, prediction_dataset.compounds
+
+    cid = prediction_dataset.compounds[7].id.to_s
+    assert_equal "Could not find similar substances with experimental data in the training dataset.", prediction_dataset.predictions[cid][:warning]
+    prediction_dataset.predictions.each do |cid,pred|
+      assert_equal "Could not find similar substances with experimental data in the training dataset.", pred[:warning] if pred[:value].nil?
+    end
+    cid = Compound.from_smiles("CCOC(=O)N").id.to_s
+    assert_match "excluded", prediction_dataset.predictions[cid][:warning]
+    # cleanup
+    [training_dataset,model,compound_dataset,prediction_dataset].each{|o| o.delete}
+  end
+ 
+  def test_classification_parameters
+    algorithms = {
+      :descriptors => {
+        :method => "fingerprint",
+        :type => "MACCS"
+      },
+      :similarity => {
+        :min => 0.4
+      },
+    }
+    training_dataset = Dataset.from_csv_file File.join(DATA_DIR,"hamster_carcinogenicity.csv")
+    model = Model::Lazar.create training_dataset: training_dataset, algorithms: algorithms
+    assert_kind_of Model::LazarClassification, model
+    assert_equal "Algorithm::Classification.weighted_majority_vote", model.algorithms[:prediction][:method]
+    assert_equal "Algorithm::Similarity.tanimoto", model.algorithms[:similarity][:method]
+    assert_equal algorithms[:similarity][:min], model.algorithms[:similarity][:min]
+    substance = training_dataset.substances[10]
+    prediction = model.predict substance
+    assert_equal "false", prediction[:value]
+    assert_equal 4, prediction[:neighbors].size
+  end
+
+  def test_kazius
+    t = Time.now
+    training_dataset = Dataset.from_csv_file File.join(DATA_DIR,"kazius.csv")
+    t = Time.now
+    model = Model::Lazar.create training_dataset: training_dataset
+    t = Time.now
+    2.times do
+      compound = Compound.from_smiles("Clc1ccccc1NN")
+      prediction = model.predict compound
+      assert_equal "1", prediction[:value]
+    end
+    training_dataset.delete
+  end
+
+  def test_caret_classification
+    skip
+  end
+
+  def test_fingerprint_chisq_feature_selection
+    skip
+  end
+
+  def test_physchem_classification
+    skip
+  end
+end

data/test/model-nanoparticle.rb

@@ -0,0 +1,128 @@
+require_relative "setup.rb"
+
+class NanoparticleModelTest  < MiniTest::Test
+  include OpenTox::Validation
+
+  def setup
+    @training_dataset = Dataset.where(:name => "Protein Corona Fingerprinting Predicts the Cellular Interaction of Gold and Silver Nanoparticles").first
+    @prediction_feature = @training_dataset.features.select{|f| f["name"] == 'log2(Net cell association)'}.first
+  end
+
+  def test_nanoparticle_model
+    assert true, @prediction_feature.measured
+    model = Model::Lazar.create training_dataset: @training_dataset, prediction_feature: @prediction_feature
+    refute_empty model.dependent_variables
+    refute_empty model.descriptor_ids
+    refute_empty model.independent_variables
+    assert_equal "Algorithm::Caret.rf", model.algorithms[:prediction][:method]
+    assert_equal "Algorithm::Similarity.weighted_cosine", model.algorithms[:similarity][:method]
+    nanoparticle = @training_dataset.nanoparticles[-34]
+    assert_includes nanoparticle.dataset_ids, @training_dataset.id
+    prediction = model.predict nanoparticle
+    refute_nil prediction[:value]
+    assert_includes prediction[:prediction_interval][0]..prediction[:prediction_interval][1], prediction[:measurements].median, "This assertion assures that measured values are within the prediction interval. It may fail in 5% of the predictions."
+    prediction = model.predict @training_dataset.substances[14]
+    refute_nil prediction[:value]
+    assert_includes prediction[:prediction_interval][0]..prediction[:prediction_interval][1], prediction[:measurements].median, "This assertion assures that measured values are within the prediction interval. It may fail in 5% of the predictions."
+    model.delete
+  end
+
+  def test_nanoparticle_fingerprint_model
+    assert true, @prediction_feature.measured
+    algorithms = {
+      :descriptors => {
+        :method => "fingerprint",
+        :type => "MP2D",
+      },
+      :similarity => {
+        :method => "Algorithm::Similarity.tanimoto",
+        :min => 0.1
+      },
+      :feature_selection => nil
+    }
+    model = Model::Lazar.create training_dataset: @training_dataset, prediction_feature: @prediction_feature, algorithms: algorithms
+    refute_empty model.dependent_variables
+    refute_empty model.descriptor_ids
+    refute_empty model.independent_variables
+    assert_equal "Algorithm::Caret.rf", model.algorithms[:prediction][:method]
+    assert_equal "Algorithm::Similarity.tanimoto", model.algorithms[:similarity][:method]
+    assert_nil model.algorithms[:descriptors][:categories]
+    nanoparticle = @training_dataset.nanoparticles[-34]
+    assert_includes nanoparticle.dataset_ids, @training_dataset.id
+    prediction = model.predict nanoparticle
+    refute_nil prediction[:value]
+    assert_includes prediction[:prediction_interval][0]..prediction[:prediction_interval][1], prediction[:measurements].median, "This assertion assures that measured values are within the prediction interval. It may fail in 5% of the predictions."
+    prediction = model.predict @training_dataset.substances[14]
+    refute_nil prediction[:value]
+    assert_includes prediction[:prediction_interval][0]..prediction[:prediction_interval][1], prediction[:measurements].median, "This assertion assures that measured values are within the prediction interval. It may fail in 5% of the predictions."
+    model.delete
+  end
+
+  def test_nanoparticle_fingerprint_model_with_feature_selection
+    assert true, @prediction_feature.measured
+    algorithms = {
+      :descriptors => {
+        :method => "fingerprint",
+        :type => "MP2D",
+      },
+      :similarity => {
+        :method => "Algorithm::Similarity.tanimoto",
+        :min => 0.1
+      },
+    }
+    model = Model::Lazar.create training_dataset: @training_dataset, prediction_feature: @prediction_feature, algorithms: algorithms
+    refute_empty model.algorithms[:feature_selection]
+    refute_empty model.dependent_variables
+    refute_empty model.descriptor_ids
+    refute_empty model.independent_variables
+    assert_equal "Algorithm::Caret.rf", model.algorithms[:prediction][:method]
+    assert_equal "Algorithm::Similarity.tanimoto", model.algorithms[:similarity][:method]
+    nanoparticle = @training_dataset.nanoparticles[-34]
+    assert_includes nanoparticle.dataset_ids, @training_dataset.id
+    prediction = model.predict nanoparticle
+    refute_nil prediction[:value]
+    assert_includes prediction[:prediction_interval][0]..prediction[:prediction_interval][1], prediction[:measurements].median, "This assertion assures that measured values are within the prediction interval. It may fail in 5% of the predictions."
+    prediction = model.predict @training_dataset.substances[14]
+    refute_nil prediction[:value]
+    assert_includes prediction[:prediction_interval][0]..prediction[:prediction_interval][1], prediction[:measurements].median, "This assertion assures that measured values are within the prediction interval. It may fail in 5% of the predictions."
+    model.delete
+  end
+
+  def test_nanoparticle_calculated_properties_model
+    skip "Nanoparticle calculate_properties similarity not yet implemented"
+    assert true, @prediction_feature.measured
+    algorithms = {
+      :descriptors => {
+        :method => "calculate_properties",
+        :features => PhysChem.openbabel_descriptors,
+      },
+      :similarity => {
+        :method => "Algorithm::Similarity.weighted_cosine",
+        :min => 0.5
+      },
+      :prediction => {
+        :method => "Algorithm::Regression.weighted_average",
+      },
+    }
+    model = Model::Lazar.create training_dataset: @training_dataset, prediction_feature: @prediction_feature, algorithms: algorithms
+    refute_empty model.dependent_variables
+    refute_empty model.descriptor_ids
+    refute_empty model.independent_variables
+    assert_equal "Algorithm::Caret.rf", model.algorithms[:prediction][:method]
+    assert_equal "Algorithm::Similarity.weighted", model.algorithms[:similarity][:method]
+    nanoparticle = @training_dataset.nanoparticles[-34]
+    assert_includes nanoparticle.dataset_ids, @training_dataset.id
+    prediction = model.predict nanoparticle
+    refute_nil prediction[:value]
+    assert_includes prediction[:prediction_interval][0]..prediction[:prediction_interval][1], prediction[:measurements].median, "This assertion assures that measured values are within the prediction interval. It may fail in 5% of the predictions."
+    prediction = model.predict @training_dataset.substances[14]
+    refute_nil prediction[:value]
+    assert_includes prediction[:prediction_interval][0]..prediction[:prediction_interval][1], prediction[:measurements].median, "This assertion assures that measured values are within the prediction interval. It may fail in 5% of the predictions."
+    model.delete
+  end
+
+  def test_import_ld
+    skip # Ambit JSON-LD export defunct
+    dataset_ids = Import::Enanomapper.import_ld
+  end
+end

data/test/model-regression.rb

@@ -0,0 +1,171 @@
+require_relative "setup.rb"
+
+class LazarRegressionTest < MiniTest::Test
+
+  def test_default_regression
+    algorithms = {
+      :descriptors => {
+        :method => "fingerprint",
+        :type => "MP2D"
+      },
+      :similarity => {
+        :method => "Algorithm::Similarity.tanimoto",
+        :min => 0.1
+      },
+      :prediction => {
+        :method => "Algorithm::Caret.pls",
+      },
+      :feature_selection => nil,
+    }
+    training_dataset = Dataset.from_csv_file File.join(DATA_DIR,"EPAFHM.medi_log10.csv")
+    model = Model::Lazar.create  training_dataset: training_dataset
+    assert_kind_of Model::LazarRegression, model
+    assert_equal algorithms, model.algorithms
+    substance = training_dataset.substances[10]
+    prediction = model.predict substance
+    assert_includes prediction[:prediction_interval][0]..prediction[:prediction_interval][1], prediction[:measurements].median, "This assertion assures that measured values are within the prediction interval. It may fail in 5% of the predictions."
+    substance = Compound.from_smiles "NC(=O)OCCC"
+    prediction = model.predict substance
+    refute_nil prediction[:value]
+    refute_nil prediction[:prediction_interval]
+    refute_empty prediction[:neighbors]
+  end
+
+  def test_weighted_average
+    training_dataset = Dataset.from_csv_file "#{DATA_DIR}/EPAFHM.medi_log10.csv"
+    algorithms = {
+      :similarity => {
+        :min => 0
+      },
+      :prediction => {
+        :method => "Algorithm::Regression.weighted_average",
+      },
+    }
+    model = Model::Lazar.create training_dataset: training_dataset, algorithms: algorithms
+    compound = Compound.from_smiles "CC(C)(C)CN"
+    prediction = model.predict compound
+    assert_equal -0.86, prediction[:value].round(2)
+    assert_equal model.substance_ids.size, prediction[:neighbors].size
+  end
+
+  def test_mpd_fingerprints
+    training_dataset = Dataset.from_csv_file "#{DATA_DIR}/EPAFHM.medi_log10.csv"
+    algorithms = {
+      :descriptors => {
+        :method => "fingerprint",
+        :type => "MP2D"
+      },
+    }
+    model = Model::Lazar.create training_dataset: training_dataset, algorithms: algorithms
+    compound = Compound.from_smiles "CCCSCCSCC"
+    prediction = model.predict compound
+    assert_equal 4, prediction[:neighbors].size
+    assert_equal 1.37, prediction[:value].round(2)
+  end
+
+  def test_local_physchem_regression
+    training_dataset = Dataset.from_csv_file "#{DATA_DIR}/EPAFHM.medi_log10.csv"
+    algorithms = {
+      :descriptors => {
+        :method => "calculate_properties",
+        :features => PhysChem.openbabel_descriptors,
+      },
+      :similarity => {
+        :method => "Algorithm::Similarity.weighted_cosine",
+        :min => 0.5
+      },
+    }
+    model = Model::Lazar.create(training_dataset:training_dataset, algorithms:algorithms)
+    compound = Compound.from_smiles "NC(=O)OCCC"
+    prediction = model.predict compound
+    refute_nil prediction[:value]
+  end
+
+  def test_local_physchem_regression_with_feature_selection
+    training_dataset = Dataset.from_csv_file "#{DATA_DIR}/EPAFHM.medi_log10.csv"
+    algorithms = {
+      :descriptors => {
+        :method => "calculate_properties",
+        :features => PhysChem.openbabel_descriptors,
+      },
+      :similarity => {
+        :method => "Algorithm::Similarity.weighted_cosine",
+        :min => 0.5
+      },
+      :feature_selection => {
+        :method => "Algorithm::FeatureSelection.correlation_filter",
+      },
+    }
+    model = Model::Lazar.create(training_dataset:training_dataset, algorithms:algorithms)
+    compound = Compound.from_smiles "NC(=O)OCCC"
+    prediction = model.predict compound
+    refute_nil prediction[:value]
+  end
+
+  def test_unweighted_cosine_physchem_regression
+    algorithms = {
+      :descriptors => {
+        :method => "calculate_properties",
+        :features => PhysChem.openbabel_descriptors,
+      },
+      :similarity => {
+        :method => "Algorithm::Similarity.cosine",
+      }
+    }
+    training_dataset = Dataset.from_csv_file File.join(DATA_DIR,"EPAFHM.mini_log10.csv")
+    model = Model::Lazar.create  training_dataset: training_dataset, algorithms: algorithms
+    assert_kind_of Model::LazarRegression, model
+    assert_equal "Algorithm::Caret.pls", model.algorithms[:prediction][:method]
+    assert_equal "Algorithm::Similarity.cosine", model.algorithms[:similarity][:method]
+    assert_equal 0.1, model.algorithms[:similarity][:min]
+    algorithms[:descriptors].delete :features
+    assert_equal algorithms[:descriptors], model.algorithms[:descriptors]
+    prediction = model.predict training_dataset.substances[10]
+    refute_nil prediction[:value]
+  end
+
+  def test_regression_with_feature_selection
+    algorithms = {
+      :feature_selection => {
+        :method => "Algorithm::FeatureSelection.correlation_filter",
+      },
+    }
+    training_dataset = Dataset.from_csv_file File.join(DATA_DIR,"EPAFHM.mini_log10.csv")
+    model = Model::Lazar.create  training_dataset: training_dataset, algorithms: algorithms
+    assert_kind_of Model::LazarRegression, model
+    assert_equal "Algorithm::Caret.pls", model.algorithms[:prediction][:method]
+    assert_equal "Algorithm::Similarity.tanimoto", model.algorithms[:similarity][:method]
+    assert_equal 0.1, model.algorithms[:similarity][:min]
+    assert_equal algorithms[:feature_selection][:method], model.algorithms[:feature_selection][:method]
+    prediction = model.predict training_dataset.substances[10]
+    refute_nil prediction[:value]
+  end
+
+  def test_regression_parameters
+    algorithms = {
+      :descriptors => {
+        :method => "fingerprint",
+        :type => "MP2D"
+      },
+      :similarity => {
+        :method => "Algorithm::Similarity.tanimoto",
+        :min => 0.3
+      },
+      :prediction => {
+        :method => "Algorithm::Regression.weighted_average",
+      },
+      :feature_selection => nil,
+    }
+    training_dataset = Dataset.from_csv_file File.join(DATA_DIR,"EPAFHM.medi_log10.csv")
+    model = Model::Lazar.create  training_dataset: training_dataset, algorithms: algorithms
+    assert_kind_of Model::LazarRegression, model
+    assert_equal "Algorithm::Regression.weighted_average", model.algorithms[:prediction][:method]
+    assert_equal "Algorithm::Similarity.tanimoto", model.algorithms[:similarity][:method]
+    assert_equal algorithms[:similarity][:min], model.algorithms[:similarity][:min]
+    assert_equal algorithms[:prediction][:parameters], model.algorithms[:prediction][:parameters]
+    substance = training_dataset.substances[10]
+    prediction = model.predict substance
+    assert_equal 0.83, prediction[:value].round(2)
+  end
+
+end

data/test/model-validation.rb

@@ -0,0 +1,19 @@
+require_relative "setup.rb"
+
+class ValidationModelTest < MiniTest::Test
+
+  def test_validation_model
+    m = Model::Validation.from_csv_file "#{DATA_DIR}/hamster_carcinogenicity.csv"
+    [:endpoint,:species,:source].each do |p|
+      refute_empty m[p]
+    end
+    assert m.classification?
+    refute m.regression?
+    m.crossvalidations.each do |cv|
+      assert cv.accuracy > 0.74, "Crossvalidation accuracy (#{cv.accuracy}) should be larger than 0.75. This may happen due to an unfavorable training/test set split."
+    end
+    prediction = m.predict Compound.from_smiles("CCCC(NN)C")
+    assert_equal "true", prediction[:value]
+    m.delete
+  end
+end

data/test/nanomaterial-model-validation.rb

@@ -0,0 +1,55 @@
+require_relative "setup.rb"
+
+class NanomaterialValidationModelTest < MiniTest::Test
+
+  def setup
+    @training_dataset = Dataset.where(:name => "Protein Corona Fingerprinting Predicts the Cellular Interaction of Gold and Silver Nanoparticles").first
+    @prediction_feature = @training_dataset.features.select{|f| f["name"] == 'log2(Net cell association)'}.first
+  end
+
+  def test_default_nanomaterial_validation_model
+    validation_model = Model::NanoValidation.create
+    [:endpoint,:species,:source].each do |p|
+      refute_empty validation_model[p]
+    end
+    assert validation_model.regression?
+    refute validation_model.classification?
+    validation_model.crossvalidations.each do |cv|
+      refute_nil cv.r_squared
+      refute_nil cv.rmse
+    end
+    nanoparticle = @training_dataset.nanoparticles[-34]
+    assert_includes nanoparticle.dataset_ids, @training_dataset.id
+    prediction = validation_model.predict nanoparticle
+    refute_nil prediction[:value]
+    assert_includes prediction[:prediction_interval][0]..prediction[:prediction_interval][1], prediction[:measurements].median, "This assertion assures that measured values are within the prediction interval. It may fail in 5% of the predictions."
+    validation_model.delete
+  end
+
+  def test_nanomaterial_validation_model_parameters
+    algorithms = {
+      :descriptors => {
+        :method => "fingerprint",
+        :type => "MP2D",
+      },
+      :similarity => {
+        :method => "Algorithm::Similarity.tanimoto",
+        :min => 0.1
+      },
+      :prediction => { :method => "OpenTox::Algorithm::Regression.weighted_average" },
+      :feature_selection => nil
+    }
+    validation_model = Model::NanoValidation.create algorithms: algorithms
+    assert validation_model.regression?
+    refute validation_model.classification?
+    validation_model.crossvalidations.each do |cv|
+      refute_nil cv.r_squared
+      refute_nil cv.rmse
+    end
+    nanoparticle = @training_dataset.nanoparticles[-34]
+    assert_includes nanoparticle.dataset_ids, @training_dataset.id
+    prediction = validation_model.predict nanoparticle
+    refute_nil prediction[:value]
+    assert_includes prediction[:prediction_interval][0]..prediction[:prediction_interval][1], prediction[:measurements].median, "This assertion assures that measured values are within the prediction interval. It may fail in 5% of the predictions."
+  end
+end

data/test/setup.rb

@@ -1,9 +1,13 @@
 ENV["LAZAR_ENV"] = "development"
 require 'minitest/autorun'
-#require_relative '../lib/lazar.rb'
-require 'lazar'
+require_relative '../lib/lazar.rb'
+#require 'lazar'
 include OpenTox
 TEST_DIR ||= File.expand_path(File.dirname(__FILE__))
 DATA_DIR ||= File.join(TEST_DIR,"data")
-$mongo.database.drop
-$gridfs = $mongo.database.fs
+training_dataset = Dataset.where(:name => "Protein Corona Fingerprinting Predicts the Cellular Interaction of Gold and Silver Nanoparticles").first
+unless training_dataset
+  Import::Enanomapper.import File.join(File.dirname(__FILE__),"data","enm")
+end
+#$mongo.database.drop
+#$gridfs = $mongo.database.fs

data/test/validation-classification.rb

@@ -0,0 +1,67 @@
+require_relative "setup.rb"
+
+class ValidationClassificationTest < MiniTest::Test
+  include OpenTox::Validation
+
+  # defaults
+  
+  def test_default_classification_crossvalidation
+    dataset = Dataset.from_csv_file "#{DATA_DIR}/hamster_carcinogenicity.csv"
+    model = Model::Lazar.create training_dataset: dataset
+    cv = ClassificationCrossValidation.create model
+    assert cv.accuracy > 0.7, "Accuracy (#{cv.accuracy}) should be larger than 0.7, this may occur due to an unfavorable training/test set split"
+    assert cv.weighted_accuracy > cv.accuracy, "Weighted accuracy (#{cv.weighted_accuracy}) should be larger than accuracy (#{cv.accuracy})."
+    File.open("/tmp/tmp.pdf","w+"){|f| f.puts cv.probability_plot(format:"pdf")}
+    p `file -b /tmp/tmp.pdf`
+    File.open("/tmp/tmp.png","w+"){|f| f.puts cv.probability_plot(format:"png")}
+    p `file -b /tmp/tmp.png`
+  end
+
+  # parameters
+
+  def test_classification_crossvalidation_parameters
+    dataset = Dataset.from_csv_file "#{DATA_DIR}/hamster_carcinogenicity.csv"
+    algorithms = {
+      :similarity => { :min => 0.3, },
+      :descriptors => { :type => "FP3" }
+    }
+    model = Model::Lazar.create training_dataset: dataset, algorithms: algorithms
+    cv = ClassificationCrossValidation.create model
+    params = model.algorithms
+    params = Hash[params.map{ |k, v| [k.to_s, v] }] # convert symbols to string
+    
+    cv.validations.each do |validation|
+      validation_params = validation.model.algorithms
+      refute_nil model.training_dataset_id
+      refute_nil validation.model.training_dataset_id
+      refute_equal model.training_dataset_id, validation.model.training_dataset_id
+      ["min_sim","type","prediction_feature_id"].each do |k|
+        assert_equal params[k], validation_params[k]
+      end
+    end
+  end
+  
+  # LOO
+
+  def test_classification_loo_validation
+    dataset = Dataset.from_csv_file "#{DATA_DIR}/hamster_carcinogenicity.csv"
+    model = Model::Lazar.create training_dataset: dataset
+    loo = ClassificationLeaveOneOut.create model
+    assert_equal 14, loo.nr_unpredicted
+    refute_empty loo.confusion_matrix
+    assert loo.accuracy > 0.77
+    assert loo.weighted_accuracy > loo.accuracy, "Weighted accuracy (#{loo.weighted_accuracy}) should be larger than accuracy (#{loo.accuracy})."
+  end
+
+  # repeated CV
+
+  def test_repeated_crossvalidation
+    dataset = Dataset.from_csv_file "#{DATA_DIR}/hamster_carcinogenicity.csv"
+    model = Model::Lazar.create training_dataset: dataset
+    repeated_cv = RepeatedCrossValidation.create model
+    repeated_cv.crossvalidations.each do |cv|
+      assert_operator cv.accuracy, :>, 0.7, "model accuracy < 0.7, this may happen by chance due to an unfavorable training/test set split"
+    end
+  end
+
+end