Maîtriser l'optimisation de la mémoire Python : techniques de science des données et d'apprentissage automatique

En tant qu'auteur prolifique, je vous invite à explorer ma collection de livres Amazon. N'oubliez pas de me suivre sur Medium pour les mises à jour et montrez votre soutien ! Vos encouragements sont grandement appréciés !

L'importance croissante de Python dans la science des données et l'apprentissage automatique nécessite une gestion efficace de la mémoire pour les projets à grande échelle. La taille croissante des ensembles de données et les demandes de calcul croissantes rendent cruciale l’optimisation de l’utilisation de la mémoire. Mon expérience avec les applications Python gourmandes en mémoire a donné naissance à plusieurs stratégies d'optimisation efficaces, que je partagerai ici.

Nous commencerons par NumPy, une bibliothèque fondamentale pour le calcul numérique. Les tableaux NumPy offrent des avantages substantiels en matière de mémoire par rapport aux listes Python, en particulier pour les ensembles de données étendus. Leur allocation de mémoire contiguë et leur typage statique minimisent les frais généraux.

Considérez cette comparaison :

import numpy as np
import sys

# Creating a list and a NumPy array with 1 million integers
py_list = list(range(1000000))
np_array = np.arange(1000000)

# Comparing memory usage
print(f"Python list size: {sys.getsizeof(py_list) / 1e6:.2f} MB")
print(f"NumPy array size: {np_array.nbytes / 1e6:.2f} MB")

La plus petite empreinte mémoire de la baie NumPy sera évidente. Cette disparité devient plus prononcée avec des ensembles de données plus volumineux.

NumPy fournit également des opérations économes en mémoire. Au lieu de générer de nouveaux tableaux pour chaque opération, il modifie souvent les tableaux sur place :

# In-place operations
np_array += 1  # Modifies the original array directly

En ce qui concerne Pandas, les types de données catégorielles sont la clé de l'optimisation de la mémoire. Pour les colonnes de chaîne avec des valeurs uniques limitées, la conversion en type catégoriel réduit considérablement la consommation de mémoire :

import pandas as pd

# DataFrame with repeated string values
df = pd.DataFrame({'category': ['A', 'B', 'C'] * 1000000})

# Memory usage check
print(f"Original memory usage: {df.memory_usage(deep=True).sum() / 1e6:.2f} MB")

# Conversion to categorical
df['category'] = pd.Categorical(df['category'])

# Post-conversion memory usage
print(f"Memory usage after conversion: {df.memory_usage(deep=True).sum() / 1e6:.2f} MB")

Les économies de mémoire peuvent être substantielles, en particulier avec de grands ensembles de données contenant des chaînes répétitives.

Pour les ensembles de données clairsemés, Pandas propose des structures de données clairsemées, stockant uniquement des valeurs non nulles, ce qui entraîne des économies de mémoire significatives pour les ensembles de données contenant de nombreuses valeurs nulles ou nulles :

# Creating a sparse series
sparse_series = pd.Series([0, 0, 1, 0, 2, 0, 0, 3], dtype="Sparse[int]")

print(f"Memory usage: {sparse_series.memory_usage(deep=True) / 1e3:.2f} KB")

Lorsque les ensembles de données dépassent la RAM disponible, les fichiers mappés en mémoire sont transformateurs. Ils permettent de travailler avec des fichiers volumineux comme s'ils étaient en mémoire, sans charger l'intégralité du fichier :

import mmap
import os

# Creating a large file
with open('large_file.bin', 'wb') as f:
    f.write(b'0' * 1000000000)  # 1 GB file

# Memory-mapping the file
with open('large_file.bin', 'r+b') as f:
    mmapped_file = mmap.mmap(f.fileno(), 0)

# Reading from the memory-mapped file
print(mmapped_file[1000000:1000010])

# Cleaning up
mmapped_file.close()
os.remove('large_file.bin')

Ceci est particulièrement utile pour un accès aléatoire sur des fichiers volumineux sans les charger complètement en mémoire.

Les expressions génératrices et itertools sont puissantes pour un traitement de données économe en mémoire. Ils permettent de traiter de grands ensembles de données sans tout charger simultanément en mémoire :

import itertools

# Generator expression
sum_squares = sum(x*x for x in range(1000000))

# Using itertools for memory-efficient operations
evens = itertools.islice(itertools.count(0, 2), 1000000)
sum_evens = sum(evens)

print(f"Sum of squares: {sum_squares}")
print(f"Sum of even numbers: {sum_evens}")

Ces techniques minimisent la surcharge de mémoire lors du traitement de grands ensembles de données.

Pour les sections de code critiques en termes de performances, Cython offre un potentiel d'optimisation important. La compilation du code Python en C entraîne des améliorations substantielles de la vitesse et une réduction potentielle de la mémoire :

def sum_squares_cython(int n):
    cdef int i
    cdef long long result = 0
    for i in range(n):
        result += i * i
    return result

# Usage
result = sum_squares_cython(1000000)
print(f"Sum of squares: {result}")

Cette fonction Cython surpassera son homologue Python pur, en particulier pour les grandes n valeurs.

PyPy, un compilateur Just-In-Time, propose des optimisations automatiques de la mémoire. C'est particulièrement bénéfique pour les programmes de longue durée, réduisant souvent considérablement l'utilisation de la mémoire :

import numpy as np
import sys

# Creating a list and a NumPy array with 1 million integers
py_list = list(range(1000000))
np_array = np.arange(1000000)

# Comparing memory usage
print(f"Python list size: {sys.getsizeof(py_list) / 1e6:.2f} MB")
print(f"NumPy array size: {np_array.nbytes / 1e6:.2f} MB")

PyPy peut conduire à une amélioration de l'efficacité et de la vitesse de la mémoire par rapport au CPython standard.

Le profilage de la mémoire est essentiel pour identifier les opportunités d'optimisation. La memory_profiler bibliothèque est un outil précieux :

# In-place operations
np_array += 1  # Modifies the original array directly

Utilisez mprof run script.py et mprof plot pour visualiser l'utilisation de la mémoire.

Résoudre les fuites de mémoire est crucial. Le module tracemalloc (Python 3.4 ) permet d'identifier les sources d'allocation de mémoire :

import pandas as pd

# DataFrame with repeated string values
df = pd.DataFrame({'category': ['A', 'B', 'C'] * 1000000})

# Memory usage check
print(f"Original memory usage: {df.memory_usage(deep=True).sum() / 1e6:.2f} MB")

# Conversion to categorical
df['category'] = pd.Categorical(df['category'])

# Post-conversion memory usage
print(f"Memory usage after conversion: {df.memory_usage(deep=True).sum() / 1e6:.2f} MB")

Cela identifie les sections de code gourmandes en mémoire.

Pour les applications extrêmement gourmandes en mémoire, une gestion personnalisée de la mémoire peut être nécessaire. Cela pourrait impliquer des pools d'objets pour la réutilisation d'objets ou une mise en cache personnalisée :

# Creating a sparse series
sparse_series = pd.Series([0, 0, 1, 0, 2, 0, 0, 3], dtype="Sparse[int]")

print(f"Memory usage: {sparse_series.memory_usage(deep=True) / 1e3:.2f} KB")

Cela minimise les frais de création/destruction d'objets.

Pour des ensembles de données exceptionnellement volumineux, envisagez des bibliothèques de calcul hors cœur comme Dask :

import mmap
import os

# Creating a large file
with open('large_file.bin', 'wb') as f:
    f.write(b'0' * 1000000000)  # 1 GB file

# Memory-mapping the file
with open('large_file.bin', 'r+b') as f:
    mmapped_file = mmap.mmap(f.fileno(), 0)

# Reading from the memory-mapped file
print(mmapped_file[1000000:1000010])

# Cleaning up
mmapped_file.close()
os.remove('large_file.bin')

Dask gère des ensembles de données plus grands que la RAM disponible en divisant les calculs en morceaux plus petits.

L'optimisation des algorithmes est également vitale. Choisir des algorithmes efficaces peut réduire considérablement l'utilisation de la mémoire :

import itertools

# Generator expression
sum_squares = sum(x*x for x in range(1000000))

# Using itertools for memory-efficient operations
evens = itertools.islice(itertools.count(0, 2), 1000000)
sum_evens = sum(evens)

print(f"Sum of squares: {sum_squares}")
print(f"Sum of even numbers: {sum_evens}")

Cette fonction de Fibonacci optimisée utilise une mémoire constante, contrairement à une implémentation récursive naïve.

En résumé, une optimisation efficace de la mémoire Python combine des structures de données efficaces, des bibliothèques spécialisées, un codage efficace en mémoire et des algorithmes appropriés. Ces techniques réduisent l'empreinte mémoire, permettant la gestion d'ensembles de données plus volumineux et des calculs plus complexes. N'oubliez pas de profiler votre code pour identifier les goulots d'étranglement et concentrer les efforts d'optimisation là où ils auront le plus grand impact.

---

101 livres

101 Books, une maison d'édition basée sur l'IA et cofondée par l'auteur Aarav Joshi, exploite l'IA pour minimiser les coûts de publication, rendant ainsi accessible des connaissances de qualité (certains livres coûtent aussi peu que 4 $ !).

Retrouvez notre livre Golang Clean Code sur Amazon.

Pour des mises à jour et plus de titres, recherchez Aarav Joshi sur Amazon. Des remises spéciales sont disponibles via [lien].

Nos Créations

Découvrez nos créations :

Centre des investisseurs | Centre des investisseurs espagnol | Investisseur central allemand | Vie intelligente | Époques & Échos | Mystères déroutants | Hindutva | Développeur Élite | Écoles JS

---

Nous sommes sur Medium

Tech Koala Insights | Epoques & Echos Monde | Support Central des Investisseurs | Mystères déroutants Medium | Sciences & Epoques Medium | Hindutva moderne

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!