数据预处理 (2)

最新推荐文章于 2023-06-16 21:30:58 发布
最新推荐文章于 2023-06-16 21:30:58 发布
阅读量601 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34910948/article/details/108005389
版权 
from sklearn.impute import SimpleImputer
import pandas as pd

data=pd.read_csv("Narrativedata.csv",index_col=0)
data.head()
AgeSexEmbarkedSurvived
022.0maleSNo
138.0femaleCYes
226.0femaleSYes
335.0femaleSYes
435.0maleSNo

1,1 impute.SimpleImputer

  • class sklearn.impute.SimpleImputer (missing_values=nan, strategy=’mean’, fill_value=None, verbose=0,
    copy=True)
data.info()

<class 'pandas.core.frame.DataFrame'>
Int64Index: 891 entries, 0 to 890
Data columns (total 4 columns):
Age         714 non-null float64
Sex         891 non-null object
Embarked    889 non-null object
Survived    891 non-null object
dtypes: float64(1), object(3)
memory usage: 34.8+ KB

age 填充

  • sklearn 中特征矩阵必须为二维
data.Age.values.shape

(891,)

Age=data.Age.values.reshape(-1,1)

imp_mean=SimpleImputer()
# 默认均值填充
#此时使用中位数填充
imp_median=SimpleImputer(strategy="median")
# 用0 填充
imp_0=SimpleImputer(strategy="constant",fill_value=0)


# imp_mean=imp_mean.fit_transform(Age)
# 会出现小说
# 避免该情况使用众数
imp_median=imp_median.fit_transform(Age)

# imp_median

data.Age=imp_median

data.info()

<class 'pandas.core.frame.DataFrame'>
Int64Index: 891 entries, 0 to 890
Data columns (total 4 columns):
Age         891 non-null float64
Sex         891 non-null object
Embarked    889 non-null object
Survived    891 non-null object
dtypes: float64(1), object(3)
memory usage: 34.8+ KB

# 使用众数填补Embarked

Embarked=data.Embarked.values.reshape(-1,1)
imp_mode=SimpleImputer(strategy="most_frequent")
data.Embarked=imp_mode.fit_transform(Embarked)

data.info()

<class 'pandas.core.frame.DataFrame'>
Int64Index: 891 entries, 0 to 890
Data columns (total 4 columns):
Age         891 non-null float64
Sex         891 non-null object
Embarked    891 non-null object
Survived    891 non-null object
dtypes: float64(1), object(3)
memory usage: 34.8+ KB

# 使用pandas 完成上述操作
data=pd.read_csv("Narrativedata.csv",index_col=0)
data.head()
AgeSexEmbarkedSurvived
022.0maleSNo
138.0femaleCYes
226.0femaleSYes
335.0femaleSYes
435.0maleSNo
data.Age=data.Age.fillna(data.Age.median())
data.info()

<class 'pandas.core.frame.DataFrame'>
Int64Index: 891 entries, 0 to 890
Data columns (total 4 columns):
Age         891 non-null float64
Sex         891 non-null object
Embarked    889 non-null object
Survived    891 non-null object
dtypes: float64(1), object(3)
memory usage: 34.8+ KB

# 三处Embark为空得行
data.dropna(axis=0,inplace=True)
data.info()

<class 'pandas.core.frame.DataFrame'>
Int64Index: 889 entries, 0 to 890
Data columns (total 4 columns):
Age         889 non-null float64
Sex         889 non-null object
Embarked    889 non-null object
Survived    889 non-null object
dtypes: float64(1), object(3)
memory usage: 34.7+ KB

data.info()

<class 'pandas.core.frame.DataFrame'>
Int64Index: 889 entries, 0 to 890
Data columns (total 4 columns):
Age         889 non-null float64
Sex         889 non-null object
Embarked    889 non-null object
Survived    889 non-null object
dtypes: float64(1), object(3)
memory usage: 34.7+ KB

2 处理分类型特征：编码与哑变量

在机器学习中，大多数算法，譬如逻辑回归，支持向量机SVM，k近邻算法等都只能够处理数值型数据，不能处理
文字，在sklearn当中，除了专用来处理文字的算法，其他算法在fit的时候全部要求输入数组或矩阵，也不能够导
入文字型数据（其实手写决策树和普斯贝叶斯可以处理文字，但是sklearn中规定必须导入数值型）。
然而在现实中，许多标签和特征在数据收集完毕的时候，都不是以数字来表现的。比如说，学历的取值可以是[“小
学”，“初中”，“高中”，“大学”]，付费方式可能包含[“支付宝”，“现金”，“微信”]等等。在这种情况下，为了让数据适
应算法和库，我们必须将数据进行编码，即是说，将文字型数据转换为数值型。

from sklearn.preprocessing import LabelEncoder
  • LabelEncoder:标签专用，用来将分类转化为分类数值
label=LabelEncoder().fit_transform(data.iloc[:,-1])

from sklearn.preprocessing import OrdinalEncoder

data=data.copy()
data.head()
AgeSexEmbarkedSurvived
022.0maleSNo
138.0femaleCYes
226.0femaleSYes
335.0femaleSYes
435.0maleSNo
  • preprocessing.OrdinalEncoder：特征专用，能够将分类特征转换为分类数值
    -类别OrdinalEncoder可以用来处理有序变量，但对于名义变量，我们只有使用哑变量的方式来处理，才能够尽量
    向算法传达最准确的信息：
data.iloc[:,1:-1]=OrdinalEncoder().fit_transform(data.iloc[:,1:-1])

data.head()
AgeSexEmbarkedSurvived
022.01.02.0No
138.00.00.0Yes
226.00.02.0Yes
335.00.02.0Yes
435.01.02.0No
OrdinalEncoder().fit(data.iloc[:,1:-1]).categories_

[array([0., 1.]), array([0., 1., 2.])]

preprocessing.OneHotEncoder：独热编码，创建哑变量

data2=data.copy()
data2.copy()
AgeSexEmbarkedSurvived
022.0maleSNo
138.0femaleCYes
226.0femaleSYes
335.0femaleSYes
435.0maleSNo
528.0maleQNo
654.0maleSNo
72.0maleSNo
827.0femaleSYes
914.0femaleCYes
104.0femaleSUnknown
1158.0femaleSYes
1220.0maleSNo
1339.0maleSNo
1414.0femaleSNo
1555.0femaleSUnknown
162.0maleQNo
1728.0maleSYes
1831.0femaleSNo
1928.0femaleCYes
2035.0maleSUnknown
2134.0maleSYes
2215.0femaleQYes
2328.0maleSYes
248.0femaleSNo
2538.0femaleSUnknown
2628.0maleCNo
2719.0maleSNo
2828.0femaleQYes
2928.0maleSNo
...............
86121.0maleSNo
86248.0femaleSYes
86328.0femaleSNo
86424.0maleSUnknown
86542.0femaleSUnknown
86627.0femaleCUnknown
86731.0maleSNo
86828.0maleSNo
8694.0maleSYes
87026.0maleSNo
87147.0femaleSUnknown
87233.0maleSNo
87347.0maleSNo
87428.0femaleCYes
87515.0femaleCYes
87620.0maleSNo
87719.0maleSNo
87828.0maleSNo
87956.0femaleCYes
88025.0femaleSYes
88133.0maleSNo
88222.0femaleSNo
88328.0maleSUnknown
88425.0maleSNo
88539.0femaleQNo
88627.0maleSNo
88719.0femaleSYes
88828.0femaleSNo
88926.0maleCUnknown
89032.0maleQNo

891 rows × 4 columns

from sklearn.preprocessing import OneHotEncoder

x=data2.iloc[:,1:-1]
SexEmbarked
0maleS
1femaleC
set(x.Sex)

{'female', 'male'}

enc=OneHotEncoder(categories="auto").fit_transform(x).toarray()

enc=OneHotEncoder(categories="auto").fit(x)

enc.get_feature_names()

array(['x0_female', 'x0_male', 'x1_C', 'x1_Q', 'x1_S'], dtype=object)

new_data=pd.concat([data2,pd.DataFrame(enc)],axis=1)

new_data.head()
AgeSexEmbarkedSurvived01234
022.0maleSNo0.01.00.00.01.0
138.0femaleCYes1.00.01.00.00.0
226.0femaleSYes1.00.00.00.01.0
335.0femaleSYes1.00.00.00.01.0
435.0maleSNo0.01.00.00.01.0
new_data.drop(["Sex","Embarked"],axis=1,inplace=True)

new_data.columns=["Age","Survived",'x0_female', 'x0_male', 'x1_C', 'x1_Q', 'x1_S']

new_data.head()
AgeSurvivedx0_femalex0_malex1_Cx1_Qx1_S
022.0No0.01.00.00.01.0
138.0Yes1.00.01.00.00.0
226.0Yes1.00.00.00.01.0
335.0Yes1.00.00.00.01.0
435.0No0.01.00.00.01.0
# 连续型特征处理 二值化或者分段
data_2=data.copy()
data_2.info()

<class 'pandas.core.frame.DataFrame'>
Int64Index: 891 entries, 0 to 890
Data columns (total 4 columns):
Age         891 non-null float64
Sex         891 non-null object
Embarked    891 non-null object
Survived    891 non-null object
dtypes: float64(1), object(3)
memory usage: 34.8+ KB

from sklearn.preprocessing import Binarizer


x=data_2.Age.values.reshape(-1,1)


tranformer=Binarizer(threshold=30).fit_transform(x)

tranformer

array([[0.],
       [1.],
       [0.],
       [1.],
       [1.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [1.],
       [0.],
       [1.],
       [0.],
       [0.],
       [1.],
       [0.],
       [1.],
       [1.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [1.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [1.],
       [0.],
       [1.],
       [0.],
       [1.],
       [1.],
       [0.],
       [0.],
       [0.],
       [1.],
       [1.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [1.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [1.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [1.],
       [1.],
       [0.],
       [1.],
       [1.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [1.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [1.],
       [1.],
       [1.],
       [0.],
       [0.],
       [0.],
       [1.],
       [1.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [1.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [1.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [1.],
       [1.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [1.],
       [1.],
       [0.],
       [0.],
       [1.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [1.],
       [1.],
       [0.],
       [0.],
       [1.],
       [1.],
       [0.],
       [1.],
       [0.],
       [0.],
       [1.],
       [1.],
       [0.],
       [0.],
       [1.],
       [1.],
       [0.],
       [1.],
       [1.],
       [0.],
       [0.],
       [1.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [1.],
       [1.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [1.],
       [1.],
       [1.],
       [0.],
       [0.],
       [1.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [1.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [1.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [1.],
       [0.],
       [1.],
       [1.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [1.],
       [1.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [1.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [1.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [1.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [1.],
       [1.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [1.],
       [1.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [1.],
       [0.],
       [1.],
       [0.],
       [1.],
       [1.],
       [1.],
       [1.],
       [0.],
       [1.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [1.],
       [1.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [1.],
       [0.],
       [0.],
       [1.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [1.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [1.],
       [0.],
       [1.],
       [1.],
       [0.],
       [1.],
       [1.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [1.],
       [1.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [1.],
       [1.],
       [1.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [1.],
       [0.],
       [1.],
       [1.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [1.],
       [1.],
       [1.],
       [0.],
       [0.],
       [0.],
       [1.],
       [1.],
       [0.],
       [1.],
       [0.],
       [1.],
       [1.],
       [1.],
       [0.],
       [0.],
       [1.],
       [1.],
       [0.],
       [0.],
       [1.],
       [1.],
       [1.],
       [0.],
       [1.],
       [1.],
       [0.],
       [1.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [1.],
       [1.],
       [1.],
       [0.],
       [0.],
       [0.],
       [1.],
       [1.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [1.],
       [1.],
       [0.],
       [0.],
       [0.],
       [1.],
       [1.],
       [1.],
       [0.],
       [0.],
       [0.],
       [1.],
       [1.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [1.],
       [1.],
       [1.],
       [1.],
       [1.],
       [0.],
       [1.],
       [0.],
       [0.],
       [1.],
       [0.],
       [1.],
       [1.],
       [1.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [1.],
       [1.],
       [1.],
       [0.],
       [1.],
       [1.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [1.],
       [1.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [1.],
       [0.],
       [1.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [1.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [1.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [1.],
       [1.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [1.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [1.],
       [1.],
       [0.],
       [1.],
       [0.],
       [1.],
       [0.],
       [1.],
       [0.],
       [1.],
       [0.],
       [1.],
       [0.],
       [1.],
       [1.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [1.],
       [1.],
       [0.],
       [0.],
       [1.],
       [1.],
       [0.],
       [0.],
       [0.],
       [1.],
       [1.],
       [0.],
       [1.],
       [1.],
       [0.],
       [1.],
       [1.],
       [0.],
       [1.],
       [0.],
       [0.],
       [1.],
       [1.],
       [0.],
       [1.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [1.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [1.],
       [0.],
       [1.],
       [1.],
       [0.],
       [0.],
       [1.],
       [0.],
       [1.],
       [0.],
       [0.],
       [1.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [1.],
       [1.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [1.],
       [0.],
       [0.],
       [0.],
       [0.],
       [1.]])

  • preprocessing.KBinsDiscretizer

  • 这是将连续型变量划分为分类变量的类，能够将连续型变量排序后按顺序分箱后编码。总共包含三个重要参数

  • n_bins 每个特征中分箱的个数，默认5，一次会被运用到所有导入的特征

  • encode 编码的方式，默认“onehot”

  • “onehot”：做哑变量，之后返回一个稀疏矩阵，每一列是一个特征中的一个类别，含有该

  • 类别的样本表示为1，不含的表示为0

  • “ordinal”：每个特征的每个箱都被编码为一个整数，返回每一列是一个特征，每个特征下含
    有不同整数编码的箱的矩阵

  • “onehot-dense”：做哑变量，之后返回一个密集数组

  • strategy 用来定义箱宽的方式，默认"quantile"
    - 用来定义箱宽的方式，默认"quantile"
    - “uniform”：表示等宽分箱，即每个特征中的每个箱的最大值之间的差为
    - (特征.max() - 特征.min())/(n_bins)
    - “quantile”：表示等位分箱，即每个特征中的每个箱内的样本数量都相同
    - “kmeans”：表示按聚类分箱，每个箱中的值到最近的一维k均值聚类的簇心得距离都相同

from sklearn.preprocessing import KBinsDiscretizer
X = data.iloc[:,0].values.reshape(-1,1)
est = KBinsDiscretizer(n_bins=3, encode='ordinal', strategy='uniform')
est.fit_transform(X)
#查看转换后分的箱：变成了一列中的三箱
set(est.fit_transform(X).ravel())
est = KBinsDiscretizer(n_bins=3, encode='onehot', strategy='uniform')
#查看转换后分的箱：变成了哑变量
est.fit_transform(X).toarray()

array([[1., 0., 0.],
       [0., 1., 0.],
       [1., 0., 0.],
       ...,
       [0., 1., 0.],
       [1., 0., 0.],
       [0., 1., 0.]])

菜菜的sklearn学习得到 https://live.bilibili.com/12582510

qq_34910948
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据预处理_BP_预处理_数据预处理_
10-03
简单的BP神经网络分类，包括数据，预处理的程序如果需要可以联系我
Pytorch学习笔记实例1——二分类
qq_39697468的博客
05-18 204
#!/usr/bin/env python # coding: utf-8 # In[1]: import matplotlib.pyplot as plt import numpy as np import pandas as pd import torch # In[34]: # 读数据 # In[2]: data = pd.read_csv('./dataset/credit-a.csv',header=None) # In[3]: data # In[35]:
reshape(-1,1)什么意思
06-16 902
reshape(-1,1)这里的-1被理解为unspecified value，意思是未指定为给定的。如果我只需要特定的列数，行数多少我无所谓，我只需要指定列数，那么行数直接用-1代替就行了，计算机帮我们算赢有多少行，反之亦然。reshape(-1,1)这里的-1被理解为unspecified value，意思是未指定为给定的。如果我只需要特定的列数，行数多少我无所谓，我只需要指定列数，那么行数直接用-1代替就行了，计算机帮我们算赢有多少行，反之亦然。
机器学习中的格式变化之--data.values.reshape(-1,1)
辩学思问的博客
07-10 1万+
转自：https://blog.csdn.net/wld914674505/article/details/80460042 data.values.reshape(-1,1) z = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]...
PYTHON基础
julyclj55555的博客
12-15 1710
一、字符串 1、字符串的创建 使用单引号或者双引号，都可以创建字符串，两者联合使用，可以创建字符串中的字符串的效果：b = ‘my_name is “TOM”’ 连续三个单引号或者三个双引号，可以创建多行字符串：resume = ‘’’ name=“gaoqi” company=“sxt” age=18 lover=“Tom”’’’ 空字符串’ '，不包含任何字符且长度为0，len()用于计算字符串的长度，即含有多少个字符。 2、字符串中的转义符号 \ 反斜杠符号 \b 退格(Backspace) \n 换
reshape(-1,1)
Jennie
03-13 2万+
reshape(行数，列数)常用来更改数据的行列数目 一般可用于numpy的array和ndarray, pandas的dataframe和series(series需要先用series.values把对象转化成ndarray结构) 那么问题来了reshape(-1,1)是什么意思呢？难道有-1行？ 这里-1是指未设定行数，程序随机分配，所以这里-1表示任一正整数 所以reshape(-1,1)表...
2.吴恩达机器学习--逻辑回归
qq_45069496的博客
06-29 697
根据学生的两门学生成绩，预测该学生是否会被大学录取。数据集 ex2data1.txt 中包含了两门课的成绩以及是否被大学录取，0代表未录取，1代表录取。 4. 定义sigmoid函数和损失函数   对于逻辑回归模型，我们构建的模型为：P(y=1∣x;θ)=11+e−θTxP(y=1|x;\theta) = \frac{1}{1 + e^{-\theta^Tx}}P(y=1∣x;θ)=1+e−θTx1​   代码中（mmm表示样本维度，nnn表示样本个数）：X=[1x01x02⋯x0m1x11x12⋯x1
特征预处理
weixin_54096215的博客
08-27 184
一.归一化 原因： 公式： 作用于每一列，max为每一列的最大值，min为每一列的最小值，mx默认区间为1，mi为0； API: sklearn.preprocessing 过程： 1.获取数据 2.实例化一个转换器 3.调用fit_transform 代码： from sklearn.preprocessing import MinMaxScaler ef data_process(): # 1.获取数据 f = pd.read_excel...
数据预处理课件
06-14
数据预处理是数据分析过程中的关键步骤，它旨在改善原始数据的质量，确保后续的数据分析和挖掘工作更为准确和高效。在本课件中，主要探讨了数据预处理的重要性、方法以及描述性数据汇总。 首先，数据预处理的原因...
python新手数据预处理案例练习
04-03
新手python数据预处理练习：1.鸢尾花数据处理2.探索chipotle数据3.探索Apple公司股价数据4.作业招聘数据探索分析
数据预处理代码_数据预处理_
10-03
一丢丢数据预处理，数据导入，查看缺失值，删除缺失值所在行，取对数差分
数据预处理数据预处理数据预处理
05-17
数据预处理数据预处理
python中reshape后数据排列方式
u011609063的博客
07-01 3640
python中reshape后数据排列方式1. 序言2. 如何手动计算2.1 针对order="C"2.2 验证2.2 针对order="F" 1. 序言 在python中，我们可能会接触numpy或者pytorch，tensorflow等，在这些库或者框架中，他们都有reshape方式，通过reshape可以将给定维度的数组换成另外一个维度。当在使用的时候，如果不清楚原理，我们可能会使用错并且还没那么容易发现自己的错误。 2. 如何手动计算 2.1 针对order=“C” 对于任意维度的一个数组，我们可以
Numpy中reshape函数、reshape(1,-1)的含义(浅显易懂，源码实例)
热门推荐
W_weiying的博客
08-27 6万+
本文详细介绍numpy中reshape函数的三种常见相关用法。 一般用法：numpy.arange(n).reshape(a, b); 依次生成n个自然数，并且以a行b列的数组形式显示: In [1]: np.arange(16).reshape(2,8) #生成16个自然数，以2行8列的形式显示 Out[1]: array([[ 0, 1, 2, 3, 4, 5, 6, ...
pandas的reshape(1,-1)
qq_38095787的博客
05-04 1004
df['Amount'].values.reshape(-1,1) （行，列）：-1指未指定具体的行数，具体的由指定的列数1决定
「08」回归的诱惑：深入浅出逻辑回归（Python实战篇）
Machine Learning with Tutors
01-21 2025
在上一篇文章「07」回归的诱惑：深入浅出逻辑回归里，我们详细解释了什么是分类算法以及逻辑回归、逻辑回归的特点，这一期给出实战案例的Python代码，供大家参考 第一步 导入数据 from collections import OrderedDict import pandas as pd #数据集 examDict={ '学习时间':[0.50,0.75,1.00,1.25...
PyTorch 03—逻辑回归与多层感知器
qq_39172845的博客
03-05 1733
PyTorch笔记—逻辑回归与多层感知器
记录遇到的几个场景题
qq_23669881的博客
11-03 186
(1) 如何实现亿级数据的全排序 其实考察的就是merge思想，内存不够时候的解决方案。现在的成熟解决框架，就是hadoop,storm这些。以hadoop为例，记录下什么阶段会排序。 1.map最后阶段进行partition分区，一般使用job.setPartitionerClass设置的类，如果没有自定义Key的hashCode()方法进行分区。在map阶段写出到环形缓冲区，在环形缓冲区溢写时会进行一次排序，每个分区内部调用job.setSortComparatorClass设置的key的比较函数类
protobuf-3.16.0-cp35-cp35m-win32.whl
最新发布
06-21
Python库是一组预先编写的代码模块，旨在帮助开发者实现特定的编程任务，无需从零开始编写代码。这些库可以包括各种功能，如数学运算、文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
amser2数据预处理
05-15
Amser2是一个大规模的数据集，用于训练机器学习模型。在使用Amser2之前，需要对其进行数据预处理，以确保数据的质量和可用性。 数据预处理包含以下步骤： 1. 数据清洗：清除数据中的缺失值、异常值和重复值等。这有助于提高模型的精度和可靠性。 2. 数据转换：将原始数据转换为模型可接受的格式，如转化为数值型数据、归一化数据等。 3. 特征选择：选择最重要的特征来提高模型性能，同时减少计算复杂性和降低过拟合的风险。 4. 数据划分：将数据集划分为训练数据、验证数据和测试数据，并且按照一定比例分配。 5. 数据平衡：对于不平衡的数据集，需要进行过采样与欠采样。 数据预处理是机器学习中非常重要的步骤，它直接影响模型的效果。在使用Amser2之前，我们需要进行相关的数据预处理，以提高模型的精度和可靠性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值