Ho bisogno di serializzare modelli scikit-learn/statsmodels in modo tale che tutte le dipendenze (codice + dati) siano impacchettate in un artefatto e questo artefatto possa essere usato per inizializzare il modello e fare previsioni. L'utilizzo del pickle module non è un'opzione, poiché si occuperà solo della dipendenza dei dati (il codice non sarà pacchettizzato). Quindi, sto conducendo esperimenti con Dill. Per rendere la mia domanda più precisa, il seguente è un esempio in cui costruisco un modello e lo mantengo.Quali sono le insidie nell'usare Dill per serializzare modelli scikit-learn/statsmodels?
from sklearn import datasets
from sklearn import svm
from sklearn.preprocessing import Normalizer
import dill
digits = datasets.load_digits()
training_data_X = digits.data[:-5]
training_data_Y = digits.target[:-5]
test_data_X = digits.data[-5:]
test_data_Y = digits.target[-5:]
class Model:
def __init__(self):
self.normalizer = Normalizer()
self.clf = svm.SVC(gamma=0.001, C=100.)
def train(self, training_data_X, training_data_Y):
normalised_training_data_X = normalizer.fit_transform(training_data_X)
self.clf.fit(normalised_training_data_X, training_data_Y)
def predict(self, test_data_X):
return self.clf.predict(self.normalizer.fit_transform(test_data_X))
model = Model()
model.train(training_data_X, training_data_Y)
print model.predict(test_data_X)
dill.dump(model, open("my_model.dill", 'w'))
Corrisponde a questo, ecco come inizializzo il modello persistente (in una nuova sessione) e faccio una previsione. Si noti che questo codice non inizializza esplicitamente o non conosce lo class Model.
import dill
from sklearn import datasets
digits = datasets.load_digits()
training_data_X = digits.data[:-5]
training_data_Y = digits.target[:-5]
test_data_X = digits.data[-5:]
test_data_Y = digits.target[-5:]
with open("my_model.dill") as model_file:
model = dill.load(model_file)
print model.predict(test_data_X)
Qualcuno ha usato Dill in questo modo ?. L'idea è che un data scientist estenda un ModelWrapper class per ogni modello che implementano e quindi costruisca l'infrastruttura intorno a ciò che persiste nei modelli, distribuisce i modelli come servizi e gestisce l'intero ciclo di vita del modello.
class ModelWrapper(object):
__metaclass__ = abc.ABCMeta
def __init__(self, model):
self.model = model
@abc.abstractmethod
def predict(self, input):
return
def dumps(self):
return dill.dumps(self)
def loads(self, model_string):
self.model = dill.loads(model_string)
Oltre le implicazioni di sicurezza (esecuzione di codice arbitrario) e il requisito che i moduli come scikit-learn dovrà essere installato sul thats macchina servono modello, ci sono e le altre insidie di questo approccio? Qualsiasi commento o parola di consiglio sarebbe molto utile.
Penso che il YHat e il Dato abbiano adottato un approccio simile, ma sono state implementate le implementazioni di Dill per scopi simili.
Ok. Ho un prototipo funzionante di questo e sembra funzionare bene. Ora, ho bisogno di fare lo stesso per R. Qualche suggerimento su questo? – Nikhil