Python熊猫：如何使用；“因素”；线性回归的设计矩阵？

如果内存为我服务，在R中有一种称为factor的数据类型，当在数据帧中使用时，它可以自动解压缩到回归设计矩阵的必要列中。例如，包含真/假/可能值的因子将转换为：

1 0 0
0 1 0
or
0 0 1

用于使用较低级别的回归代码。有没有一种方法可以通过熊猫图书馆实现类似的功能？我看到Pandas中有一些回归支持，但由于我有自己定制的回归例程，我对设计矩阵（2d numpy数组或矩阵）的构造非常感兴趣来自异构数据，支持numpy对象的列与派生它的Pandas数据帧之间的映射

更新：下面是一个数据矩阵示例，其中包含我所想到的类型的异构数据（示例来自Pandas手册）：

“a”列应转换为4个浮点列（“b”列可转换为单个浮点列，而“c”列应为设计矩阵中未修改的最后一列）

谢谢

SetJmp

我得到这个输出：

[ 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]

---

因此，第一列是“一”数据帧位置的指示符，第二列是“两”数据帧位置的指示符，依此类推。第4列和第5列是数据帧位置的指示符，分别为“x”和“y”，最后一列只是随机数据。

有一个名为patsy的新模块解决了这个问题。下面链接的quickstart只需几行代码就可以解决上述问题

下面是一个示例用法：

import pandas
import patsy

dataFrame = pandas.io.parsers.read_csv("salary2.txt") 
#salary2.txt is a re-formatted data set from the textbook
#Introductory Econometrics: A Modern Approach
#by Jeffrey Wooldridge
y,X = patsy.dmatrices("sl ~ 1+sx+rk+yr+dg+yd",dataFrame)
#X.design_info provides the meta data behind the X columns
print X.design_info

生成：

> DesignInfo(['Intercept',
>             'sx[T.male]',
>             'rk[T.associate]',
>             'rk[T.full]',
>             'dg[T.masters]',
>             'yr',
>             'yd'],
>            term_slices=OrderedDict([(Term([]), slice(0, 1, None)), (Term([EvalFactor('sx')]), slice(1, 2, None)),
> (Term([EvalFactor('rk')]), slice(2, 4, None)),
> (Term([EvalFactor('dg')]), slice(4, 5, None)),
> (Term([EvalFactor('yr')]), slice(5, 6, None)),
> (Term([EvalFactor('yd')]), slice(6, 7, None))]),
>            builder=<patsy.build.DesignMatrixBuilder at 0x10f169510>)

>设计信息（['Intercept'，
>“sx[T.male]”，
>“rk[T.associate]”，
>“rk[T.full]”，
>“dg[T.masters]”，
>“yr”，
>“yd”]，
>term_slices=OrderedDict（[（term（[]），slice（0，1，无）），（term（[EvalFactor（'sx'）]），slice（1，2，无）），
>（术语（[EvalFactor（'rk'）]），切片（2,4,None）），
>（术语（[EvalFactor（'dg'）]），切片（4,5,None）），
>（术语（[EvalFactor（'yr'））），切片（5,6,None）），
>（术语（[EvalFactor（'yd'）），切片（6，7，无）），
>生成器=）

patsy.dmatrices

在许多情况下都可以很好地工作。如果您只有一个向量-a

pandas.Series

，那么下面的代码可能会产生退化设计矩阵，并且没有截距列

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

---

从2014年2月3日起，熊猫0.13.1有一个方法：

>>> 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

---

values属性返回嵌套的数据数组，其中最里面的数组保存dtype=object。因子被转换成字符串，浮点数据是这个内部数组中的浮点。对我来说不是这样的。我对上面的问题进行了编辑以进行说明。它对您很有用，因为在您的示例中，所有数据都是浮点型的。然而，当字符串数据存在时，我得到了一个不同的结构作为返回类型。我所寻找的是一种逻辑映射，它将数据帧转换为二维浮点数组，然后将这些浮点数组放入一个低级解算器中，该解算器需要设计矩阵X和因变量y。所谓低级别，我指的是speudoinverse代码，它只知道如何处理二维浮点数组（而不是重数组）。这种较低级别的编码在统计参考中被称为“设计矩阵”。下面的讨论强调了R代码如何在发送到低级别解算器代码之前“幕后”将因素转换为设计矩阵。虽然示例因子只有2个级别，但我相信正确的行为可以预期为3个或更多级别。似乎

numpy

重新排列
可能是合适的。我来看看
值
是否可以轻松导出到
重新排列
不清楚“a”列应转换为4个浮点列”是什么意思。。。你是说4个浮点值吗？我不知道如何将第一列拆分为多个列来实现设计矩阵。我的理解是，这里的前两列是分类变量。你们的意思是你们想要4个二进制变量，只有当那个行数据有第一列分类号时，它们才等于1？将一个有k个级别的因子转换成k个不同的列/变量被称为离散化。在将连续值转换为离散值时，pasty是极好的。
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

>>> 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