Skip to content

Featurizers

matgpr.featurizers

CompositionFeaturizer

Bases: BaseEstimator, TransformerMixin

Scikit-learn-style transformer for inorganic composition descriptors.

The transformer wraps :func:matgpr.featurize_compositions, preserving the same pymatgen-backed elemental-property descriptors while adding familiar fit, transform, fit_transform, and get_feature_names_out methods.

Source code in matgpr/featurizers.py 
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
class CompositionFeaturizer(BaseEstimator, TransformerMixin):
    """Scikit-learn-style transformer for inorganic composition descriptors.

    The transformer wraps :func:`matgpr.featurize_compositions`, preserving the
    same pymatgen-backed elemental-property descriptors while adding familiar
    ``fit``, ``transform``, ``fit_transform``, and ``get_feature_names_out``
    methods.
    """

    def __init__(
        self,
        *,
        formula_column: str | int | None = None,
        properties: Sequence[str] = DEFAULT_ELEMENTAL_PROPERTIES,
        statistics: Sequence[str] = DEFAULT_COMPOSITION_STATISTICS,
        column_prefix: str | None = None,
        errors: str = "raise",
        cache_dir: str | Path | None = None,
        return_dataframe: bool = True,
    ):
        self.formula_column = formula_column
        self.properties = properties
        self.statistics = statistics
        self.column_prefix = column_prefix
        self.errors = errors
        self.cache_dir = cache_dir
        self.return_dataframe = return_dataframe

    def fit(self, X, y=None):
        """Store input-column metadata and deterministic descriptor names."""
        _validate_errors(self.errors)
        _set_input_metadata(self, X)
        self.formula_column_ = _resolve_column(X, self.formula_column, kind="formula")
        feature_names = _composition_feature_names(
            properties=self.properties,
            statistics=self.statistics,
            column_prefix=self.column_prefix,
        )
        self.feature_names_out_ = np.asarray(feature_names, dtype=object)
        self.n_features_out_ = len(self.feature_names_out_)
        return self

    def transform(self, X):
        """Transform formulas into numeric composition descriptors."""
        check_is_fitted(self, "feature_names_out_")
        formulas, index = _extract_values(X, self.formula_column_, kind="formula")
        result = featurize_compositions(
            formulas,
            properties=self.properties,
            statistics=self.statistics,
            errors=self.errors,
            cache_dir=self.cache_dir,
        )
        features = result.features.copy()
        features.columns = self.feature_names_out_
        features.index = index
        self.failed_ = result.failed
        self.cache_keys_ = result.cache_keys.set_axis(index)
        self.cache_hit_ = result.cache_hit.set_axis(index)
        self.last_result_ = result
        return _format_transform_output(features, self.return_dataframe)

    def get_feature_names_out(self, input_features=None) -> np.ndarray:
        """Return output descriptor names."""
        check_is_fitted(self, "feature_names_out_")
        _validate_input_features(self, input_features)
        return self.feature_names_out_.copy()

fit(X, y=None)

Store input-column metadata and deterministic descriptor names.

Source code in matgpr/featurizers.py 
103
104
105
106
107
108
109
110
111
112
113
114
115
def fit(self, X, y=None):
    """Store input-column metadata and deterministic descriptor names."""
    _validate_errors(self.errors)
    _set_input_metadata(self, X)
    self.formula_column_ = _resolve_column(X, self.formula_column, kind="formula")
    feature_names = _composition_feature_names(
        properties=self.properties,
        statistics=self.statistics,
        column_prefix=self.column_prefix,
    )
    self.feature_names_out_ = np.asarray(feature_names, dtype=object)
    self.n_features_out_ = len(self.feature_names_out_)
    return self

transform(X)

Transform formulas into numeric composition descriptors.

Source code in matgpr/featurizers.py 
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
def transform(self, X):
    """Transform formulas into numeric composition descriptors."""
    check_is_fitted(self, "feature_names_out_")
    formulas, index = _extract_values(X, self.formula_column_, kind="formula")
    result = featurize_compositions(
        formulas,
        properties=self.properties,
        statistics=self.statistics,
        errors=self.errors,
        cache_dir=self.cache_dir,
    )
    features = result.features.copy()
    features.columns = self.feature_names_out_
    features.index = index
    self.failed_ = result.failed
    self.cache_keys_ = result.cache_keys.set_axis(index)
    self.cache_hit_ = result.cache_hit.set_axis(index)
    self.last_result_ = result
    return _format_transform_output(features, self.return_dataframe)

get_feature_names_out(input_features=None)

Return output descriptor names.

Source code in matgpr/featurizers.py 
137
138
139
140
141
def get_feature_names_out(self, input_features=None) -> np.ndarray:
    """Return output descriptor names."""
    check_is_fitted(self, "feature_names_out_")
    _validate_input_features(self, input_features)
    return self.feature_names_out_.copy()

MagpieCompositionFeaturizer

Bases: BaseEstimator, TransformerMixin

Scikit-learn-style wrapper for matminer Magpie composition descriptors.

Magpie descriptors summarize elemental properties with composition-weighted statistics. This transformer keeps matminer optional: the backend is imported only when fit or the low-level Magpie helper functions are called.

Source code in matgpr/featurizers.py 
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
class MagpieCompositionFeaturizer(BaseEstimator, TransformerMixin):
    """Scikit-learn-style wrapper for matminer Magpie composition descriptors.

    Magpie descriptors summarize elemental properties with composition-weighted
    statistics. This transformer keeps `matminer` optional: the backend is
    imported only when ``fit`` or the low-level Magpie helper functions are
    called.
    """

    def __init__(
        self,
        *,
        formula_column: str | int | None = None,
        properties: Sequence[str] | None = None,
        statistics: Sequence[str] | None = None,
        column_prefix: str | None = "magpie",
        impute_nan: bool = True,
        errors: str = "raise",
        return_dataframe: bool = True,
    ):
        self.formula_column = formula_column
        self.properties = properties
        self.statistics = statistics
        self.column_prefix = column_prefix
        self.impute_nan = impute_nan
        self.errors = errors
        self.return_dataframe = return_dataframe

    def fit(self, X, y=None):
        """Store input-column metadata and Magpie descriptor names."""
        _validate_errors(self.errors)
        _set_input_metadata(self, X)
        self.formula_column_ = _resolve_column(X, self.formula_column, kind="formula")
        self.magpie_featurizer_ = _build_magpie_featurizer(
            properties=self.properties,
            statistics=self.statistics,
            impute_nan=self.impute_nan,
        )
        self.feature_names_out_ = np.asarray(
            _magpie_feature_names(
                self.magpie_featurizer_.feature_labels(),
                column_prefix=self.column_prefix,
            ),
            dtype=object,
        )
        self.n_features_out_ = len(self.feature_names_out_)
        return self

    def transform(self, X):
        """Transform formulas into matminer Magpie composition descriptors."""
        check_is_fitted(self, ["feature_names_out_", "magpie_featurizer_"])
        formulas, index = _extract_values(X, self.formula_column_, kind="formula")
        result = _featurize_magpie_compositions_with_backend(
            formulas,
            featurizer=self.magpie_featurizer_,
            feature_names=self.feature_names_out_,
            errors=self.errors,
        )
        features = result.features.copy()
        features.index = index
        self.failed_ = result.failed
        self.last_result_ = result
        return _format_transform_output(features, self.return_dataframe)

    def get_feature_names_out(self, input_features=None) -> np.ndarray:
        """Return output Magpie descriptor names."""
        check_is_fitted(self, "feature_names_out_")
        _validate_input_features(self, input_features)
        return self.feature_names_out_.copy()

fit(X, y=None)

Store input-column metadata and Magpie descriptor names.

Source code in matgpr/featurizers.py 
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
def fit(self, X, y=None):
    """Store input-column metadata and Magpie descriptor names."""
    _validate_errors(self.errors)
    _set_input_metadata(self, X)
    self.formula_column_ = _resolve_column(X, self.formula_column, kind="formula")
    self.magpie_featurizer_ = _build_magpie_featurizer(
        properties=self.properties,
        statistics=self.statistics,
        impute_nan=self.impute_nan,
    )
    self.feature_names_out_ = np.asarray(
        _magpie_feature_names(
            self.magpie_featurizer_.feature_labels(),
            column_prefix=self.column_prefix,
        ),
        dtype=object,
    )
    self.n_features_out_ = len(self.feature_names_out_)
    return self

transform(X)

Transform formulas into matminer Magpie composition descriptors.

Source code in matgpr/featurizers.py 
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
def transform(self, X):
    """Transform formulas into matminer Magpie composition descriptors."""
    check_is_fitted(self, ["feature_names_out_", "magpie_featurizer_"])
    formulas, index = _extract_values(X, self.formula_column_, kind="formula")
    result = _featurize_magpie_compositions_with_backend(
        formulas,
        featurizer=self.magpie_featurizer_,
        feature_names=self.feature_names_out_,
        errors=self.errors,
    )
    features = result.features.copy()
    features.index = index
    self.failed_ = result.failed
    self.last_result_ = result
    return _format_transform_output(features, self.return_dataframe)

get_feature_names_out(input_features=None)

Return output Magpie descriptor names.

Source code in matgpr/featurizers.py 
208
209
210
211
212
def get_feature_names_out(self, input_features=None) -> np.ndarray:
    """Return output Magpie descriptor names."""
    check_is_fitted(self, "feature_names_out_")
    _validate_input_features(self, input_features)
    return self.feature_names_out_.copy()

StructureFeaturizer

Bases: BaseEstimator, TransformerMixin

Scikit-learn-style transformer for global crystal-structure descriptors.

Source code in matgpr/featurizers.py 
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
class StructureFeaturizer(BaseEstimator, TransformerMixin):
    """Scikit-learn-style transformer for global crystal-structure descriptors."""

    def __init__(
        self,
        *,
        structure_column: str | int | None = None,
        features: Sequence[str] = DEFAULT_STRUCTURE_FEATURES,
        column_prefix: str | None = None,
        errors: str = "raise",
        cache_dir: str | Path | None = None,
        return_dataframe: bool = True,
    ):
        self.structure_column = structure_column
        self.features = features
        self.column_prefix = column_prefix
        self.errors = errors
        self.cache_dir = cache_dir
        self.return_dataframe = return_dataframe

    def fit(self, X, y=None):
        """Store input-column metadata and deterministic descriptor names."""
        _validate_errors(self.errors)
        _set_input_metadata(self, X)
        self.structure_column_ = _resolve_column(X, self.structure_column, kind="structure")
        self.feature_names_out_ = np.asarray(
            structure_feature_names(self.features, column_prefix=self.column_prefix),
            dtype=object,
        )
        self.n_features_out_ = len(self.feature_names_out_)
        return self

    def transform(self, X):
        """Transform structures into numeric lattice and packing descriptors."""
        check_is_fitted(self, "feature_names_out_")
        structures, index = _extract_values(X, self.structure_column_, kind="structure")
        result = featurize_structures(
            structures,
            features=self.features,
            errors=self.errors,
            cache_dir=self.cache_dir,
        )
        features = result.features.copy()
        features.columns = self.feature_names_out_
        features.index = index
        self.failed_ = result.failed
        self.cache_keys_ = result.cache_keys.set_axis(index)
        self.cache_hit_ = result.cache_hit.set_axis(index)
        self.last_result_ = result
        return _format_transform_output(features, self.return_dataframe)

    def get_feature_names_out(self, input_features=None) -> np.ndarray:
        """Return output descriptor names."""
        check_is_fitted(self, "feature_names_out_")
        _validate_input_features(self, input_features)
        return self.feature_names_out_.copy()

fit(X, y=None)

Store input-column metadata and deterministic descriptor names.

Source code in matgpr/featurizers.py 
235
236
237
238
239
240
241
242
243
244
245
def fit(self, X, y=None):
    """Store input-column metadata and deterministic descriptor names."""
    _validate_errors(self.errors)
    _set_input_metadata(self, X)
    self.structure_column_ = _resolve_column(X, self.structure_column, kind="structure")
    self.feature_names_out_ = np.asarray(
        structure_feature_names(self.features, column_prefix=self.column_prefix),
        dtype=object,
    )
    self.n_features_out_ = len(self.feature_names_out_)
    return self

transform(X)

Transform structures into numeric lattice and packing descriptors.

Source code in matgpr/featurizers.py 
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
def transform(self, X):
    """Transform structures into numeric lattice and packing descriptors."""
    check_is_fitted(self, "feature_names_out_")
    structures, index = _extract_values(X, self.structure_column_, kind="structure")
    result = featurize_structures(
        structures,
        features=self.features,
        errors=self.errors,
        cache_dir=self.cache_dir,
    )
    features = result.features.copy()
    features.columns = self.feature_names_out_
    features.index = index
    self.failed_ = result.failed
    self.cache_keys_ = result.cache_keys.set_axis(index)
    self.cache_hit_ = result.cache_hit.set_axis(index)
    self.last_result_ = result
    return _format_transform_output(features, self.return_dataframe)

get_feature_names_out(input_features=None)

Return output descriptor names.

Source code in matgpr/featurizers.py 
266
267
268
269
270
def get_feature_names_out(self, input_features=None) -> np.ndarray:
    """Return output descriptor names."""
    check_is_fitted(self, "feature_names_out_")
    _validate_input_features(self, input_features)
    return self.feature_names_out_.copy()

SmilesFeaturizer

Bases: BaseEstimator, TransformerMixin

Scikit-learn-style transformer for molecule or polymer SMILES.

Molecule SMILES are canonicalized directly with RDKit. If smiles_type="polymer", repeat-unit SMILES must contain exactly two [*] dummy atoms and are converted to the cyclic-trimer surrogate used by :func:matgpr.featurize_smiles.

Source code in matgpr/featurizers.py 
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
class SmilesFeaturizer(BaseEstimator, TransformerMixin):
    """Scikit-learn-style transformer for molecule or polymer SMILES.

    Molecule SMILES are canonicalized directly with RDKit. If
    ``smiles_type="polymer"``, repeat-unit SMILES must contain exactly two
    ``[*]`` dummy atoms and are converted to the cyclic-trimer surrogate used by
    :func:`matgpr.featurize_smiles`.
    """

    def __init__(
        self,
        *,
        smiles_column: str | int | None = None,
        smiles_type: str = "molecule",
        fingerprint_type: str = "morgan",
        n_bits: int = 1024,
        radius: int = 2,
        descriptors: Sequence[str] = DEFAULT_RDKIT_DESCRIPTORS,
        column_prefix: str | None = None,
        errors: str = "raise",
        cache_dir: str | Path | None = None,
        include_canonical_smiles: bool = False,
        return_dataframe: bool = True,
    ):
        self.smiles_column = smiles_column
        self.smiles_type = smiles_type
        self.fingerprint_type = fingerprint_type
        self.n_bits = n_bits
        self.radius = radius
        self.descriptors = descriptors
        self.column_prefix = column_prefix
        self.errors = errors
        self.cache_dir = cache_dir
        self.include_canonical_smiles = include_canonical_smiles
        self.return_dataframe = return_dataframe

    def fit(self, X, y=None):
        """Store input-column metadata and deterministic fingerprint names."""
        _validate_errors(self.errors)
        _set_input_metadata(self, X)
        self.smiles_column_ = _resolve_column(X, self.smiles_column, kind="SMILES")
        empty_result = featurize_smiles(
            [],
            smiles_type=self.smiles_type,
            fingerprint_type=self.fingerprint_type,
            n_bits=self.n_bits,
            radius=self.radius,
            descriptors=self.descriptors,
            column_prefix=self.column_prefix,
            errors=self.errors,
            cache_dir=self.cache_dir,
        )
        feature_names = list(empty_result.features.columns)
        if self.include_canonical_smiles:
            feature_names = [empty_result.canonical_smiles.name, *feature_names]
        self.feature_names_out_ = np.asarray(feature_names, dtype=object)
        self.n_features_out_ = len(self.feature_names_out_)
        return self

    def transform(self, X):
        """Transform SMILES strings into RDKit fingerprints or descriptors."""
        check_is_fitted(self, "feature_names_out_")
        smiles_values, index = _extract_values(X, self.smiles_column_, kind="SMILES")
        result = featurize_smiles(
            smiles_values,
            smiles_type=self.smiles_type,
            fingerprint_type=self.fingerprint_type,
            n_bits=self.n_bits,
            radius=self.radius,
            descriptors=self.descriptors,
            column_prefix=self.column_prefix,
            errors=self.errors,
            cache_dir=self.cache_dir,
        )
        features = result.features.copy()
        features.index = index
        canonical_smiles = result.canonical_smiles.set_axis(index)

        if self.include_canonical_smiles:
            features = pd.concat([canonical_smiles, features], axis=1)
            features.columns = self.feature_names_out_

        self.canonical_smiles_ = canonical_smiles
        self.failed_ = result.failed
        self.cache_keys_ = result.cache_keys.set_axis(index)
        self.cache_hit_ = result.cache_hit.set_axis(index)
        self.last_result_ = result
        return _format_transform_output(features, self.return_dataframe)

    def get_feature_names_out(self, input_features=None) -> np.ndarray:
        """Return output fingerprint or descriptor names."""
        check_is_fitted(self, "feature_names_out_")
        _validate_input_features(self, input_features)
        return self.feature_names_out_.copy()

fit(X, y=None)

Store input-column metadata and deterministic fingerprint names.

Source code in matgpr/featurizers.py 
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
def fit(self, X, y=None):
    """Store input-column metadata and deterministic fingerprint names."""
    _validate_errors(self.errors)
    _set_input_metadata(self, X)
    self.smiles_column_ = _resolve_column(X, self.smiles_column, kind="SMILES")
    empty_result = featurize_smiles(
        [],
        smiles_type=self.smiles_type,
        fingerprint_type=self.fingerprint_type,
        n_bits=self.n_bits,
        radius=self.radius,
        descriptors=self.descriptors,
        column_prefix=self.column_prefix,
        errors=self.errors,
        cache_dir=self.cache_dir,
    )
    feature_names = list(empty_result.features.columns)
    if self.include_canonical_smiles:
        feature_names = [empty_result.canonical_smiles.name, *feature_names]
    self.feature_names_out_ = np.asarray(feature_names, dtype=object)
    self.n_features_out_ = len(self.feature_names_out_)
    return self

transform(X)

Transform SMILES strings into RDKit fingerprints or descriptors.

Source code in matgpr/featurizers.py 
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
def transform(self, X):
    """Transform SMILES strings into RDKit fingerprints or descriptors."""
    check_is_fitted(self, "feature_names_out_")
    smiles_values, index = _extract_values(X, self.smiles_column_, kind="SMILES")
    result = featurize_smiles(
        smiles_values,
        smiles_type=self.smiles_type,
        fingerprint_type=self.fingerprint_type,
        n_bits=self.n_bits,
        radius=self.radius,
        descriptors=self.descriptors,
        column_prefix=self.column_prefix,
        errors=self.errors,
        cache_dir=self.cache_dir,
    )
    features = result.features.copy()
    features.index = index
    canonical_smiles = result.canonical_smiles.set_axis(index)

    if self.include_canonical_smiles:
        features = pd.concat([canonical_smiles, features], axis=1)
        features.columns = self.feature_names_out_

    self.canonical_smiles_ = canonical_smiles
    self.failed_ = result.failed
    self.cache_keys_ = result.cache_keys.set_axis(index)
    self.cache_hit_ = result.cache_hit.set_axis(index)
    self.last_result_ = result
    return _format_transform_output(features, self.return_dataframe)

get_feature_names_out(input_features=None)

Return output fingerprint or descriptor names.

Source code in matgpr/featurizers.py 
362
363
364
365
366
def get_feature_names_out(self, input_features=None) -> np.ndarray:
    """Return output fingerprint or descriptor names."""
    check_is_fitted(self, "feature_names_out_")
    _validate_input_features(self, input_features)
    return self.feature_names_out_.copy()

PolymerSmilesFeaturizer

Bases: SmilesFeaturizer

Convenience transformer for two-ended polymer repeat-unit SMILES.

Source code in matgpr/featurizers.py 
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
class PolymerSmilesFeaturizer(SmilesFeaturizer):
    """Convenience transformer for two-ended polymer repeat-unit SMILES."""

    def __init__(
        self,
        *,
        smiles_column: str | int | None = None,
        fingerprint_type: str = "morgan",
        n_bits: int = 1024,
        radius: int = 2,
        descriptors: Sequence[str] = DEFAULT_RDKIT_DESCRIPTORS,
        column_prefix: str | None = None,
        errors: str = "raise",
        cache_dir: str | Path | None = None,
        include_canonical_smiles: bool = False,
        return_dataframe: bool = True,
    ):
        super().__init__(
            smiles_column=smiles_column,
            smiles_type="polymer",
            fingerprint_type=fingerprint_type,
            n_bits=n_bits,
            radius=radius,
            descriptors=descriptors,
            column_prefix=column_prefix,
            errors=errors,
            cache_dir=cache_dir,
            include_canonical_smiles=include_canonical_smiles,
            return_dataframe=return_dataframe,
        )

featurize_magpie_compositions(formulas, *, properties=None, statistics=None, column_prefix='magpie', impute_nan=True, errors='raise')

Featurize inorganic formulas with matminer Magpie descriptors.

Parameters:

Name Type Description Default
formulas Sequence[object]

Formula strings or pymatgen.Composition objects.

 required
properties Sequence[str] | None

Optional Magpie elemental properties and summary statistics. When omitted, matminer's standard Magpie property/statistic set is used.

 None
statistics Sequence[str] | None

Optional Magpie elemental properties and summary statistics. When omitted, matminer's standard Magpie property/statistic set is used.

 None
column_prefix str | None

Prefix added to cleaned descriptor names. The default "magpie" avoids collisions with lightweight matgpr composition descriptors.

 'magpie'
impute_nan bool

Passed to matminer's ElementProperty featurizer.

 True
errors str

"raise" stops at the first invalid formula. "coerce" returns rows filled with NaN and records failures in failed.

 'raise'
Source code in matgpr/featurizers.py 
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
def featurize_magpie_compositions(
    formulas: Sequence[object],
    *,
    properties: Sequence[str] | None = None,
    statistics: Sequence[str] | None = None,
    column_prefix: str | None = "magpie",
    impute_nan: bool = True,
    errors: str = "raise",
) -> CompositionFingerprintResult:
    """Featurize inorganic formulas with matminer Magpie descriptors.

    Parameters
    ----------
    formulas
        Formula strings or ``pymatgen.Composition`` objects.
    properties, statistics
        Optional Magpie elemental properties and summary statistics. When
        omitted, matminer's standard Magpie property/statistic set is used.
    column_prefix
        Prefix added to cleaned descriptor names. The default ``"magpie"``
        avoids collisions with lightweight `matgpr` composition descriptors.
    impute_nan
        Passed to matminer's ``ElementProperty`` featurizer.
    errors
        ``"raise"`` stops at the first invalid formula. ``"coerce"`` returns
        rows filled with ``NaN`` and records failures in ``failed``.
    """
    _validate_errors(errors)
    featurizer = _build_magpie_featurizer(
        properties=properties,
        statistics=statistics,
        impute_nan=impute_nan,
    )
    feature_names = _magpie_feature_names(
        featurizer.feature_labels(),
        column_prefix=column_prefix,
    )
    return _featurize_magpie_compositions_with_backend(
        formulas,
        featurizer=featurizer,
        feature_names=feature_names,
        errors=errors,
    )

append_magpie_composition_features(data, *, formula_column='composition', drop_formula_column=False, properties=None, statistics=None, column_prefix='magpie', impute_nan=True, errors='raise')

Append matminer Magpie descriptors to a dataframe.

Source code in matgpr/featurizers.py 
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
def append_magpie_composition_features(
    data: pd.DataFrame,
    *,
    formula_column: str = "composition",
    drop_formula_column: bool = False,
    properties: Sequence[str] | None = None,
    statistics: Sequence[str] | None = None,
    column_prefix: str | None = "magpie",
    impute_nan: bool = True,
    errors: str = "raise",
) -> pd.DataFrame:
    """Append matminer Magpie descriptors to a dataframe."""
    if formula_column not in data.columns:
        raise KeyError(f"Formula column '{formula_column}' not found")

    result = featurize_magpie_compositions(
        data[formula_column],
        properties=properties,
        statistics=statistics,
        column_prefix=column_prefix,
        impute_nan=impute_nan,
        errors=errors,
    )
    features = result.features.set_index(data.index)
    base = data.drop(columns=[formula_column]) if drop_formula_column else data.copy()
    return pd.concat([base, features], axis=1)