ArrayRecord

class ArrayRecord

class ArrayRecord(array_dict: dict[str, Array], *, keep_input: bool = True)

class ArrayRecord(numpy_ndarrays: list[ndarray[tuple[Any, ...], dtype[Any]]], *, keep_input: bool = True)

class ArrayRecord(torch_state_dict: dict[str, torch.Tensor] | dict[str, Any], *, keep_input: bool = True)

Bases : TypedDict[str, Array], InflatableObject

Enregistrement d’array.

Un dictionnaire typé (str à Array) qui peut stocker des tableaux nommés, y compris les paramètres de modèle, les gradients, les embeddings ou les tableaux non-paramétriques. Intérieurement, cela se comporte de manière similaire à un dict[str, Array]. Un ArrayRecord peut être vu comme équivalent à PyTorch’s state_dict, mais il contient des tableaux sous forme sérialisée.

Cet objet est l’un des types d’enregistrements pris en charge par RecordDict et peut donc être stocké dans le content d’un Message ou dans le state d’un Context.

Cette classe peut être instanciée de plusieurs manières :

1. En fournissant rien (conteneur vide).

2. En fournissant un dictionnaire de clés Array (via l’argument array_dict).

3. En fournissant une liste de matrices NumPy ndarray (via l’argument numpy_ndarrays).

4. En fournissant un objet PyTorch state_dict (via l’argument torch_state_dict).

Paramètres:

• array_dict (Optional[dict[str, Array]] (default: None)) – Un dictionnaire existant contenant des instances nommées Array. Si fourni, ces entrées seront utilisées directement pour peupler le record.

• numpy_ndarrays (Optional[list[NDArray]] (default: None)) – Une liste de tableaux NumPy. Chaque tableau sera automatiquement converti en un Array et stocké dans ce record avec des clés générées.

• torch_state_dict (Optional[dict[str, torch.Tensor]] (default: None)) – Un state_dict PyTorch (clés str vers valeurs torch.Tensor). Chaque tenseur sera converti en Array et stocké dans cet enregistrement.

• keep_input (bool (default: True)) – Si False, les entrées du input sont supprimées après avoir été ajoutées à ce record pour libérer de la mémoire. Si True, l’input reste inchangé. Quoi qu’il en soit, aucune mémoire dupliquée n’est utilisée si l’input est un dictionnaire de Array, c’est-à-dire array_dict.

Exemples

Initialiser un ArrayRecord vide:

record = ArrayRecord()

Initialiser avec un dictionnaire de Array:

arr = Array("float32", [5, 5], "numpy.ndarray", b"serialized_data...")
record = ArrayRecord({"weight": arr})

Initialiser avec une liste de tableaux NumPy:

import numpy as np
arr1 = np.random.randn(3, 3)
arr2 = np.random.randn(2, 2)
record = ArrayRecord([arr1, arr2])

Initialiser avec l’état_dict d’un modèle PyTorch:

import torch.nn as nn
model = nn.Linear(10, 5)
record = ArrayRecord(model.state_dict())

Initialiser avec les poids d’un modèle TensorFlow (une liste de tableaux NumPy):

import tensorflow as tf
model = tf.keras.Sequential([tf.keras.layers.Dense(5, input_shape=(10,))])
record = ArrayRecord(model.get_weights())

Methods

clear()
copy()	Retourner une copie superficielle du dictionnaire.
count_bytes()	Retourner le nombre de Bytes stockés dans cet objet.
deflate()	Défléter l'ArrayRecord.
from_array_dict(array_dict, *[, keep_input])	Créer un ArrayRecord à partir d'un dictionnaire de Array.
from_numpy_ndarrays(ndarrays, *[, keep_input])	Créez ArrayRecord à partir d'une liste de NumPy ndarray.
from_torch_state_dict(state_dict, *[, ...])	Créez ArrayRecord à partir de PyTorch state_dict.
get(k[,d])
inflate(object_content[, children])	Infléitez un ArrayRecord à partir de bytes.
items()
keys()
pop(k[,d])	Si la clé n'est pas trouvée, d est retourné si donné, sinon KeyError est levé.
popitem()	Comme une 2-tuple ; mais levez KeyError si D est vide.
setdefault(k[,d])
to_numpy_ndarrays(*[, keep_input])	Retournez l'ArrayRecord sous forme de liste de NumPy ndarray.
to_torch_state_dict(*[, keep_input])	Retournez l'ArrayRecord sous forme de PyTorch state_dict.
update([E, ]**F)	Si E est présent et a une méthode .keys(), faites : pour k dans E: D[k] = E[k] Si E est présent mais manque de la méthode .keys(), faites : pour (k, v) dans E: D[k] = v Dans les deux cas, ceci est suivi de : pour k, v dans F.items(): D[k] = v
values()

Attributes

children	Retournez un dictionnaire des Arrays avec leurs IDs d'objet comme clés.
is_dirty	Vérifier si l'objet est sale après la dernière déflation.
object_id	Obtenir l'ID d'objet.

property children: dict[str, InflatableObject]

Retournez un dictionnaire des Arrays avec leurs IDs d’objet comme clés.

clear() → None.  Remove all items from D.

copy() → Self

Retourner une copie superficielle du dictionnaire.

count_bytes() → int

Retourner le nombre de Bytes stockés dans cet objet.

Notez que une petite quantité de Bytes peut également être incluse dans ce comptage qui correspond à la métadonnée du objet sérialisé (par exemple, d’un tableau NumPy) nécessaire pour désérialiser.

deflate() → bytes

Défléter l’ArrayRecord.

classmethod from_array_dict(array_dict: dict[str, Array], *, keep_input: bool = True) → ArrayRecord

Créer un ArrayRecord à partir d’un dictionnaire de Array.

classmethod from_numpy_ndarrays(ndarrays: list[ndarray[tuple[Any, ...], dtype[Any]]], *, keep_input: bool = True) → ArrayRecord

Créez ArrayRecord à partir d’une liste de NumPy ndarray.

classmethod from_torch_state_dict(state_dict: dict[str, torch.Tensor], *, keep_input: bool = True) → ArrayRecord

Créez ArrayRecord à partir de PyTorch state_dict.

get(k[, d]) → D[k] if k in D, else d.  d defaults to None.

classmethod inflate(object_content: bytes, children: dict[str, InflatableObject] | None = None) → ArrayRecord

Infléitez un ArrayRecord à partir de bytes.

Paramètres:

• object_content (bytes) – Le contenu déflété de l’ArrayRecord.

• children (Optional[dict[str, InflatableObject]] (default: None)) – Dictionnaire des objets Inflatable enfants mappés à leurs IDs d’objet. Ces enfants permettent l’inflation complète de l’ArrayRecord.

Renvoie:

L’ArrayRecord gonflé.

Type renvoyé:

ArrayRecord

property is_dirty: bool

Vérifier si l’objet est sale après la dernière déflation.

items() → a set-like object providing a view on D's items.

keys() → a set-like object providing a view on D's keys.

property object_id: str

Obtenir l’ID d’objet.

pop(k[, d]) → v, remove specified key and return the corresponding value.

Si la clé n’est pas trouvée, d est retourné si donné, sinon KeyError est levé.

popitem() → (k, v), remove and return some (key, value) pair

Comme une 2-tuple ; mais levez KeyError si D est vide.

setdefault(k[, d]) → D.get(k,d), also set D[k]=d if k not in D

to_numpy_ndarrays(*, keep_input: bool = True) → list[ndarray[tuple[Any, ...], dtype[Any]]]

Retournez l’ArrayRecord sous forme de liste de NumPy ndarray.

to_torch_state_dict(*, keep_input: bool = True) → OrderedDict[str, torch.Tensor]

Retournez l’ArrayRecord sous forme de PyTorch state_dict.

update([E, ]**F) → None.  Update D from mapping/iterable E and F.

Si E est présent et a une méthode .keys(), faites : pour k dans E: D[k] = E[k] Si E est présent mais manque de la méthode .keys(), faites : pour (k, v) dans E: D[k] = v Dans les deux cas, ceci est suivi de : pour k, v dans F.items(): D[k] = v

values() → an object providing a view on D's values.