PyTorch ¿Cómo cargar un modelo previamente entrenado?

Existen varios enfoques para registrar (serializar) y cargar (deserializar) patrones de inferencia en PyTorch.

Por ejemplo, es posible que deba cargar un modelo que ya está entrenado y una copia de seguridad que proviene de Internet. Más recientemente respondí a esta pregunta en un foro de debate https://discuss.pytorch.org/t/i-want-to-do-machine-learning-with-android/98753. Aprovecho este artículo para dar algunos detalles.

GUARDA Y CARGA DE UN MODO PRE-TRAINED con load_state_dict

En PyTorch puedes guardar un modelo almacenando en su archivo sus state_dict estos son diccionarios Python, se pueden grabar, actualizar, modificar y restaurar fácilmente, añadiendo una gran modularidad a los modelos y optimizadores de PyTorch.

En mi ejemplo:

ESPNet está respaldado con este método

https://github.com/sacmehta/ESPNet/tree/master/pretrained/encoder

Me las arreglé para cargar el modelo de codificador utilizando la clase ESPNet que hace un load_state_dict

antorcha de importación
modelo - ESPNet(20,encoderFile"espnet_p_2_q_8.pth", p-2, q-8)
ejemplo - torch.rand (1, 3, 224, 224)
traced_script_module - torch.jit.trace (modelo, ejemplo)
traced_script_module.save ("model.pt")

La salida es

¡Codifica cargado!

Tenga en cuenta que ESPNet utiliza la GPU predeterminada y que se requería una adaptación en Model.py en https://github.com/sacmehta/ESPNet/tree/master/train reemplazando:

self.encoder.load_state_dict (torch.load (encoderFile)

Por:

self.encoder.load_state_dict (torch.load (encoderFile,map_location'cpu')

De lo contrario, si no realiza este ajuste no tiene la capacidad de iniciarse en una GPU, obtendrá el siguiente error:

RuntimeError: intentar deserializar un objeto en un dispositivo CUDA, pero torch.cuda.is_available() es False. Si se está ejecutando en una máquina solo para CPU, utilice torch.load con map_location-torch.device ('cpu') para asignar sus almacenamientos a la CPU.
PYTORCH TORCHSCRIPT

COPIA DE SEGURIDAD Y CARGA POR SCRIPT PYTORCH

https://pytorch.org/docs/stable/jit.html

TorchScript es una forma de crear modelos que se pueden crear que se pueden optimizar desde el código PyTorch.

Cualquier programa TorchScript se puede guardar desde un proceso de Python y cargarse en un proceso en el que no haya dependencia de Python.

El código siguiente le permite guardar el modelo ESPNet previamente entrenado que fue respaldado por el método clásico torch.save mediante el uso de TorchScript.

antorcha de importación

modelo - ESPNet(20,encoderFile"espnet_p_2_q_8.pth", p-2, q-8)
ejemplo - torch.rand (1, 3, 224, 224)
traced_script_module - torch.jit.trace (modelo, ejemplo)
#Exemple con TorchScript
torch.jit.save (traced_script_module, "scriptmodel.pth")

Un ejemplo para el cargador a través de TorchScript a continuación:

antorcha de importación
model - torch.jit.load ("scriptmodel.pth")

RECURSOS SOBRE EL TEMA

https://pytorch.org/docs/stable/jit.html

https://pytorch.org/tutorials/beginner/Intro_to_TorchScript_tutorial.html

https://stackoverflow.com/questions/53900396/what-are-torch-scripts-in-pytorch

BCEWithLogitsLoss en PyTorch ¿cómo encontrar la implementación?

Me han preguntado recientemente sobre cómo encontrar el código BCEWithLogitsLoss (https://discuss.pytorch.org/t/implementation-of-binary-cross-entropy/98715/2) para una función llamada en PYTORCH con la función handle_torch_function me lleva algún tiempo entenderlo, y lo compartiré con usted si ayuda:

La pregunta era acerca de BCEWithLogitsLoss – BCELoss + sigmoid() ? Mi respuesta puede ser aplicable si desea analizar el código de todas las funciones que figura en el diccionario ret de https://github.com/pytorch/pytorch/blob/master/torch/overrides.py

BCEWithLogitsLoss es una combinación de BCELOSS + una capa sigmoid i. Esto es más estable numéricamente que el uso de un sigmoid simple seguido de un BCELoss ya que, al combinar las operaciones en una capa, aprovecha el truco log-sum-exp para la estabilidad numérica ver: https://en.wikipedia.org/wiki/LogSumExp

  1. El código de la clase BCEWithLogitsLoss se puede encontrar en https://github.com/pytorch/pytorch/blob/master/torch/nn/modules/loss.py
    def forward(self, input: Tensor, target: Tensor) -> Tensor:
        retorno F.binary_cross_entropy_with_logits (entrada, objetivo,
                                                  self.peso,
                                                  pos_weight-self.pos_weight,
                                                  reducción-auto.reducción)
BCEWithLogitLoss PYTORCH

El Oject F se importa de functionnal.py aquí : https://github.com/pytorch/pytorch/blob/master/torch/nn/functional.py

Encontrará la función llamada

def binary_cross_entropy_with_logits(entrada, destino, peso-Ninguno, size_average-Ninguno,
                                     reducir-Ninguno, reducción 'media', pos_weight-Ninguno):

Llama a la handle_torch_function en https://github.com/pytorch/pytorch/blob/master/torch/overrides.pyYou en
contrará una entrada de la función binary_cross_entropy_with_logits en el ret dictionnary que contiene todas las funciones que se pueden invalidar en pytorch. Esta
es la implementación de Python de torch_functionMore
información en https://github.com/pytorch/pytorch/issues/24015

A continuación, el código al que se llama está
en el Filehttps://github.com/pytorch/pytorch/blob/master/aten/src/ATen/native/Loss.cpp de C++

Tensor binary_cross_entropy_with_logits (const Tensor> entrada, const Tensor&, const Tensor&weight, const Tensor&pos_weight, int64_t 
...
BCEWithLogitLoss PYTORCH

LIENS DE RESSOURCES :

https://pytorch.org/docs/stable/generated/torch.nn.BCEWithLogitsLoss.html

https://discuss.pytorch.org/t/bceloss-vs-bcewithlogitsloss/33586

https://stackoverflow.com/questions/59246416/the-output-of-numerical-calculation-of-bcewithlogitsloss-for-pytorch-example

https://www.semicolonworld.com/question/61244/implementing-bcewithlogitsloss-from-pytorch-in-keras