Création de variables fictives dans pandas pour python
j'essaie de créer une série de variables fictives à partir d'une variable catégorique en utilisant pandas en python. Je suis tombé sur la fonction get_dummies , mais chaque fois que j'essaie de l'appeler, je reçois une erreur que le nom n'est pas défini.
toutes les idées ou autres façons de créer les variables fictives seraient appréciées.
EDIT : puisque d'autres semblent tomber dessus, la fonction get_dummies dans pandas fonctionne maintenant parfaitement bien. Cela signifie que les éléments suivants devraient fonctionner:
import pandas as pd
dummies = pd.get_dummies(df['Category'])
voir http://blog.yhathq.com/posts/logistic-regression-and-python.html pour plus d'informations.
9 réponses
il est difficile de déduire ce que vous cherchez à partir de la question, mais ma meilleure supposition est la suivante.
si nous supposons que vous avez une base de données où une colonne est "Catégorie" et contient des entiers (ou autres identificateurs uniques) pour les catégories, alors nous pouvons faire ce qui suit.
appeler le DataFrame dfrm , et supposer que pour chaque ligne, dfrm['Category'] est une certaine valeur dans l'ensemble des entiers de 1 à N. alors,
for elem in dfrm['Category'].unique():
dfrm[str(elem)] = dfrm['Category'] == elem
maintenant, il y aura une nouvelle colonne indicatrice pour chaque catégorie qui est vrai/faux selon que les données dans cette rangée sont dans cette catégorie.
si vous voulez contrôler les noms des catégories, vous pouvez faire un dictionnaire, comme
cat_names = {1:'Some_Treatment', 2:'Full_Treatment', 3:'Control'}
for elem in dfrm['Category'].unique():
dfrm[cat_names[elem]] = dfrm['Category'] == elem
pour avoir comme résultat des colonnes avec des noms spécifiés, plutôt que la simple conversion de chaîne des valeurs de catégorie. En fait, pour certains types, str() peut ne pas produire quelque chose d'utile pour vous.
quand je pense à des variables fictives, je pense à les utiliser dans le contexte de la régression OLS, et je ferais quelque chose comme ça:
import numpy as np
import pandas as pd
import statsmodels.api as sm
my_data = np.array([[5, 'a', 1],
[3, 'b', 3],
[1, 'b', 2],
[3, 'a', 1],
[4, 'b', 2],
[7, 'c', 1],
[7, 'c', 1]])
df = pd.DataFrame(data=my_data, columns=['y', 'dummy', 'x'])
just_dummies = pd.get_dummies(df['dummy'])
step_1 = pd.concat([df, just_dummies], axis=1)
step_1.drop(['dummy', 'c'], inplace=True, axis=1)
# to run the regression we want to get rid of the strings 'a', 'b', 'c' (obviously)
# and we want to get rid of one dummy variable to avoid the dummy variable trap
# arbitrarily chose "c", coefficients on "a" an "b" would show effect of "a" and "b"
# relative to "c"
step_1 = step_1.applymap(np.int)
result = sm.OLS(step_1['y'], sm.add_constant(step_1[['x', 'a', 'b']])).fit()
print result.summary()
basé sur la documentation officielle :
dummies = pd.get_dummies(df['Category']).rename(columns=lambda x: 'Category_' + str(x))
df = pd.concat([df, dummies], axis=1)
df = df.drop(['Category'], inplace=True, axis=1)
il y a aussi un beau post dans le blog FastML.
le code suivant renvoie le datagramme avec la colonne "Catégorie" remplacée par les colonnes "catégories":
df_with_dummies = pd.get_dummies(df, prefix='Category_', columns=['Category'])
http://pandas.pydata.org/pandas-docs/stable/generated/pandas.get_dummies.html
pour mon affaire, dmatrices dans patsy a résolu mon problème. En fait, cette fonction est conçue pour la génération de variables dépendantes et indépendantes à partir d'une DataFrame donnée avec une chaîne de Formule R-style. Mais il peut être utilisé pour la génération de mannequin caractéristiques de l'catégorique fonctionnalités. Tout ce que vous devez faire serait de laisser tomber la colonne 'Intercept' qui est générée par dmatrices automatiquement indépendamment de votre DataFrame d'origine.
import pandas as pd
from patsy import dmatrices
df_original = pd.DataFrame({
'A': ['red', 'green', 'red', 'green'],
'B': ['car', 'car', 'truck', 'truck'],
'C': [10,11,12,13],
'D': ['alice', 'bob', 'charlie', 'alice']},
index=[0, 1, 2, 3])
_, df_dummyfied = dmatrices('A ~ A + B + C + D', data=df_original, return_type='dataframe')
df_dummyfied = df_dummyfied.drop('Intercept', axis=1)
df_dummyfied.columns
Index([u'A[T.red]', u'B[T.truck]', u'D[T.bob]', u'D[T.charlie]', u'C'], dtype='object')
df_dummyfied
A[T.red] B[T.truck] D[T.bob] D[T.charlie] C
0 1.0 0.0 0.0 0.0 10.0
1 0.0 0.0 1.0 0.0 11.0
2 1.0 1.0 0.0 1.0 12.0
3 0.0 1.0 0.0 0.0 13.0
vous pouvez créer des variables fictives pour gérer les données catégoriques
# Creating dummy variables for categorical datatypes
trainDfDummies = pd.get_dummies(trainDf, columns=['Col1', 'Col2', 'Col3', 'Col4'])
cela fera tomber les colonnes originales dans trainDf et ajoutera la colonne avec des variables muettes à la fin du trainDfDummies dataframe.
il crée automatiquement les noms de colonne en ajoutant les valeurs à la fin du nom de colonne original.
j'étais Donc avoir une réponse à cette question aujourd'hui (7/25/2013), donc j'ai écrit plus tôt. Je l'ai testé avec des jouets exemples, nous espérons que vous obtenez certains kilométrage
def categorize_dict(x, y=0):
# x Requires string or numerical input
# y is a boolean that specifices whether to return category names along with the dict.
# default is no
cats = list(set(x))
n = len(cats)
m = len(x)
outs = {}
for i in cats:
outs[i] = [0]*m
for i in range(len(x)):
outs[x[i]][i] = 1
if y:
return outs,cats
return outs
j'ai créé une variable fictive pour chaque État en utilisant ce code.
def create_dummy_column(series, f):
return series.apply(f)
for el in df.area_title.unique():
col_name = el.split()[0] + "_dummy"
f = lambda x: int(x==el)
df[col_name] = create_dummy_column(df.area_title, f)
df.head()
Plus généralement, je voudrais juste utiliser .d'appliquer et de transmettre une fonction anonyme à l'inégalité qui définit votre catégorie.
(merci à @prpl.mnky.dshwshr pour la .unique () insight)
manutention caractéristiques des catégories scikit-learn s'attend à ce que toutes les fonctionnalités soient numériques. Alors, comment inclure une caractéristique catégorique dans notre modèle?
catégories ordonnées: les transformer en valeurs numériques sensibles (exemple: Petite=1, Moyenne=2, Grande=3)) Catégories non ordonnées: utiliser un codage fictif (0/1) Quelles sont les caractéristiques catégoriques de notre ensemble de données?
catégories ordonnées: météo (déjà encodé avec des valeurs numériques sensibles) Catégories non classées: saison (besoins factices encodage), vacances (déjà mannequin codés), workingday (déjà mannequin codé) Pour la saison, nous ne pouvons pas simplement laisser l'encodage comme 1 = printemps, 2 = été, 3 = automne, et 4 = hiver, parce que cela impliquerait une relation ordonnée. Au lieu de cela, nous créons plusieurs variables fictives:
# An utility function to create dummy variable
`def create_dummies( df, colname ):
col_dummies = pd.get_dummies(df[colname], prefix=colname)
col_dummies.drop(col_dummies.columns[0], axis=1, inplace=True)
df = pd.concat([df, col_dummies], axis=1)
df.drop( colname, axis = 1, inplace = True )
return df`