análise fatorial exploratória confirmatória

FactorAnalyzer é um módulo Python para realizar análise fatorial exploratórias (AFE) e confirmatória (AFC). Na análise exploratória se pode usar várias técnicas de estimativa. É possível executar AFE usando (1) solução residual mínima (MINRES), (2) uma solução de máxima verossimilhança ou (3) uma solução de fator principal. A análise confirmatória só pode ser executada usando uma solução de máxima verossimilhança.

As classes da biblioteca são compatíveis com scikit-learn. Partes do código são portadas da biblioteca psych do R, e a classe AFC foi baseada na biblioteca sem. A classe factor_analyzer.factor_analyzer.FactorAnalyzer se utiliza de sklearn.base.BaseEstimator e sklearn.base.TransformerMixin.

Na AFE as matrizes de carga fatorial são geralmente submetidas a rotações após o modelo de análise fatorial ser estimado, buscando-se produzir uma estrutura mais simples e de fácil interpretação na identificação das variáveis que estão carregando em um determinado fator.

Os dois tipos mais comuns de rotações são:

Rotação ortogonal varimax, que gira a matriz de cargas fatoriais de forma a maximizar a soma da variância das cargas quadradas, preservando a ortogonalidade da matriz de carga.
A rotação oblíqua promax, baseada na rotação varimax, mas buscando maior correlaçãp dos fatores.

Essa biblioteca inclui o módulo analisador de fatores com a classe FactorAnalyzer. Essa classe inclui os métodos fit() e transform() para realizar a análise e pontuar novos dados usando o modelo de fatores ajustados. Rotações opcionais podem ser realizadas sobre a matriz de cargas fatoriais com a classe Rotator.

Os seguintes métodos de rotação estão disponíveis tanto para FactorAnalyzer quanto para Rotator:

varimax (rotação ortogonal),
promax (oblíqua),
oblimin (oblíqua),
oblimax (ortogonal),
quartimin (oblíqua),

quartimax (ortogonal),
equamax (ortogonal),
geomin_obl (oblíqua),
geomin_ort (ortogonal).

A biblioteca também inclui o módulo confirmatory_factor_analyzer com a classe ConfirmatoryFactorAnalyzer. A classe contém os métodos fit() e transform() que realizam análises fatoriais confirmatórias e pontuam novos dados usando o modelo ajustado. A execução do CFA requer que os usuários especifiquem previamente o modelo com as relações de carga fatorial esperadas, o que pode ser feito usando a classe ModelSpecificationParser.

# A biblioteca pode ser instalada usando pip:
$ pip install factor_analyzer

# ou conda:
$ conda install -c ets factor_analyzer

Ele depende de Python 3.4 (ou superior), numpy, pandas, scipy, scikit-learn.

A classe factor_analyzer possui um método para ajustar um modelo de análise e fazer a análise fatorial usando solução residual mínima (MINRES), solução de máxima verossimilhança ou (3) solução de fator principal. Retorna a matriz de cargas fatoriais. Por default não realiza nenhuma rotação. Opcionalmente pode realizar uma rotação usando os métodos citados abaixo.

Análise Fatorial Exploratória

Módulo factor_analyzer.factor_analyzer

class
factor_analyzer.factor_analyzer.FactorAnalyzer(n_factors=3, rotation='promax', method='minres',
                                               use_smc=True, is_corr_matrix=False, bounds=(0.005, 1),
                                               impute='median', rotation_kwargs=None)

Parâmetros:

n_factors

(int, opcional) – Número de fatores a ajustar. Default: 3.

rotation

(str, opcional) – Default: None.
Define o tipo de rotação a realizar após o ajuste do modelo. Nenhuma rotação será realizada se rotation = None e nenhuma normalização de Kaiser será aplicada. Os seguintes métodos de rotação estão disponíveis:

varimax (rotação ortogonal),
promax (oblíqua),
oblimin (oblíqua),
oblimax (ortogonal),

quartimin (oblíqua),
quartimax (ortogonal),
equamax (ortogonal),

sendo rotation = ‘promax’ o default.

method

({‘minres’, ‘ml’, ‘principal’}, opcional) – Método de ajuste a ser usado: solução residual mínima (MINRES), uma solução de máxima verossimilhança ou de fator principal. Default: minres.

use_smc

(bool, opcional) – Uso de correlação multipla quadrada (SMC, square multiple correlation) como ponto de partida para a análise. Default: True.

bounds

(tuple, opcional) – Limites inferior e superior das variáveis para a otimização “L-BFGS-B”. Default: (0.005, 1).

impute

({‘drop’, ‘mean’, ‘median’}, opcional) – Se existem valores faltantes nos dados usar apagamento na lista inteira (‘drop’) ou substituir valores usando a mediana (‘median’) ou a média (‘mean’) da coluna.

use_corr_matrix

(bool, opcional) – Ajuste para Verdadeiro se os dados de entrada já são a matriz de correlação. Default: False.

rotation_kwargs

(opcional) – argumentos adicionais passados para o método de rotação.

Propriedades:

loadings: A matriz de cargas fatoriais. Default: None se o método fit() não foi chamado.
Tipo: numpy array
corr: A matriz original de correlação. Default: None se o método fit() não foi chamado.
Tipo: numpy array
rotation_matrix: A matriz de rotação, se uma rotação não foi executada.
Tipo: numpy array
structure: A estrutura da matriz de cargas fatoriais. (Só existe se rotação for promax).
Tipo: numpy array ou None
psi: A matriz de fatores de correlação. (Só existe se rotação for oblíqua).
Tipo: numpy array ou None

Métodos:

fit(X, y=None): Faz a análise fatorial sobre os dados de X usando ‘minres’, ‘ml’, ou ‘principal solutions’. Default: SMC (correlação múltipla quadrada)
Parâmetros:
X (variável tipo array) – Dados originais a serem analisados.
y (não é utilizado).
get_communalities(): Calcula as comunalidades, dada uma matriz de cargas fatoriais.
Retorna: communalities (numpy array), as comunalidades.
get_eigenvalues(): Calcula os autovalores, dada uma matriz de correlações fatoriais.
Retorna: original_eigen_values (numpy array), os autovalores originais.
common_factor_eigen_values(numpy array), os autovalores dos fatores comuns.
get_factor_variance(): Calcula informações de variância, inclusive a variância, variância proporcional e cumulativa para cada fator.
Retorna: variance (numpy array) – A variância dos fatores.
proportional_variance (numpy array) – A variância proporcional dos fatores.
cumulative_variances (numpy array) – A variância cumulativa dos fatores.
get_uniquenesses(): Calcula a unicidade, dada uma matriz de cargas fatoriais.
Retorna: uniquenesses (numpy array) – A unicidade da matriz de cargas fatoriais.
transform(X): Retorna a pontuação de fatores para um novo conjunto de dados.
Parâmetros: X (variável de array, shape (n_amostras, n_características)) – Os dados a pontuar usando o modelo de fatores ajustado.
Retorna: X_new – As variáveis latentes de X. (um numpy array, shape (n_amostras, n_componentes))

Testes de Bartlett e KMO

factor_analyzer.factor_analyzer.calculate_bartlett_sphericity(x)

Testa a hipótese de que a matriz de correlação é igual à matriz identidade (o que significa que não há correlação entre as variáveis).

Parâmetro: X (variável de array) – Dados sobre os quais calcular a esfericidade.
Retorna:: statistic (float) – O valor de chi-quadrado, \chi^2.
p_value (float) – O valor de p-value associado ao teste.

factor_analyzer.factor_analyzer.calculate_kmo(x)

Calcula o critério de Kaiser-Meyer-Olkin para cada fator individual e para o conjunto fatores. Essa estatística representa o grau com que cada variável observada pode ser predita, sem erro, pelas demais variáveis. Na maior parte dos casos KMO < 0.6 é considerado inadequado.

Parâmetros:: x (variável de array) – Dados sobre os quais calcular coeficientes KMOs.
Retorna:: kmo_per_variable (array numpy) – O KMO para cada item.
kmo_total (float) – A pontuação KMO geral.

Análise Fatorial Confirmatória

Módulo factor_analyzer.confirmatory_factor_analyzer

class
factor_analyzer.confirmatory_factor_analyzer.ConfirmatoryFactorAnalyzer(specification=None,
                                n_obs=None, is_cov_matrix=False, bounds=None, max_iter=200,
                                tol=None, impute='median', disp=True)

A classe ConfirmatoryFactorAnalyzer ajusta um modelo de análise fatorial confirmatória usando o modelo de máxima verosimelhança (maximum likelihood).

Parâmetros:

specification

(ModelSpecification object ou None, opcional) – Um modelo de especificação ModelSpecification ou None. Se None for fornecido o ModelSpecification será gerado supondo que o número de fatores n_factors é o mesmo que o número de variáveis, n_variables, e que todas as variáveis carregam em todos os fatores. Note que isso pode significa que o modelo não foi identificado e a otimização poderá falhar. Default: None.

n_obs

(int ou None, opcional) – Número de observações no conjunto original de dados. Se não for passado e is_cov_matrix=True um erro será lançado. Default: None.

is_cov_matrix

(bool, opcional) – Informa se a matriz de entrada X é a matriz de covariância. Se False o conjunto completo de dados é considerado. Default: False.

bounds

(lista de tuplas ou None, opcional) – Uma lista de limites mínimos e máximos para cada elemento do array de entrada. Deve ser igual a x0 que é o array de entrada do modelo de especificação.

O comprimento é: ((n_factors * n_variables) + n_variables + n_factors + (((n_factors * n_factors) – n_factors) // 2)

Se bounds=None nenhum limite será tomado. Default: None.

max_iter

(int, opcional) – Número máximo de iterações na rotina de otimização. Default: 200.

tol

(float ou None, opcional) – Tolerância para a convergência. Default: None.

disp

(bool, opcional) – Se a mensagem da otimização do scipy fmin é enviado para o standard output. Default: True.

Exceção levantada

ValueError – Se is_cov_matrix = True e n_obs não é fornecido.

Propriedades:

model: Objeto modelo de especificação.
Tipo: ModelSpecification.
loadings_: A Matriz da Cargas fatoriais.
Tipo: numpy array
error_vars_: A matriz de variância de erros (Tipo: numpy array).
factor_varcovs_: A Matriz de covariância. (Tipo: numpy array).
log_likelihood_: O log de verossimilhança da rotina de otimização. (Tipo: float).
aic_: O critério de informação de Akaike. (Tipo: float).
bic_: O critério de informação Bayesiano. (Tipo: float).

Métodos:

fit(X, y=None): realiza a análise fatorial confirmatória sobre os dados de X usando máxima verossimilhança.
Parâmetros:
X (variável tipo array) – Dados originais a serem analisados. Se X for a matriz de covariância é necessário marcar is_cov_matrix = True.
y (não é utilizado)
Exceção levantada:: ValueError – Se a especificação não é um objeto ModelSpecification nem None.
AssertionError – Se is_cov_matrix = True e a matriz fornecida não é quadrada.
AssertionError – If len(bounds) != len(x0)
get_model_implied_cov(): Retorna a matriz de covariância implícita no modelo, se o modelo foi estimado. (numpy array)
get_standard_errors(): Lê os erros padrão da matriz de covariância implícita e das médias implícitas.
Retorna:
loadings_se (numpy array) – Os erros padrões para os cargas fatoriais.
error_vars_se (numpy array) – Os erros padrões para as variâncias de erros.
transform(X): Lê as pontuações para os fatores do novo conjunto de dados.
Parâmetros: X (tipo array, shape (n_amostras, n_características)) – Os dados a serem pontuados usando o modelo fatorial ajustado.
Retorna: pontuações – As variáveis latentes de X (um numpy array, shape (n_amostras, n_componentes))

class
factor_analyzer.confirmatory_factor_analyzer.ModelSpecification(loadings, n_factors, n_variables,
                                                                factor_names=None, variable_names=None)

Uma classe para encapsular a especificação do modelo para a análise confirmatória. Esta classe contém várias propriedades de especificação que são usadas no procedimento AFC.

Parâmetros:

loadings: (tipo array) – Especificação de cargas fatoriais.
error_vars (array-like) – Especificação de variância do erro
factor_covs (tipo array) – Especificação da covariância do fator.
factor_names (lista de str ou None) – uma lista de nomes de fatores, se disponível. Default: None.
variable_names (lista de str ou None) – Uma lista de nomes de variáveis, se disponível. Default: None.

Phylos.net

Pensar e Imaginar

análise fatorial exploratória confirmatória

Biblioteca FactorAnalyser

Análise Fatorial Exploratória

Módulo factor_analyzer.factor_analyzer

Testes de Bartlett e KMO

Análise Fatorial Confirmatória

Módulo factor_analyzer.confirmatory_factor_analyzer

Analisador de especificação de modelo

Módulo factor_analyzer.rotator

Bibliografia