Lưu phân loại vào đĩa trong scikit-học

Question

Làm thế nào để tiết kiệm một huấn luyện Naive Bayes phân loại để đĩa và sử dụng nó để dự đoán dữ liệu?

tôi có chương trình mẫu sau đây từ trang web scikit-học:

from sklearn import datasets 
iris = datasets.load_iris() 
from sklearn.naive_bayes import GaussianNB 
gnb = GaussianNB() 
y_pred = gnb.fit(iris.data, iris.target).predict(iris.data) 
print "Number of mislabeled points : %d" % (iris.target != y_pred).sum() 

Answer 1

Classifiers chỉ là đối tượng có thể được ngâm và đổ giống như bất kỳ khác. Tiếp tục ví dụ của bạn:

import cPickle 
# save the classifier 
with open('my_dumped_classifier.pkl', 'wb') as fid: 
    cPickle.dump(gnb, fid)  

# load it again 
with open('my_dumped_classifier.pkl', 'rb') as fid: 
    gnb_loaded = cPickle.load(fid) 

Answer 2

Bạn cũng có thể sử dụng joblib.dump và joblib.load đó là hiệu quả hơn tại xử lý mảng số hơn Pickler python mặc định.

Joblib được bao gồm trong scikit-học:

>>> from sklearn.externals import joblib 
>>> from sklearn.datasets import load_digits 
>>> from sklearn.linear_model import SGDClassifier 

>>> digits = load_digits() 
>>> clf = SGDClassifier().fit(digits.data, digits.target) 
>>> clf.score(digits.data, digits.target) # evaluate training error 
0.9526989426822482 

>>> filename = '/tmp/digits_classifier.joblib.pkl' 
>>> _ = joblib.dump(clf, filename, compress=9) 

>>> clf2 = joblib.load(filename) 
>>> clf2 
SGDClassifier(alpha=0.0001, class_weight=None, epsilon=0.1, eta0=0.0, 
     fit_intercept=True, learning_rate='optimal', loss='hinge', n_iter=5, 
     n_jobs=1, penalty='l2', power_t=0.5, rho=0.85, seed=0, 
     shuffle=False, verbose=0, warm_start=False) 
>>> clf2.score(digits.data, digits.target) 
0.9526989426822482 

Answer 3

gì bạn đang tìm kiếm được gọi là mẫu kiên trì nói cách sklearn và nó được ghi chép lại trong introduction và trong model persistence phần.

Vì vậy, bạn đã khởi tạo phân loại của bạn và huấn luyện nó trong một thời gian dài với

clf = some.classifier() 
clf.fit(X, y) 

Sau này, bạn có hai lựa chọn:

1) Sử dụng Pickle

import pickle 
# now you can save it to a file 
with open('filename.pkl', 'wb') as f: 
    pickle.dump(clf, f) 

# and later you can load it 
with open('filename.pkl', 'rb') as f: 
    clf = pickle.load(f) 

2) Sử dụng Joblib

from sklearn.externals import joblib 
# now you can save it to a file 
joblib.dump(clf, 'filename.pkl') 
# and later you can load it 
clf = joblib.load('filename.pkl') 

Một lần nữa nó là hữu ích để đọc các liên kết nêu trên

Answer 4

Trong nhiều trường hợp, đặc biệt là với phân loại văn bản đó là không đủ chỉ để lưu trữ các phân loại nhưng bạn sẽ cần để lưu trữ các vectorizer cũng để bạn có thể vector hóa đầu vào của mình trong tương lai.

import pickle 
with open('model.pkl', 'wb') as fout: 
    pickle.dump((vectorizer, clf), fout) 

tương lai trường hợp sử dụng:

with open('model.pkl', 'rb') as fin: 
    vectorizer, clf = pickle.load(fin) 

X_new = vectorizer.transform(new_samples) 
X_new_preds = clf.predict(X_new) 

Trước khi bán phá giá vectorizer, người ta có thể xóa các tài sản stop_words_ của vectorizer bởi:

vectorizer.stop_words_ = None 

để bán phá giá hiệu quả hơn. Ngoài ra nếu các tham số phân loại của bạn thưa thớt (như trong hầu hết các ví dụ phân loại văn bản), bạn có thể chuyển đổi các tham số từ dày đặc sang thưa thớt sẽ tạo ra sự khác biệt lớn về mức tiêu thụ bộ nhớ, tải và bán phá giá. Sparsify mô hình bằng cách:

clf.sparsify() 

Mà sẽ tự động làm việc cho SGDClassifier nhưng trong trường hợp bạn biết mô hình của bạn là thưa thớt (nhiều số không trong clf.coef_) sau đó bạn có thể tự chuyển đổi CLF.coef_ vào một csr scipy sparse matrix bởi:

và sau đó bạn có thể lưu trữ hiệu quả hơn.

Answer 5

sklearn bộ ước tính thực hiện các phương pháp giúp bạn dễ dàng lưu các thuộc tính được đào tạo có liên quan của một bộ ước tính. Một số ước lượng thực hiện __getstate__ phương pháp bản thân, nhưng những người khác, giống như GMM chỉ cần sử dụng base implementation mà chỉ đơn giản giúp tiết kiệm các đối tượng từ điển bên trong:

def __getstate__(self): 
    try: 
     state = super(BaseEstimator, self).__getstate__() 
    except AttributeError: 
     state = self.__dict__.copy() 

    if type(self).__module__.startswith('sklearn.'): 
     return dict(state.items(), _sklearn_version=__version__) 
    else: 
     return state 

Phương pháp khuyến khích để lưu mô hình của bạn để đĩa là sử dụng pickle mô-đun:

from sklearn import datasets 
from sklearn.svm import SVC 
iris = datasets.load_iris() 
X = iris.data[:100, :2] 
y = iris.target[:100] 
model = SVC() 
model.fit(X,y) 
import pickle 
with open('mymodel','wb') as f: 
    pickle.dump(model,f) 

Tuy nhiên, bạn nên lưu dữ liệu bổ sung để có thể đào tạo lại mô hình trong tương lai hoặc gặp hậu quả nghiêm trọng (chẳng hạn như bị khóa vào phiên bản cũ của sklearn).

Từ documentation:

Để xây dựng lại một mô hình tương tự với các phiên bản tương lai của scikit-học, metadata bổ sung nên được lưu dọc theo ngâm mô hình:

Dữ liệu huấn luyện, ví dụ một tham chiếu đến một bản chụp bất biến

Mã nguồn python sử dụng để tạo ra các mô hình

Các phiên bản của scikit-học và phụ thuộc của nó

Các kiểm chứng chéo điểm số thu được trên dữ liệu huấn luyện

Điều này đặc biệt đúng đối với các bộ ước lượng Ensemble dựa trên mô-đun tree.pyx được viết bằng Cython (chẳng hạn như IsolationForest), vì nó tạo ra sự ghép nối với người thực hiện tation, không được đảm bảo ổn định giữa các phiên bản của sklearn. Nó đã thấy những thay đổi không tương thích ngược trong quá khứ.

Nếu mô hình của bạn trở nên rất lớn và tải trở thành mối phiền toái, bạn cũng có thể sử dụng hiệu quả hơn joblib. Từ các tài liệu:

Trong trường hợp cụ thể của scikit, nó có thể là thú vị hơn để sử dụng thay thế joblib của pickle (joblib.dump & joblib.load), đó là hiệu quả hơn trên các đối tượng mang mảng NumPy lớn trong nội bộ như thường là trường hợp cho các trình ước tính tìm hiểu được trang bị scikit, nhưng chỉ có thể dưa vào đĩa chứ không phải một chuỗi: