Python Pickle-tutorial: objectserialisatie

Waarom hebben we objectserialisatie nodig?

Voordat we beginnen met Python Pickle, is het goed om te begrijpen waarom objectserialisatie zo belangrijk is.

Je vraagt je misschien af waarom we datastructuren niet gewoon in een tekstbestand kunnen opslaan en ze later weer openen in plaats van ze te moeten serialiseren.

Laten we een eenvoudig voorbeeld bekijken om de voordelen van serialisatie te begrijpen.

Hier is een geneste dictionary met studentinformatie zoals naam, leeftijd en geslacht:

students = {

  'Student 1': {
        'Name': "Alice", 'Age' :10, 'Grade':4,
    },   
    'Student 2': {
        'Name':'Bob', 'Age':11, 'Grade':5
    },   
    'Student 3': {
        'Name':'Elena', 'Age':14, 'Grade':8
    }   
}

Laten we het datatype van het object “students” bekijken:

type(students)

dict

Nu we hebben bevestigd dat het studentobject een dictionary is, schrijven we het zonder serialisatie naar een tekstbestand:

with open('student_info.txt','w') as data:
      data.write(str(students))

Let op: omdat we alleen strings naar tekstbestanden kunnen schrijven, hebben we de dictionary geconverteerd naar een string met de functie str(). Dit betekent dat de oorspronkelijke staat van onze dictionary verloren is gegaan.

Nu lezen we de dictionary, printen die en controleren opnieuw het type:

with open("student_info.txt", 'r') as f:
    for students in f:
        print(students)

type(students)

str

De geneste dictionary wordt nu als string weergegeven en zal een fout geven als we de keys of values proberen te benaderen.

Hier komt serialisatie van pas.

Bij complexere datatypen zoals dictionaries, dataframes en geneste lijsten zorgt serialisatie ervoor dat je de oorspronkelijke staat van het object bewaart zonder relevante informatie te verliezen.

Later in dit artikel leren we hoe we dezelfde dictionary met Pickle in een bestand opslaan en deze met de bibliotheek deserialiseren. Je kunt meer lezen over Python dictionary comprehension in een aparte tutorial. 

Introductie tot Pickle in Python

De Pickle-module van Python is een populair formaat om datatypen te serialiseren en deserialiseren. Dit formaat is native voor Python, wat betekent dat Pickle-objecten niet met een andere programmeertaal kunnen worden geladen.

Pickle heeft zijn eigen voordelen en nadelen ten opzichte van andere serialisatieformaten.

Voordelen van Pickle voor het serialiseren van objecten

• In tegenstelling tot serialisatieformaten zoals JSON, die niet met tuples en datetime-objecten overweg kunnen, kan Pickle bijna elk veelgebruikt ingebouwd Python-datatype serialiseren. Het behoudt ook exact de staat van het object, wat JSON niet kan.
• Pickle is ook een goede keuze voor recursieve structuren, omdat het een object maar één keer wegschrijft.
• Pickle biedt flexibiliteit bij het deserialiseren. Je kunt eenvoudig verschillende variabelen in een Pickle-bestand opslaan en ze in een andere Python-sessie terugladen, precies zoals ze waren, zonder je code te hoeven aanpassen.

Nadelen van Pickle

• Pickle is onveilig omdat het kwaadaardige Python-callables kan uitvoeren om objecten te construeren. Bij het deserialiseren kan Pickle geen onderscheid maken tussen een kwaadaardige en een niet-kwaadaardige callable. Hierdoor kun je tijdens deserialisatie willekeurige code uitvoeren.
• Zoals eerder genoemd is Pickle een Python-specifieke module, en het kan lastig zijn om gepickelde objecten in een andere taal te deserialiseren.
• Volgens meerdere benchmarks is Pickle trager en produceert het grotere geserialiseerde waarden dan formaten zoals JSON en Apache Thrift.

Objecten opslaan en laden met de Pickle-functies dump en load

Pickle gebruikt de volgende functies voor het serialiseren en deserialiseren van Python-objecten:

pickle.dump(obj, file, protocol=None, *, fix_imports=True, buffer_callback=None)

pickle.dumps(obj, protocol=None, *, fix_imports=True, buffer_callback=None)

pickle.load(file, *, fix_imports=True, encoding='ASCII', errors='strict', buffers=None)

pickle.loads(data, /, *, fix_imports=True, encoding=”ASCII”, errors=”strict”, buffers=None)

De Pickle-functies dump() en dumps() worden gebruikt om een object te serialiseren. Het enige verschil is dat dump() de data naar een bestand schrijft, terwijl dumps() een byte-object teruggeeft. 

Evenzo leest load() gepickelde objecten uit een bestand, terwijl loads() ze deserialiseert uit een bytes-achtig object.

In deze tutorial gebruiken we de functies dump() en load() om Python-objecten naar een bestand te pickelen en weer te “unpickelen”.

Python-datastructuren serialiseren met Pickle

Lijsten

Eerst maken we een eenvoudige Python-lijst:

import pickle 

student_names = ['Alice','Bob','Elena','Jane','Kyle']

Nu openen we een tekstbestand, schrijven de lijst erin met de functie dumps(), en sluiten het bestand:

with open('student_file.pkl', 'wb') as f:  # open a text file
    pickle.dump(student_names, f) # serialize the list

We hebben eerst een bestand “student_file.pkl” aangemaakt. De extensie hoeft niet .pkl te zijn. Je kunt het noemen zoals je wilt en het bestand wordt alsnog aangemaakt. Toch is het goede gewoonte om de .pkl-extensie te gebruiken als herinnering dat dit een Pickle-bestand is.

Let ook op dat we het bestand in modus wb hebben geopend. Dit betekent dat je in binaire modus schrijft, zodat de data als bytes-object wordt opgeslagen.

Vervolgens gebruiken we de functie dump() om de lijst student_names in het bestand te bewaren.

Tot slot kun je het bestand sluiten met de volgende regel code:

f.close()

Nu deserialiseren we het bestand en printen we de lijst:

with open('student_file.pkl', 'rb') as f:

    student_names_loaded = pickle.load(f) # deserialize using load()
    print(student_names_loaded) # print student names

De output van de bovenstaande code zou als volgt moeten zijn:

['Alice', 'Bob', 'Elena', 'Jane', 'Kyle']

Merk op dat we om te deserialiseren de modus rb (read binary) moeten gebruiken. Daarna unpickelen we het object met de functie load(), waarna we de data in een andere variabele kunnen opslaan en naar wens gebruiken.

Laten we nu het datatype controleren van de lijst die we zojuist hebben ge-unpickeld:

type(student_names_loaded)

list

Top! We hebben de oorspronkelijke staat en het datatype van deze lijst behouden.

Numpy-arrays

Laten we nu een iets complexer datatype serialiseren en deserialiseren: Numpy-arrays.

We maken eerst een 10 bij 10-array van enen:

import numpy as np

numpy_array = np.ones((10,10)) # 10x10 array

Vervolgens roepen we, net als eerder, de functie dump() aan om deze array naar een bestand te serialiseren:

with open('my_array.pkl','wb') as f:
    pickle.dump(numpy_array, f)

Tot slot unpickelen we deze array en controleren we de vorm en het datatype om te bevestigen dat de oorspronkelijke staat behouden is:

with open('my_array.pkl','rb') as f:
    unpickled_array = pickle.load(f)
    print('Array shape: '+str(unpickled_array.shape))
    print('Data type: '+str(type(unpickled_array)))

Je zou de volgende output moeten krijgen:

Array shape: (10, 10)

Data type: <class 'numpy.ndarray'>

Het ge-unpickelde object is een 10x10 Numpy-array, met dezelfde vorm en hetzelfde datatype als het object dat we hebben geserialiseerd.

pandas DataFrames

Een dataframe is een object waar data scientists dagelijks mee werken. De populairste manier om een pandas DataFrame te laden en op te slaan is via CSV-bestanden. Leer meer over importeren in onze pandas read_csv()-tutorial. 

Dit proces is echter trager dan serialisatie en kan extreem tijdrovend worden als het dataframe groot is.

Laten we de efficiëntie van het opslaan en laden van een pandas-dataframe met Pickle versus CSV vergelijken door de benodigde tijd te meten.

We maken eerst een pandas-dataframe met 100.000 rijen aan gegenereerde data:

import pandas as pd
import numpy as np

# Set random seed
np.random.seed(123)

data = {'Column1': np.random.randint(0, 10, size=100000),
        'Column2': np.random.choice(['A', 'B', 'C'], size=100000),
        'Column3': np.random.rand(100000)}


# Create Pandas dataframe
df = pd.DataFrame(data)

Nu berekenen we hoeveel tijd het kost om dit dataframe als csv-bestand op te slaan:

import time

start = time.time()

df.to_csv('pandas_dataframe.csv')

end = time.time()
print(end - start)

0.19349145889282227

Het kostte 0,19 seconden om een pandas-dataframe met drie kolommen en 100.000 rijen als csv op te slaan.

Laten we kijken of Pickle de prestaties kan verbeteren. De pandas-bibliotheek heeft een methode to_pickle() waarmee we dataframes in één regel naar pickle-bestanden kunnen serialiseren:

start = time.time()

df.to_pickle("my_pandas_dataframe.pkl")

end = time.time()
print(end - start)

0.0059659481048583984

Het kostte slechts 5 milliseconden om hetzelfde pandas DataFrame naar een Pickle-bestand op te slaan, een aanzienlijke prestatieverbetering ten opzichte van CSV.

Nu lezen we het bestand terug in pandas en kijken of het laden van een Pickle-bestand ook sneller is dan een csv-bestand inlezen:

# Reading the csv file into Pandas:
start1 = time.time()
df_csv = pd.read_csv("my_pandas_dataframe.csv")
end1 = time.time()
print("Time taken to read the csv file: " + str(end1 - start1) + "\n")

# Reading the Pickle file into Pandas:
start2 = time.time()
df_pkl = pd.read_pickle("my_pandas_dataframe.pkl")
end2 = time.time()
print("Time taken to read the Pickle file: " + str(end2 - start2))

De bovenstaande code zou de volgende output moeten geven:

Time taken to read the csv file: 0.00677490234375

Time taken to read the Pickle file: 0.0009608268737792969

Het kostte 6 milliseconden om het CSV-bestand in pandas te lezen en slechts 0,9 milliseconde om het Pickle-bestand te laden. 

Hoewel dit verschil klein lijkt, kan het serialiseren van grote pandas-dataframes met Pickle aanzienlijke tijdwinst opleveren. Pickle helpt ook het datatype van elke kolom te behouden en neemt minder schijfruimte in dan een CSV-bestand.

Dictionaries

Tot slot serialiseren we de dictionary die we in het eerste deel van de tutorial naar een tekstbestand schreven:

students = {
  'Student 1': {
        'Name': "Alice", 'Age' :10, 'Grade':4,
    },
   
    'Student 2': {
        'Name':'Bob', 'Age':11, 'Grade':5
    },
   
    'Student 3': {
        'Name':'Elena', 'Age':14, 'Grade':8
    }
}

Weet je nog dat we deze dictionary naar een string moesten omzetten toen we hem als tekstbestand opsloegen, waardoor de oorspronkelijke staat verloren ging.

Nu serialiseren we hem met Pickle en lezen we hem terug om te controleren of alle eigenschappen van een Python-dictionary behouden zijn:

# serialize the dictionary to a pickle file
with open("student_dict.pkl", "wb") as f:
    pickle.dump(students, f)
   
# deserialize the dictionary and print it out
with open("student_dict.pkl", "rb") as f:
    deserialized_dict = pickle.load(f)
    print(deserialized_dict)

Je zou de volgende output moeten krijgen:

{'Student 1': {'Name': 'Alice', 'Age': 10, 'Grade': 4}, 'Student 2': {'Name': 'Bob', 'Age': 11, 'Grade': 5}, 'Student 3': {'Name': 'Elena', 'Age': 14, 'Grade': 8}}

Laten we nu het type van deze variabele controleren:

type(deserialized_dict)

dict

Laten we wat informatie over de eerste student in deze dictionary ophalen:

print(
    "The first student's name is "
    + deserialized_dict["Student 1"]["Name"]
    + " and she is "
    + (str(deserialized_dict["Student 1"]["Age"]))
    + " years old."
)

The first student's name is Alice and she is 10 years old.

Top! De dictionary heeft al zijn oorspronkelijke eigenschappen behouden en is net zo te benaderen als vóór de serialisatie. Bekijk onze tutorial over Python dictionary comprehension voor meer informatie. 

Machinelearningmodellen serialiseren met Pickle

Het trainen van een machinelearningmodel kost veel tijd: uren, en soms zelfs dagen. Het is simpelweg niet haalbaar om een algoritme telkens vanaf nul te hertrainen wanneer je het opnieuw wilt gebruiken of naar een andere omgeving wilt overzetten.

Wil je leren over best practices bij het bouwen van machinelearningalgoritmen, volg dan onze cursus Designing Machine Learning Workflows in Python.

Met Pickle kun je machinelearningmodellen in hun bestaande staat serialiseren, zodat je ze later opnieuw kunt gebruiken wanneer nodig.

In deze sectie leren we een machinelearningmodel met Pickle te serialiseren.

We genereren eerst wat nepdata en bouwen een lineair regressiemodel met de scikit-learn-bibliotheek:

from sklearn.linear_model import LinearRegression
from sklearn.datasets import make_regression

# generate regression dataset
X, y = make_regression(n_samples=100, n_features=3, noise=0.1, random_state=1)

# train regression model
linear_model = LinearRegression()
linear_model.fit(X, y)

Nu printen we enkele samenvattende modelparameters:

# summary of the model
print('Model intercept :', linear_model.intercept_)
print('Model coefficients : ', linear_model.coef_)
print('Model score : ', linear_model.score(X, y))

Model intercept : -0.010109549594702116

Model coefficients :  [44.18793068 98.97389468 58.17121618]

Model score :  0.9999993081899219

We kunnen dit model vervolgens serialiseren met de functie dump() van Pickle:

with open("linear_regression.pkl", "wb") as f:
    pickle.dump(linear_model, f)

Het model is nu opgeslagen als Pickle-bestand. Laten we het deserialiseren met de functie load():

with open("linear_regression.pkl", "rb") as f:
    unpickled_linear_model = pickle.load(f)

Het geserialiseerde model is nu geladen en opgeslagen in de variabele unpickled_linear_model. Laten we de parameters controleren om te bevestigen dat het hetzelfde model is als dat we eerder maakten:

# summary of the model
print('Model intercept :', unpickled_linear_model.intercept_)
print('Model coefficients : ', unpickled_linear_model.coef_)
print('Model score : ', unpickled_linear_model.score(X, y))

Je zou de volgende output moeten krijgen:

Model intercept : -0.010109549594702116

Model coefficients :  [44.18793068 98.97389468 58.17121618]

Model score :  0.9999993081899219

Top! De parameters van het ge-unpickelde model zijn hetzelfde als die van het oorspronkelijke model. 

We kunnen dit model nu gebruiken om voorspellingen te doen op een testdataset, erop door te trainen of het naar een andere omgeving over te zetten.

Python Pickle-prestaties verbeteren voor grote objecten

Pickle is een efficiënt serialisatieformaat dat in verschillende benchmarks vaak sneller blijkt dan JSON, XML en HDF5. 

Bij extreem grote datastructuren of enorme machinelearningmodellen kan Pickle echter aanzienlijk vertragen, en kan serialisatie een bottleneck in je workflow worden.

Hier zijn enkele manieren om de tijd voor het opslaan en laden van Pickle-bestanden te verkorten:

Gebruik het argument PROTOCOL

Het standaardprotocol bij het opslaan en laden van Pickle-bestanden is momenteel 4, wat het meest compatibel is met verschillende Python-versies. 

Wil je je workflow versnellen, gebruik dan het argument HIGHEST_PROTOCOL, het snelste beschikbare protocol van Pickle.

Om het prestatieverschil tussen Pickles meest compatibele protocol en het standaardprotocol te vergelijken, serialiseren we eerst een pandas DataFrame met het standaardprotocol. Dit is de protocolversie die Pickle gebruikt als je niets expliciet opgeeft:

import pickle
import time
import numpy as np

# Set random seed
np.random.seed(100)

data = {'Column1': np.random.randint(0, 10, size=100000),
        'Column2': np.random.choice(['A', 'B', 'C'], size=100000),
        'Column3': np.random.rand(100000)}

# serialize to a file

start = time.time()

with open("df1.pkl", "wb") as f:
    pickle.dump(data, f)

end = time.time()
print(end - start)

0.006001710891723633

Het kostte ongeveer 6 milliseconden om het DataFrame te serialiseren met het standaardprotocol van Pickle.

Nu pickelen we het DataFrame met het hoogste protocol:

start = time.time()

with open("df2.pkl", "wb") as f:
    pickle.dump(data, f, protocol=pickle.HIGHEST_PROTOCOL)

end = time.time()
print(end - start)

0.0030384063720703125

Met het hoogste protocol konden we het DataFrame in de helft van de tijd serialiseren.

Gebruik cPickle in plaats van Pickle

De module cPickle is een snellere versie van Pickle, geschreven in C. Daardoor is hij sneller dan de pure Python-implementatie van Pickle. 

Let op: in Python 3 is cPickle hernoemd naar _pickle, de bibliotheek die we zullen importeren.

import _pickle as cPickle

start = time.time()

with open("df3.pkl", "wb") as f:
    cPickle.dump(data, f)

end = time.time()

print(end-start)

0.004027366638183594

Serialisatie met cPickle duurde circa 4 milliseconden, wat een flinke verbetering is ten opzichte van de Pickle-module.

Serialiseer alleen wat je nodig hebt

Zelfs met workarounds om serialisatie te versnellen, kan het proces nog steeds traag zijn voor grote objecten.

Om de prestaties te verbeteren, kun je de datastructuur opsplitsen en alleen de noodzakelijke subsets serialiseren.

Werk je bijvoorbeeld met dictionaries, specificeer dan de key-valueparen die je opnieuw wilt benaderen. Verklein de dictionary voordat je deze serialiseert: dit vermindert de complexiteit en versnelt het proces aanzienlijk.

Serialisatie met Pickle in Python: volgende stappen

Gefeliciteerd! Je hebt een breed scala aan onderwerpen geleerd over serialisatie in Python en het gebruik van de Pickle-bibliotheek.

Je zou nu een goed begrip moeten hebben van wat serialisatie is, hoe je Pickle gebruikt om Python-datastructuren te serialiseren, en hoe je de prestaties van Pickle optimaliseert met verschillende argumenten en modules.

Hier zijn enkele stappen die je kunt nemen om je begrip van serialisatie te verdiepen en het in te zetten om je data science-workflows te verbeteren:

1. Leer over nieuwe serialisatieformaten. Hoewel we in deze tutorial alleen de Pickle-module hebben behandeld, is dit niet per se het beste formaat voor elke situatie. Het is de moeite waard om andere formaten zoals JSON, XML en HDF5 te leren kennen, zodat je weet welk formaat je wanneer kiest.
2. Ga zelf aan de slag. Pas de concepten uit deze tutorial toe in je data science-workflows. De volgende keer dat je een nieuwe datastructuur maakt of de output van een berekening in een variabele opslaat, serialiseer die dan voor later gebruik in plaats van je code telkens opnieuw uit te voeren.
3. Volg een online cursus. Om je data science-workflows te optimaliseren en taken zoals serialisatie efficiënt uit te voeren, is een sterk begrip van Python-datastructuren en objecten essentieel. Volg hiervoor onze cursus Data Types for Data Science in Python.