def test_featurize_bsdos(self, refresh_df_init=False, limit=1): """ Tests featurize_dos and featurize_bandstructure. Args: refresh_df_init (bool): for developers, if the test need to be updated set to True. Otherwise set to False to make the final test independent of MPRester and faster. limit (int): the maximum final number of entries. Returns (None): """ target = "color" df_bsdos_pickled = "mp_data_with_dos_bandstructure.pickle" if refresh_df_init: mpdr = MPDataRetrieval() df = mpdr.get_dataframe(criteria={"material_id": "mp-149"}, properties=[ "pretty_formula", "dos", "bandstructure", "bandstructure_uniform" ]) df.to_pickle(os.path.join(TEST_DIR, df_bsdos_pickled)) else: df = pd.read_pickle(os.path.join(TEST_DIR, df_bsdos_pickled)) df = df.dropna(axis=0) df = df.rename( columns={ "bandstructure_uniform": "bandstructure", "bandstructure": "line bandstructure" }) df[target] = [["red"]] n_cols_init = df.shape[1] featurizer = AutoFeaturizer(preset="express", ignore_errors=False, multiindex=False) df = featurizer.fit_transform(df, target) # sanity checks self.assertTrue(len(df), limit) self.assertGreater(len(df.columns), n_cols_init) # DOSFeaturizer: self.assertEqual(df["cbm_character_1"][0], "p") # DopingFermi: self.assertAlmostEqual(df["fermi_c1e+20T300"][0], -0.539, 3) # Hybridization: self.assertAlmostEqual(df["vbm_sp"][0], 0.181, 3) self.assertAlmostEqual(df["cbm_s"][0], 0.4416, 3) self.assertAlmostEqual(df["cbm_sp"][0], 0.9864, 3) # BandFeaturizer: self.assertAlmostEqual(df["direct_gap"][0], 2.556, 3) self.assertAlmostEqual(df["n_ex1_norm"][0], 0.6285, 4) # BranchPointEnergy: self.assertAlmostEqual(df["branch_point_energy"][0], 5.7677, 4)
def test_column_attr(self): """ Test that the autofeaturizer object correctly takes in composition_col, structure_col, bandstruct_col, and dos_col, and checks that fit_and_transform() works correctly with the attributes. """ # Modification of test_featurize_composition with AutoFeaturizer parameter target = "K_VRH" df = copy.copy(self.test_df[['composition', target]].iloc[:self.limit]) af = AutoFeaturizer(composition_col="composition", preset="best", ignore_errors=False) df = af.fit_transform(df, target) self.assertEqual(df["LUMO_element"].iloc[0], "Nb") self.assertTrue("composition" not in df.columns) df = self.test_df[["composition", target]].iloc[:self.limit] df["composition"] = [Composition(s) for s in df["composition"]] af = AutoFeaturizer(composition_col="composition", preset="best") df = af.fit_transform(df, target) self.assertEqual(df["LUMO_element"].iloc[0], "Nb") self.assertTrue("composition" not in df.columns) # Modification of test_featurize_structure with AutoFeaturizer parameter target = "K_VRH" df = copy.copy(self.test_df[['structure', target]].iloc[:self.limit]) af = AutoFeaturizer(structure_col="structure", preset="fast") df = af.fit_transform(df, target) self.assertTrue("vpa" in df.columns) self.assertTrue("HOMO_character" in df.columns) self.assertTrue("composition" not in df.columns) self.assertTrue("structure" not in df.columns) df = copy.copy(self.test_df[['structure', target]].iloc[:self.limit]) df["structure"] = [s.as_dict() for s in df["structure"]] af = AutoFeaturizer(structure_col="structure", preset="fast") df = af.fit_transform(df, target) self.assertTrue("vpa" in df.columns) self.assertTrue("HOMO_character" in df.columns) self.assertTrue("composition" not in df.columns) self.assertTrue("structure" not in df.columns)
def test_presets(self): target = "K_VRH" df = copy.copy(self.test_df.iloc[:self.limit]) af = AutoFeaturizer(preset="fast") df = af.fit_transform(df, target) known_feats = CompositionFeaturizers().fast + \ StructureFeaturizers().fast n_structure_featurizers = len(af.featurizers["structure"]) n_composition_featurizers = len(af.featurizers["composition"]) n_featurizers = n_structure_featurizers + n_composition_featurizers self.assertEqual(n_featurizers, len(known_feats))
def test_featurize_composition(self): """ Test automatic featurization while only considering formula/composition. """ target = "K_VRH" # When compositions are strings df = copy.copy(self.test_df[["composition", target]].iloc[: self.limit]) af = AutoFeaturizer(preset="express") df = af.fit_transform(df, target) self.assertAlmostEqual(df["MagpieData minimum Number"].iloc[2], 14.0) self.assertTrue("composition" not in df.columns) # When compositions are Composition objects df = self.test_df[["composition", target]].iloc[: self.limit] df["composition"] = [Composition(s) for s in df["composition"]] af = AutoFeaturizer(preset="express") df = af.fit_transform(df, target) self.assertAlmostEqual(df["MagpieData minimum Number"].iloc[2], 14.0) self.assertTrue("composition" not in df.columns)
def test_use_metaselector(self): # Test to see if metaselector works for this dataset df = copy.copy(self.test_df.iloc[:self.limit]) target = "K_VRH" af = AutoFeaturizer() af.fit(df, target) self.assertIsNotNone(af.metaselector) dataset_mfs = af.metaselector.dataset_mfs self.assertIn("composition_metafeatures", dataset_mfs.keys()) self.assertIn("structure_metafeatures", dataset_mfs.keys()) self.assertIsNotNone(dataset_mfs["composition_metafeatures"]) self.assertIsNotNone(dataset_mfs["structure_metafeatures"]) comp_mfs = dataset_mfs["composition_metafeatures"] self.assertEqual(comp_mfs["number_of_compositions"], 5) self.assertAlmostEqual(comp_mfs["percent_of_all_metal"], 0.2) self.assertAlmostEqual(comp_mfs["percent_of_metal_nonmetal"], 0.8) self.assertAlmostEqual(comp_mfs["percent_of_all_nonmetal"], 0.0) self.assertAlmostEqual(comp_mfs["percent_of_contain_trans_metal"], 0.8) self.assertEqual(comp_mfs["number_of_different_elements"], 7) self.assertAlmostEqual(comp_mfs["avg_number_of_elements"], 2.2) self.assertEqual(comp_mfs["max_number_of_elements"], 3) self.assertEqual(comp_mfs["min_number_of_elements"], 1) struct_mfs = dataset_mfs["structure_metafeatures"] self.assertEqual(struct_mfs["number_of_structures"], 5) self.assertAlmostEqual(struct_mfs["percent_of_ordered_structures"], 1.0) self.assertAlmostEqual(struct_mfs["avg_number_of_sites"], 7.0) self.assertEqual(struct_mfs["max_number_of_sites"], 12) self.assertEqual( struct_mfs["number_of_different_elements_in_structures"], 7) excludes = af.metaselector.excludes self.assertIn("IonProperty", excludes) self.assertIn("Miedema", excludes) self.assertIn("OxidationStates", excludes) self.assertIn("YangSolidSolution", excludes) self.assertIn("TMetalFraction", excludes) self.assertIn("ElectronegativityDiff", excludes) self.assertIn("CationProperty", excludes) self.assertIn("ElectronAffinity", excludes) df = af.fit_transform(df, target) ef = ElectronAffinity() ef_feats = ef.feature_labels() self.assertFalse(any([f in df.columns for f in ef_feats])) self.assertFalse(any([f in df.columns for f in ef_feats]))
def test_featurize_composition(self): """ Test automatic featurization while only considering formula/composition. """ target = "K_VRH" # When compositions are strings df = copy.copy(self.test_df[['composition', target]].iloc[:self.limit]) af = AutoFeaturizer(preset="fast") df = af.fit_transform(df, target) self.assertAlmostEqual(df["frac f valence electrons"].iloc[2], 0.5384615384615384) self.assertEqual(df["LUMO_element"].iloc[0], "Nb") self.assertTrue("composition" not in df.columns) # When compositions are Composition objects df = self.test_df[["composition", target]].iloc[:self.limit] df["composition"] = [Composition(s) for s in df["composition"]] af = AutoFeaturizer(preset="fast") df = af.fit_transform(df, target) self.assertAlmostEqual(df["frac f valence electrons"].iloc[2], 0.5384615384615384) self.assertEqual(df["LUMO_element"].iloc[0], "Nb") self.assertTrue("composition" not in df.columns)
def test_presets(self): target = "K_VRH" df = copy.copy(self.test_df.iloc[: self.limit]) af = AutoFeaturizer(preset="express") df = af.fit_transform(df, target) known_feats = ( CompositionFeaturizers().express + StructureFeaturizers().express ) n_structure_featurizers = len(af.featurizers["structure"]) n_composition_featurizers = len(af.featurizers["composition"]) n_removed_featurizers = len(af.removed_featurizers) n_featurizers = ( n_structure_featurizers + n_composition_featurizers + n_removed_featurizers ) self.assertEqual(n_featurizers, len(known_feats))
def test_exclude_by_users(self): """ Test custom args for featurizers to use. """ df = copy.copy(self.test_df.iloc[:self.limit]) target = "K_VRH" exclude = ["ElementProperty"] ep = ElementProperty.from_preset("matminer") ep_feats = ep.feature_labels() # Test to make sure excluded does not show up af = AutoFeaturizer(exclude=exclude, preset="fast") af.fit(df, target) df = af.fit_transform(df, target) self.assertTrue(af.auto_featurizer) self.assertIn("ElementProperty", af.exclude) self.assertFalse(any([f in df.columns for f in ep_feats]))
def test_featurizers_by_users(self): df = copy.copy(self.test_df.iloc[:self.limit]) target = "K_VRH" dn = DensityFeatures() gsf = GlobalSymmetryFeatures() featurizers = {"structure": [dn, gsf]} af = AutoFeaturizer(featurizers=featurizers) df = af.fit_transform(df, target) # Ensure that the featurizers are not set automatically, metaselection # is not used, exclude is None and featurizers not passed by the users # are not used. self.assertFalse(af.auto_featurizer) self.assertTrue(af.exclude == []) self.assertIn(dn, af.featurizers["structure"]) self.assertIn(gsf, af.featurizers["structure"]) ep = ElementProperty.from_preset("matminer") ep_feats = ep.feature_labels() self.assertFalse(any([f in df.columns for f in ep_feats]))