Si la mémoire me nourrit, il existe un type de données appelé facteur qui, lorsqu'il est utilisé dans un fichier de données peut être automatiquement décompressé dans les colonnes nécessaires d'une matrice de conception de régression. Par exemple, un facteur contenant des valeurs vraies / fausses / peut-être serait transformée en: dans le but d'utiliser le code de régression de niveau inférieur. Y a-t-il un moyen d'atteindre quelque chose de similaire à l'aide de la bibliothèque Pandas? Je vois qu'il y a un soutien de régression au sein des pandas, mais depuis que j'ai mes propres routines de régression personnalisées, je suis vraiment intéressé par la construction de la matrice de conception (une matrice ou une matrice de 2D numpy ou une matrice) de données hétérogènes avec support pour la cartographie de la cartographie et du fort entre Les colonnes de l'objet numpy et le fichier de données pandas à partir duquel il est dérivé. mise à jour: Voici un exemple de matrice de données avec des données hétérogènes du tri que je pense à (l'exemple provient du manuel Pandas ): la colonne "A" doit être convertie en 4 colonnes à point flottant (malgré le sens, il n'y a que quatre atomes uniques), la colonne "B" Peut être converti en une seule colonne à point flottant et la colonne «C» doit être une colonne finale non modifiée de la matrice de conception. Merci, SETJMP
5 Réponses :
[ 1. 0. 0. 0. 1. 0. 0.36444463] [ 1. 0. 0. 0. 0. 1. -0.63610264] [ 0. 1. 0. 0. 0. 1. 1.27876991] [ 0. 0. 1. 0. 1. 0. 0.69048607] [ 0. 1. 0. 0. 0. 1. 0.34243241] [ 1. 0. 0. 0. 1. 0. -1.17370649] [ 0. 0. 0. 1. 1. 0. -0.52271636]
L'attribut de valeurs renvoie Ndarray d'imbriquée où le tableau InnerMost contient DTYPE = objet. Les facteurs sont convertis en chaînes et les données de flotteur flottent dans cette matrice intérieure.
Cela ne fonctionne pas comme ça pour moi. J'ai édité la question ci-dessus pour illustrer.
Cela fonctionne pour vous car dans votre exemple, toutes les données se déroulent du type de flotteur. Cependant, avec des données de chaîne présentes, je reçois une structure différente en tant que type de retour. Ce que je cherche comme une cartographie logique qui transforme la structure de données en Ndarray 2D de flotteurs qui pourraient ensuite être placés dans un solveur de faible teneur en attente de la matrice de conception X et des variables dépendantes y. En bas niveau, je veux dire du code SPEudoinverse qui ne sait que travailler sur des ndarrays de flottaison 2D (pas recharge). Ce codage de niveau inférieur est celui qui est appelé «matrice de conception» dans les références de statistiques.
Voici une discussion mettant en évidence comment le code R traduit les facteurs dans une matrice de conception "derrière les scènes" avant d'envoyer au code de solveur de levier bas. Bien que les exemples de facteurs ne disposent que de 2 niveaux, je pense que le comportement correct peut être attendu pour 3 niveaux ou plus.
Il semble qu'un numpy recarray pourrait être approprié. Je vais regarder si valeurs peut être facilement exporté vers un recarray
En outre, il serait utile que vous puissiez fournir un code de travail qui crée un petit exemple de Dataframe qui a des chaînes, etc., dans des endroits analogues à celui que vous travaillez. Afin que nous puissions tester des méthodes.
J'ai modifié la question avec un petit exemple d'un tel cadre de données.
J'ai modifié la réponse avec ma meilleure hypothèse sur ce que vous vouliez des variables catégoriques. Si je vous ai compris, vous recherchez des colonnes indicatrices et que ce qui précède devrait faire le tour.
Merci d'avoir mis beaucoup d'efforts à cela. Votre solution est maintenant assez proche de ce que je suis après même un peu non général, comme votre commentaire sur le dictionnaire ordonnant des alluches. Avoir un codage de la cartographie inverse dans l'affaire général est également important. J'ai suivi ce que je pense être la fonction équivalente de R: Model.Matrix. Je tiens toujours qu'une solution meilleure / plus élégante apparaîtra, c'est pourquoi je ne clique pas pour l'instant.
C'est bien, pas de soucis. Je serais également intéressé par une solution plus élégante. Il faut certainement être une façon plus pythonique de le faire.
Il y a un nouveau module appelé Patsy qui résout ce problème. Le QuickStart lié ci-dessous résout le problème décrit ci-dessus dans quelques lignes de code.
pâteuse est superbe pour transformer des valeurs continues en discrets.
patsy.dmatrices code> peut dans de nombreux cas bien fonctionner. Si vous avez juste un vecteur - un pandas.series code> - alors le code ci-dessous peut fonctionner produisant une matrice de conception dégénérée et sans colonne d'interception. def factor(series):
"""Convert a pandas.Series to pandas.DataFrame design matrix.
Parameters
----------
series : pandas.Series
Vector with categorical values
Returns
-------
pandas.DataFrame
Design matrix with ones and zeroes.
See Also
--------
patsy.dmatrices : Converts categorical columns to numerical
Examples
--------
>>> import pandas as pd
>>> design = factor(pd.Series(['a', 'b', 'a']))
>>> design.ix[0,'[a]']
1.0
>>> list(design.columns)
['[a]', '[b]']
"""
levels = list(set(series))
design_matrix = np.zeros((len(series), len(levels)))
for row_index, elem in enumerate(series):
design_matrix[row_index, levels.index(elem)] = 1
name = series.name or ""
columns = map(lambda level: "%s[%s]" % (name, level), levels)
df = pd.DataFrame(design_matrix, index=series.index,
columns=columns)
return df
Pandas 0.13.1 Du 3 février 2014 a une méthode:
>>> pd.Series(['one', 'one', 'two', 'three', 'two', 'one', 'six']).str.get_dummies() one six three two 0 1 0 0 0 1 1 0 0 0 2 0 0 0 1 3 0 0 1 0 4 0 0 0 1 5 1 0 0 0 6 0 1 0 0
import pandas as pd
import numpy as np
def get_design_matrix(data_in,columns_index,ref):
columns_index_temp = columns_index.copy( )
design_matrix = pd.DataFrame(np.zeros(shape = [len(data_in),len(columns_index)-1]))
columns_index_temp.remove(ref)
design_matrix.columns = columns_index_temp
for ii in columns_index_temp:
loci = list(map(lambda x:x == ii,data_in))
design_matrix.loc[loci,ii] = 1
return(design_matrix)
get_design_matrix(data_in = ['one','two','three','six','one','two'],
columns_index = ['one','two','three','six'],
ref = 'one')
Out[3]:
two three six
0 0.0 0.0 0.0
1 1.0 0.0 0.0
2 0.0 1.0 0.0
3 0.0 0.0 1.0
4 0.0 0.0 0.0
5 1.0 0.0 0.0
Ce n'est pas clair ce que vous voulez dire par "La" Colonne "doit être convertie en 4 colonnes à virgule flottante" ... Voulez-vous dire 4 valeurs de points flottants? Je ne vois pas comment la division des premières colonnes dans des colonnes mutliples permettra une matrice de conception. Je crois comprendre que les deux premières colonnes ici sont des variables catégoriques. Voulez-vous dire que vous souhaitez 4 variables binaires, qui sont égales à 1 uniquement si cette ligne des données avait ce numéro de premier colonne-catégorique?
Conversion d'un facteur avec des niveaux K en k colonnes / variables distinctes est appelée discrétisation .