python - tutorial - característica Unión de características heterógenas

tfidfvectorizer

Question

Tengo 3 conjuntos de características diferentes para un conjunto determinado de archivos de audio. Cada uno de ellos son matrices de características almacenadas como una matriz de dimensiones de la siguiente manera:

• característica 1: (978 * 153)
• característica 2: (978 * 800)
• característica 3: (978 * 12)

Cada una de estas características se ha extraído de los archivos de audio usando diferentes técnicas.

Lo que me gustaría hacer es entrenarlos juntos en un clasificador dado. (usando la tubería). He leído esto , este y el enlace del blog en el enlace 2, pero se trata de diferentes métodos de extracción y luego el uso de los clasificadores. Dado que ya tengo los datos extraídos como se mencionó anteriormente, quería saber qué hacer a continuación, es decir, cómo combinarlos para obtener una canalización.

Sé que aquí no se puede pedir un código directo, solo quiero punteros. Cómo combinar datos (tal vez usando un pipeline) que se extrae de diferentes métodos para clasificarlos usando un SVM por ejemplo.

Answer 1

Suponiendo que quiera tratar con un conjunto de características en modelos independientes y luego agrupe sus resultados, escribiré una respuesta a continuación. Sin embargo, si desea simplemente usar las características de las 3 técnicas de extracción de características en un solo modelo, simplemente agréguelas juntas en un solo conjunto de datos y úselas para el entrenamiento.

Creo que la forma más fácil de hacerlo en un Pipeline es crear un solo (978 * 965) pandas DataFrame que incluya características de las tres técnicas. Luego, dentro de su canalización, puede definir una clase personalizada que seleccione grupos de características, por ejemplo, esto debería funcionar:

class VarSelect(BaseEstimator, TransformerMixin):
    def __init__(self, keys):
        self.keys = keys
    def fit(self, x, y=None):
        return self
    def transform(self, df):
        return df[self.keys].values

Luego necesitará una clase simple que se ajuste a un modelo y luego lo transforme para proporcionar predicciones (necesarias para apilar sus modelos). Algo como esto debería funcionar (dependiendo de si su problema es regresión o clasificación):

class ModelClassTransformer(BaseEstimator, TransformerMixin):
    def __init__(self, model):
        self.model = model
    def fit(self, *args, **kwargs):
        self.model.fit(*args, **kwargs)
        return self
    def transform(self, X, **transform_params):
        return DataFrame(self.model.predict_proba(X))

class ModelRegTransformer(BaseEstimator, TransformerMixin):
    def __init__(self, model):
        self.model = model
    def fit(self, *args, **kwargs):
        self.model.fit(*args, **kwargs)
        return self
    def transform(self, X, **transform_params):
        return DataFrame(self.model.predict(X))

Ahora que tiene todas estas cosas, puede crear una canalización que entrene modelos individuales en subconjuntos de su conjunto de datos y luego los apile en un modelo final ensamblado. Un ejemplo de canal usando un montón de SVM (como lo solicitó) podría verse así:

Pipeline([
    (''union'', FeatureUnion([
        (''modelA'', Pipeline([
            (''var'', VarSelect(keys=vars_a)),
            (''scl'', StandardScaler(copy=True, with_mean=True, with_std=True)),
            (''svm'', ModelRegTransformer(SVC(kernel=''rbf'')))),
        ])),
        (''modelB'', Pipeline([
            (''var'', VarSelect(keys=vars_b)),
            (''scl'', StandardScaler(copy=True, with_mean=True, with_std=True)),
            (''svm'', ModelRegTransformer(SVC(kernel=''rbf''))),
        ])),
        (''modelC'', Pipeline([
            (''var'', VarSelect(keys=vars_c)),
            (''scl'', StandardScaler(copy=True, with_mean=True, with_std=True)),
            (''svm'', ModelRegTransformer(SVC(kernel=''rbf''))),
        ]))
    ])),
    (''scl'', StandardScaler(copy=True, with_mean=True, with_std=True)),
    (''svm'', SVC(kernel=''rbf''))
])