Thanks for the contribution! Looking at this, I think using only the dominant feature name might be a bit misleading. That said, I'm not sure what to suggest as an alternative.

In some contexts, the full feature names might be desirable (see e.g. cell 19 of this notebook). In other cases, that will lead to feature names with thousands of characters.

I think probably the safest default is to just call them "pca0", "pca1", etc. and perhaps have an optional argument along the lines of full_names or something like that.

Thanks for the input. I have just created an initial PR and it seems helpful if the variance corresponding the input feature could also be mentioned in the results. Also a concern would be the criteria to choose whether multiple features are equally dominant. Will proceed as per your feedback.

@jakevdp, thanks for the notebook. They really are great help for me in general too. If I understand it right, your suggestion is to print the components as the linear combination of the features weighted by the variance. It definitely provides clearer understanding to the end user but might become too lengthy. Please do correct me if I misunderstood the comment.

your suggestion is to print the components as the linear combination of the features weighted by the variance.

Yes – though not weighted by the variance per se, but by the contribution to each principal vector. I think that could be useful in some cases, but far too long to be the default.

Ah sorry, I mistook the contribution to the component for variance. Thanks !

So maybe having an option full_names like @jakevdp suggested above can solve this?
When it is set to True, then show each features' contribution to each principal as output feature names.

So maybe having an option full_names like @jakevdp suggested above can solve this?
When it is set to True, then show each features' contribution to each principal as output feature names.

That's what I had in mind. What do you think?

So, when full_names is set to True mention the contribution of features to principal component and simply be [ 'pca0', 'pca1', .. ] when full_names is False right ?

So, when full_names is set to True mention the contribution of features to principal component and simply be [ 'pca0', 'pca1', .. ] when full_names is False right ?

Features output by PCA is called Principal Component, is 'pc0' better than 'pca0'?
Just in curious, I have no strong opinion on it.

Yes, I think that's a good idea.

Thanks, will go ahead and do the suggested changes !

Does something like this seem fine ?

>>> pca.get_feature_names(full_output=True)
['0.838492 * x0 + 0.544914 * x1', '0.544914 * x0 + -0.838492 * x1']
>>> pca.get_feature_names()
['pc0', 'pc1']

Also should the value of full_output be False by default or should be provided compulsorily ? Do let me know your opinion !

Looks good! I'd probably cut off the coefficients at 3 places past the decimal point, and perhaps change + -0.838 to - 0.838.

Hi, I have done the changes but not probably in the best possible implementation. Do have a look and let me know your opinion. Thanks !

Not sure if you saw my other comment, because the diff was outdated. Here's a quick & clear way to create the feature name with generator expressions:

def name_generator(coefficients, names):
    yield "{0:.3f} * {1}".format(coefficients[0], names[0])
    for c, n in zip(coefficients[1:], names[1:]):
        yield "{0:s} {1:.3f} * {2}".format('-' if c < 0 else '+', abs(c), n)

coefficients = np.random.rand(5) - 0.5
names = ['pc{0}'.format(i) for i in range(len(coefficients))]

' '.join(name_generator(coefficients, names))
# '-0.111 * pc0 + 0.476 * pc1 + 0.241 * pc2 - 0.011 * pc3 + 0.329 * pc4'

Sorry my old approach was really bad so changed it a bit. The generator-fu is really cool :) Only one question out of curiosity. Is it intentional for not leaving space between the sign for the first feature ?

Yes, no space on the first feature is intentional – I think it reads better that way.

I have done the changes as suggested. Please have a look at your convenience. Thanks.

PCA is mostly used when there are a lot of input features. Listing a fixed number of the largest contributing features to each component seems most useful to me, rather than listing all. Perhaps the appropriate parameter is show_coef: one of {False, True, integer} where False and True are like the current full_output option; integer n shows the sorted top n contributions to each component. I'm not sure about the need for True.

I would also use '{:2g}*{s}' to format the weight and the input name to reduce verbosity (remove spaces around multiplication and reduce precision to 2), but this can be configurable.

Hi everyone, thanks for the inputs. I understand that the addition of get_feature_names warrants discussion. It seems that the idea of giving only specified number of highest contributing features to each component is a good approach here. Please do let me know if I shall proceed the currently suggested approach or would happily oblige to wait until a consensus is reached. Thanks.

I'd be ok with False, True, int

Hi everyone, I understand the embargo on adding this feature, but still wanted to let you know that I did try enabling integer value for full_output as suggested. Please do have a look at your convenience and let me know your thoughts and suggestions. Thanks.

Hi, this is the present working with the option of choosing the number of features to be shown in the decreasing order of contribution to the component. Please do let me know your opinions on this. Thanks.

>>> import numpy as np
>>> from sklearn.decomposition import PCA
>>> X = np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]])
>>> pca = PCA(n_components=2).fit(X)
>>> pca.get_feature_names(full_output=True)
['0.84*x0 + 0.54*x1', '0.54*x0 - 0.84*x1']
>>> pca.get_feature_names(full_output=1)
['0.84*x0', '-0.84*x1']
>>> pca.get_feature_names()
['pc0', 'pc1']

I'd rather show_coef over full_output

@jnothman I have done the changes and also raised meaningful errors when show_coef is less than 1 or greater than n_features. Please let me know if you have any more suggestions. Thanks.

Actually now that I look closely at your suggestion, shouldn't it be np.argsort(np.abs(components), axis=1)[:, ::-1] since we want to reverse the order along the first axis. Please correct me if I am wrong. The tests here will pass for either of them since it is symmetric matrix in the example. Thanks.

Yes, what you said. But perhaps you should use a stronger test.

Thanks for confirming. I just used the example already given. Will use a better one and update the PR.

Closing because with SLEP007, PCA now has get_feature_names_out: #21334