Python中Pickle模块的dump()方法和load()方法

在机器学习中,我们常常需要把训练好的模型存储起来,这样在进行决策时直接将模型读出,而不需要重新训练模型,这样就大大节约了时间。Python提供的pickle模块就很好地解决了这个问题,它可以序列化对象并保存到磁盘中,并在需要的时候读取出来,任何对象都可以执行序列化操作。

Pickle模块中最常用的函数为:

(1)pickle.dump(obj, file, [,protocol])

函数的功能:将obj对象序列化存入已经打开的file中。

参数讲解:

obj:想要序列化的obj对象。
file:文件名称。
protocol:序列化使用的协议。如果该项省略,则默认为0。如果为负值或HIGHEST_PROTOCOL,则使用最高的协议版本。
(2)pickle.load(file)

函数的功能:将file中的对象序列化读出。

参数讲解:

file:文件名称。
(3)pickle.dumps(obj[, protocol])

函数的功能:将obj对象序列化为string形式,而不是存入文件中。

参数讲解:

obj:想要序列化的obj对象。
protocal:如果该项省略,则默认为0。如果为负值或HIGHEST_PROTOCOL,则使用最高的协议版本。
(4)pickle.loads(string)

函数的功能:从string中读出序列化前的obj对象。

参数讲解:

string:文件名称。
【注】 dump() 与 load() 相比 dumps() 和 loads() 还有另一种能力:dump()函数能一个接着一个地将几个对象序列化存储到同一个文件中,随后调用load()来以同样的顺序反序列化读出这些对象。

 

import matplotlib.pyplot as plt
import pandas as pd
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_iris
 
data=load_iris()
print(data.feature_names,data.target_names)

df=pd.DataFrame(data.data,columns=data.feature_names)
df['class']=data.target
print("************"*10)
print(type(data),sep='\n')

X,y=load_iris().data,load_iris().target

data_pca=PCA(n_components=2).fit_transform(X)
print(data_pca.shape)
print(y.shape)
print('y: ',y)
# z=[z for z in range(3) for i in range(150)]
plt.scatter(data_pca[:,0],data_pca[:,1],c=y)

  

#输出:
['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)'] ['setosa' 'versicolor' 'virginica']
************************************************************************************************************************
<class 'sklearn.utils._bunch.Bunch'>
(150, 2)
(150,)
y:  [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2
 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
 2 2]

  

python设置load_summarize_chain超时时间 python load_model_数据

 

 

 

from sklearn.datasets import load_iris

X, y = load_iris().data, load_iris().target

#或
from sklearn.datasets import load_boston

boston = load_boston()
x = boston.data
y = boston.target

#下载数据集
from sklearn.datasets import load_boston
boston = load_boston()
#查看数据键值
boston.keys()
#dict_keys(['data', 'target', 'feature_names', 'DESCR', 'filename'])
x = boston['data']
y = boston['target']
#查看数据结构
x.shape
#(506, 13)   #506个样本,13个属性

   

x_train,x_test,y_train,y_test = train_test_split(x,y,test_size=0.2)

#选择模型拟合训练集
from sklearn.linear_model import LinearRegression
lr = LinearRegression()
lr.fit(x_train,y_train)

#使用测试集测试数据
y_ = lr.predict(x_test)
#预测值与真实值的差距
(y_test-y_).round(2)

  

from sklearn import datasets
import numpy as np
import pandas as pd

iris = datasets.load_iris()
X=iris.data[:,:]
y=iris.target
print(X)
print(X.shape,type(iris))
print(y)

from sklearn.model_selection import train_test_split
X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0.33,random_state=3,shuffle=False)#默认shuffle为True,此处如
# 果用True效果比用False好,自己实验的一般来说随机种子用3比较好
print(X_train,X_test,y_train,y_test,sep='\n')

from sklearn.preprocessing import StandardScaler
sc=StandardScaler()
# sc.fit(X_train)
sc.fit(X)
X_train_std=sc.transform(X_train)
X_test_std=sc.transform(X_test)
print(X_train.shape,y_train.shape,X_test.shape,y_test.shape,sep='\n')

#拟合/训练
from sklearn.linear_model import Perceptron
ppn=Perceptron(n_iter_no_change=50,eta0=0.1,random_state=3)
ppn.fit(X_train_std,y_train)
y_pred=ppn.predict(X_test_std)#用导入的模型重新预测
print(f"Misclassfied sampled: {(y_test != y_pred).sum()}")

# 法1. 保存和导入训练好的模型
import pickle

f=pickle.dumps(ppn)#保存模型
ppn1=pickle.loads(f)#导入模型
y_pred1=ppn1.predict(X_test_std)#用导入的模型重新预测
print(f"Misclassfied sampled: {(y_test != y_pred1).sum()}")

# 法2. 保存和导入训练好的模型
from joblib import dump,load

dump(ppn,'./ppn.joblib')#当然也可以保存成其他后缀,比如pth
ppn2=load('ppn.joblib')#
y_pred2=ppn2.predict(X_test_std)
print(f"Misclassfied sampled: {(y_test != y_pred2).sum()}")

# ## sklearn 示例
# from sklearn import svm
# from sklearn import datasets
# clf = svm.SVC()
# X, y= datasets.load_iris(return_X_y=True)
# clf.fit(X, y)
#
# import pickle
# s = pickle.dumps(clf)
# clf2 = pickle.loads(s)
# clf2.predict(X[0:1])
# print(y[0])
#
# from joblib import dump, load
# dump(clf, 'filename.joblib')
# clf = load('filename.joblib')
# print(clf)

  

#打印出准确率
from sklearn.metrics import accuracy_score
print(f"Accuracy: {accuracy_score(y_test,y_pred):.2f}")

  

pickle.dump()

封装是一个将Python数据对象转化为字节流的过程,拆封是封装的逆操作,将字节文件或字节对象中的字节流转化为Python数据对象,不要从不收信任的数据源中拆封数据。可以封装和拆封几乎任何Python数据对象,主要包括:

    None , True,False
    整数,浮点数,复数
    字符串,字节,ByteArray对象
    元组,列表,集合,包含可封装对象的字典
    在一个模块的顶层定义的函数
    在一个模块的顶层定义的内置函数
    那是在一个模块的顶层定义的类
    __dict__或调用__getstate__()的结果是可封装的类的实例

 pickle模块中常用的方法有:

    1. pickle.dump(obj, file, protocol=None,)

    必填参数obj表示将要封装的对象

    必填参数file表示obj要写入的文件对象,file必须以二进制可写模式打开,即“wb”

    可选参数protocol表示告知pickler使用的协议,支持的协议有0,1,2,3,默认的协议是添加在Python 3中的协议3,     其他的协议详情见参考文档

    2. pickle.load(file,*,fix_imports=True, encoding="ASCII", errors="strict")

    必填参数file必须以二进制可读模式打开,即“rb”,其他都为可选参数

    3. pickle.dumps(obj):以字节对象形式返回封装的对象,不需要写入文件中

    4. pickle.loads(bytes_object): 从字节对象中读取被封装的对象,并返回

 pickle模块可能出现三种异常:

    1. PickleError:封装和拆封时出现的异常类,继承自Exception

    2. PicklingError: 遇到不可封装的对象时出现的异常,继承自PickleError

    3. UnPicklingError: 拆封对象过程中出现的异常,继承自PickleError

 pickle应用实例:

import pickle 
 

with open("my_profile.txt", "wb") as myprofile:  
    pickle.dump({"name":"AlwaysJane", "age":"20+", "sex":"female"}, myprofile)

with open("my_profile.txt", "rb") as get_myprofile:
    print (pickle.load(get_myprofile))

  

import pickle
 

class Profile:
    name = "AlwaysJane"

pickledclass = pickle.dumps(Profile)
print (pickledclass)
print (pickle.loads(pickledclass))

  

基础知识:

python自带的file函数只能存储和读取字符串格式的数据.
pickle可以存储和读取成其他格式比如list dict的数据,

pickle的功能就是把你上次计算得到的数据保存起来,当你需要使用这些数据时,直接通过reload把数据恢复了就行,这样的好处有:
1.被pickle的数据,在被多次reload时,不需要重新去计算得到这些数据,这样节省计算机资源,如果你不pickle,你每调用一次数据,就要计算一次。
2通过pickle的数据,被reload时,可以更好的被内存调用,不需要经过数据格式的转换。
有人可能觉得,我直接通过open把数据写到一个txt文档也能达到以上的效果,但是这样做的结果是,你能够达到pickle的功能,把数据保存起来,但是当你再去调用这些数据时,你的txt格式的数据,没有pickle的数据读取更高效。
另外还有一点,你通过open把数据存储到txt中时的效率,就不如pickle的效率高。
综上,你如果只是做一次的数据存储和调用,以及数据量很小的情况下,你可以用open等方法保存数据和调用数据,但是当你需要通过大量计算得到一个数据,同时后期还会多次使用这个数据时,pickle的节省计算机资源的效果就出来了。

 


在机器学习中,我们常常需要把训练好的模型存储起来,这样在进行决策时直接将模型读出,而不需要重新训练模型,这样就大大节约了时间。Python提供的pickle模块就很好地解决了这个问题,它可以序列化对象并保存到磁盘中,并在需要的时候读取出来,任何对象都可以执行序列化操作。

Pickle模块中最常用的函数为:

(1)pickle.dump(obj, file, [,protocol])

函数的功能:将obj对象序列化存入已经打开的file中。

参数讲解:

obj:想要序列化的obj对象。
file:文件名称。
protocol:序列化使用的协议。如果该项省略,则默认为0。如果为负值或HIGHEST_PROTOCOL,则使用最高的协议版本。
(2)pickle.load(file)

函数的功能:将file中的对象序列化读出。

参数讲解:

file:文件名称。
(3)pickle.dumps(obj[, protocol])

函数的功能:将obj对象序列化为string形式,而不是存入文件中。

参数讲解:

obj:想要序列化的obj对象。
protocal:如果该项省略,则默认为0。如果为负值或HIGHEST_PROTOCOL,则使用最高的协议版本。
(4)pickle.loads(string)

函数的功能:从string中读出序列化前的obj对象。

参数讲解:

string:文件名称。
【注】 dump() 与 load() 相比 dumps() 和 loads() 还有另一种能力:dump()函数能一个接着一个地将几个对象序列化存储到同一个文件中,随后调用load()来以同样的顺序反序列化读出这些对象。

 

import matplotlib.pyplot as plt
import pandas as pd
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_iris
 
data=load_iris()
print(data.feature_names,data.target_names)

df=pd.DataFrame(data.data,columns=data.feature_names)
df['class']=data.target
print("************"*10)
print(type(data),sep='\n')

X,y=load_iris().data,load_iris().target

data_pca=PCA(n_components=2).fit_transform(X)
print(data_pca.shape)
print(y.shape)
print('y: ',y)
# z=[z for z in range(3) for i in range(150)]
plt.scatter(data_pca[:,0],data_pca[:,1],c=y)

  

#输出:
['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)'] ['setosa' 'versicolor' 'virginica']
************************************************************************************************************************
<class 'sklearn.utils._bunch.Bunch'>
(150, 2)
(150,)
y:  [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2
 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
 2 2]

  

python设置load_summarize_chain超时时间 python load_model_数据

 

 

 

from sklearn.datasets import load_iris

X, y = load_iris().data, load_iris().target

#或
from sklearn.datasets import load_boston

boston = load_boston()
x = boston.data
y = boston.target

#下载数据集
from sklearn.datasets import load_boston
boston = load_boston()
#查看数据键值
boston.keys()
#dict_keys(['data', 'target', 'feature_names', 'DESCR', 'filename'])
x = boston['data']
y = boston['target']
#查看数据结构
x.shape
#(506, 13)   #506个样本,13个属性

   

x_train,x_test,y_train,y_test = train_test_split(x,y,test_size=0.2)

#选择模型拟合训练集
from sklearn.linear_model import LinearRegression
lr = LinearRegression()
lr.fit(x_train,y_train)

#使用测试集测试数据
y_ = lr.predict(x_test)
#预测值与真实值的差距
(y_test-y_).round(2)

  

from sklearn import datasets
import numpy as np
import pandas as pd

iris = datasets.load_iris()
X=iris.data[:,:]
y=iris.target
print(X)
print(X.shape,type(iris))
print(y)

from sklearn.model_selection import train_test_split
X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0.33,random_state=3,shuffle=False)#默认shuffle为True,此处如
# 果用True效果比用False好,自己实验的一般来说随机种子用3比较好
print(X_train,X_test,y_train,y_test,sep='\n')

from sklearn.preprocessing import StandardScaler
sc=StandardScaler()
# sc.fit(X_train)
sc.fit(X)
X_train_std=sc.transform(X_train)
X_test_std=sc.transform(X_test)
print(X_train.shape,y_train.shape,X_test.shape,y_test.shape,sep='\n')

#拟合/训练
from sklearn.linear_model import Perceptron
ppn=Perceptron(n_iter_no_change=50,eta0=0.1,random_state=3)
ppn.fit(X_train_std,y_train)
y_pred=ppn.predict(X_test_std)#用导入的模型重新预测
print(f"Misclassfied sampled: {(y_test != y_pred).sum()}")

# 法1. 保存和导入训练好的模型
import pickle

f=pickle.dumps(ppn)#保存模型
ppn1=pickle.loads(f)#导入模型
y_pred1=ppn1.predict(X_test_std)#用导入的模型重新预测
print(f"Misclassfied sampled: {(y_test != y_pred1).sum()}")

# 法2. 保存和导入训练好的模型
from joblib import dump,load

dump(ppn,'./ppn.joblib')#当然也可以保存成其他后缀,比如pth
ppn2=load('ppn.joblib')#
y_pred2=ppn2.predict(X_test_std)
print(f"Misclassfied sampled: {(y_test != y_pred2).sum()}")

# ## sklearn 示例
# from sklearn import svm
# from sklearn import datasets
# clf = svm.SVC()
# X, y= datasets.load_iris(return_X_y=True)
# clf.fit(X, y)
#
# import pickle
# s = pickle.dumps(clf)
# clf2 = pickle.loads(s)
# clf2.predict(X[0:1])
# print(y[0])
#
# from joblib import dump, load
# dump(clf, 'filename.joblib')
# clf = load('filename.joblib')
# print(clf)

  

#打印出准确率
from sklearn.metrics import accuracy_score
print(f"Accuracy: {accuracy_score(y_test,y_pred):.2f}")

  

pickle.dump()

封装是一个将Python数据对象转化为字节流的过程,拆封是封装的逆操作,将字节文件或字节对象中的字节流转化为Python数据对象,不要从不收信任的数据源中拆封数据。可以封装和拆封几乎任何Python数据对象,主要包括:

    None , True,False
    整数,浮点数,复数
    字符串,字节,ByteArray对象
    元组,列表,集合,包含可封装对象的字典
    在一个模块的顶层定义的函数
    在一个模块的顶层定义的内置函数
    那是在一个模块的顶层定义的类
    __dict__或调用__getstate__()的结果是可封装的类的实例

 pickle模块中常用的方法有:

    1. pickle.dump(obj, file, protocol=None,)

    必填参数obj表示将要封装的对象

    必填参数file表示obj要写入的文件对象,file必须以二进制可写模式打开,即“wb”

    可选参数protocol表示告知pickler使用的协议,支持的协议有0,1,2,3,默认的协议是添加在Python 3中的协议3,     其他的协议详情见参考文档

    2. pickle.load(file,*,fix_imports=True, encoding="ASCII", errors="strict")

    必填参数file必须以二进制可读模式打开,即“rb”,其他都为可选参数

    3. pickle.dumps(obj):以字节对象形式返回封装的对象,不需要写入文件中

    4. pickle.loads(bytes_object): 从字节对象中读取被封装的对象,并返回

 pickle模块可能出现三种异常:

    1. PickleError:封装和拆封时出现的异常类,继承自Exception

    2. PicklingError: 遇到不可封装的对象时出现的异常,继承自PickleError

    3. UnPicklingError: 拆封对象过程中出现的异常,继承自PickleError

 pickle应用实例:

import pickle 
 

with open("my_profile.txt", "wb") as myprofile:  
    pickle.dump({"name":"AlwaysJane", "age":"20+", "sex":"female"}, myprofile)

with open("my_profile.txt", "rb") as get_myprofile:
    print (pickle.load(get_myprofile))

  

import pickle
 

class Profile:
    name = "AlwaysJane"

pickledclass = pickle.dumps(Profile)
print (pickledclass)
print (pickle.loads(pickledclass))

  

基础知识:

python自带的file函数只能存储和读取字符串格式的数据.
pickle可以存储和读取成其他格式比如list dict的数据,

pickle的功能就是把你上次计算得到的数据保存起来,当你需要使用这些数据时,直接通过reload把数据恢复了就行,这样的好处有:
1.被pickle的数据,在被多次reload时,不需要重新去计算得到这些数据,这样节省计算机资源,如果你不pickle,你每调用一次数据,就要计算一次。
2通过pickle的数据,被reload时,可以更好的被内存调用,不需要经过数据格式的转换。
有人可能觉得,我直接通过open把数据写到一个txt文档也能达到以上的效果,但是这样做的结果是,你能够达到pickle的功能,把数据保存起来,但是当你再去调用这些数据时,你的txt格式的数据,没有pickle的数据读取更高效。
另外还有一点,你通过open把数据存储到txt中时的效率,就不如pickle的效率高。
综上,你如果只是做一次的数据存储和调用,以及数据量很小的情况下,你可以用open等方法保存数据和调用数据,但是当你需要通过大量计算得到一个数据,同时后期还会多次使用这个数据时,pickle的节省计算机资源的效果就出来了。