def test_conversion_multiindex_dynamic(self):
# test dynamic target_col_id setting with multiindex
coords = [[0, 0, 0], [0.75, 0.5, 0.75]]
lattice = Lattice([[3.8401979337, 0.00, 0.00],
[1.9200989668, 3.3257101909, 0.00],
[0.00, -2.2171384943, 3.1355090603]])
struct = Structure(lattice, ["Si"] * 2, coords)
d = {'structure_dict': [struct.as_dict(), struct.as_dict()]}
df_2lvl = DataFrame(data=d)
df_2lvl.columns = MultiIndex.from_product((["custom"],
df_2lvl.columns.values))
dto = DictToObject()
df_2lvl = dto.featurize_dataframe(df_2lvl, ('custom', 'structure_dict'),
multiindex=True)
new_col_id = ('DictToObject', 'structure_dict_object')
self.assertEqual(df_2lvl[new_col_id].tolist()[0], struct)
self.assertEqual(df_2lvl[new_col_id].tolist()[1], struct)
def test_dict_to_object(self):
coords = [[0, 0, 0], [0.75, 0.5, 0.75]]
lattice = Lattice([[3.8401979337, 0.00, 0.00],
[1.9200989668, 3.3257101909, 0.00],
[0.00, -2.2171384943, 3.1355090603]])
struct = Structure(lattice, ["Si"] * 2, coords)
d = {'structure_dict': [struct.as_dict(), struct.as_dict()]}
df = DataFrame(data=d)
dto = DictToObject(target_col_id='structure')
df = dto.featurize_dataframe(df, 'structure_dict')
self.assertEqual(df["structure"].tolist()[0], struct)
self.assertEqual(df["structure"].tolist()[1], struct)
# test dynamic target_col_id setting
df = DataFrame(data=d)
dto = DictToObject()
df = dto.featurize_dataframe(df, 'structure_dict')
self.assertEqual(df["structure_dict_object"].tolist()[0], struct)
self.assertEqual(df["structure_dict_object"].tolist()[1], struct)
def _tidy_column(self, df, featurizer_type):
"""
Various conversions to homogenize columns for featurization input.
For example, take a column of compositions and ensure they are decorated
with oxidation states, are not strings, etc.
Args:
df (pandas.DataFrame)
featurizer_type: The key defining the featurizer input. For example,
composition featurizers should have featurizer_type of
"composition".
Returns:
df (pandas.DataFrame): DataFrame with featurizer_type column
ready for featurization.
"""
# todo: Make the following conversions more robust (no [0] type checking)
type_tester = df[featurizer_type].iloc[0]
if featurizer_type == self.composition_col:
# Convert formulas to composition objects
if isinstance(type_tester, str):
self.logger.info(
self._log_prefix +
"Compositions detected as strings. Attempting "
"conversion to Composition objects...")
stc = StrToComposition(overwrite_data=True,
target_col_id=featurizer_type)
df = stc.featurize_dataframe(df,
featurizer_type,
multiindex=self.multiindex,
ignore_errors=True,
inplace=False)
elif isinstance(type_tester, dict):
self.logger.info(self._log_prefix +
"Compositions detected as dicts. Attempting "
"conversion to Composition objects...")
df[featurizer_type] = [
Composition.from_dict(d) for d in df[featurizer_type]
]
# Convert non-oxidstate containing comps to oxidstate comps
if self.guess_oxistates:
self.logger.info(
self._log_prefix +
"Guessing oxidation states of compositions, as"
" they were not present in input.")
cto = CompositionToOxidComposition(
target_col_id=featurizer_type,
overwrite_data=True,
return_original_on_error=True,
max_sites=-50)
try:
df = cto.featurize_dataframe(df,
featurizer_type,
multiindex=self.multiindex,
inplace=False)
except Exception as e:
self.logger.info(self._log_prefix +
"Could not decorate oxidation states due "
"to {}. Excluding featurizers based on "
"composition oxistates".format(e))
classes_require_oxi = [
c.__class__.__name__
for c in CompositionFeaturizers().need_oxi
]
self.exclude.extend(classes_require_oxi)
else:
# Convert structure/bs/dos dicts to objects (robust already)
if isinstance(type_tester, (dict, str)):
self.logger.info(self._log_prefix.capitalize() +
"{} detected as string or dict. Attempting "
"conversion to {} objects..."
"".format(featurizer_type, featurizer_type))
if isinstance(type_tester, str):
raise ValueError("{} column is type {}. Cannot convert."
"".format(featurizer_type,
type(type_tester)))
dto = DictToObject(overwrite_data=True,
target_col_id=featurizer_type)
df = dto.featurize_dataframe(df,
featurizer_type,
inplace=False)
# Decorate with oxidstates
if featurizer_type == self.structure_col and \
self.guess_oxistates:
self.logger.info(
self._log_prefix +
"Guessing oxidation states of structures if they were "
"not present in input.")
sto = StructureToOxidStructure(
target_col_id=featurizer_type,
overwrite_data=True,
return_original_on_error=True,
max_sites=-50)
try:
df = sto.featurize_dataframe(
df,
featurizer_type,
multiindex=self.multiindex,
inplace=False)
except Exception as e:
self.logger.info(
self._log_prefix +
"Could not decorate oxidation states on structures "
"due to {}.".format(e))
return df