Download de torchmetrics - Download de código -fonte torchmetrics

torchmetrics

Pitão

Minor patch release

Baixar

Métricas de aprendizado de máquina para aplicativos pytorch distribuídos e escaláveis.

O que é Torchmetrics • Implementando uma métrica • Métricas embutidas • Documentos • Comunidade • Licença

Teste de IC | CPU

Instalação

Instalação simples da Pypi

pip install torchmetrics

Outras instalações

Instale usando o CONDA

conda install -c conda-forge torchmetrics

Pip da fonte

 # with git
pip install git+https://github.com/Lightning-AI/torchmetrics.git@release/stable

Pip do arquivo

pip install https://github.com/Lightning-AI/torchmetrics/archive/refs/heads/release/stable.zip

Dependências extras para métricas especializadas:

pip install torchmetrics[audio]
pip install torchmetrics[image]
pip install torchmetrics[text]
pip install torchmetrics[all]  # install all of the above

Instale a versão mais recente do desenvolvedor

pip install https://github.com/Lightning-AI/torchmetrics/archive/master.zip

O que é Torchmetrics

A Torchmetrics é uma coleção de mais de 100 implementações de métricas de Pytorch e uma API fácil de usar para criar métricas personalizadas. Oferece:

Uma interface padronizada para aumentar a reprodutibilidade
Reduz o caldeira
Acumulação automática sobre lotes
Métricas otimizadas para treinamento distribuído
Sincronização automática entre vários dispositivos

Você pode usar a Torchmetrics com qualquer modelo Pytorch ou com Lightning Pytorch para desfrutar de recursos adicionais, como:

As métricas do módulo são colocadas automaticamente no dispositivo correto.
Suporte nativo para métricas de registro em raios para reduzir ainda mais caldeiras.

Usando Torchmetrics

Métricas de módulo

As métricas baseadas em módulo contêm estados métricos internos (semelhantes aos parâmetros do módulo Pytorch) que automatizam o acúmulo e a sincronização entre os dispositivos!

Acumulação automática em vários lotes
Sincronização automática entre vários dispositivos
Aritmética métrica

Isso pode ser executado na CPU, GPU único ou multi-GPUs!

Para o caso único GPU/CPU:

 import torch

# import our library
import torchmetrics

# initialize metric
metric = torchmetrics . classification . Accuracy ( task = "multiclass" , num_classes = 5 )

# move the metric to device you want computations to take place
device = "cuda" if torch . cuda . is_available () else "cpu"
metric . to ( device )

n_batches = 10
for i in range ( n_batches ):
    # simulate a classification problem
    preds = torch . randn ( 10 , 5 ). softmax ( dim = - 1 ). to ( device )
    target = torch . randint ( 5 , ( 10 ,)). to ( device )

    # metric on current batch
    acc = metric ( preds , target )
    print ( f"Accuracy on batch { i } : { acc } " )

# metric on all batches using custom accumulation
acc = metric . compute ()
print ( f"Accuracy on all data: { acc } " )

O uso métrico do módulo permanece o mesmo ao usar várias GPUs ou vários nós.

Exemplo usando DDP

 import os
import torch
import torch . distributed as dist
import torch . multiprocessing as mp
from torch import nn
from torch . nn . parallel import DistributedDataParallel as DDP
import torchmetrics


def metric_ddp ( rank , world_size ):
    os . environ [ "MASTER_ADDR" ] = "localhost"
    os . environ [ "MASTER_PORT" ] = "12355"

    # create default process group
    dist . init_process_group ( "gloo" , rank = rank , world_size = world_size )

    # initialize model
    metric = torchmetrics . classification . Accuracy ( task = "multiclass" , num_classes = 5 )

    # define a model and append your metric to it
    # this allows metric states to be placed on correct accelerators when
    # .to(device) is called on the model
    model = nn . Linear ( 10 , 10 )
    model . metric = metric
    model = model . to ( rank )

    # initialize DDP
    model = DDP ( model , device_ids = [ rank ])

    n_epochs = 5
    # this shows iteration over multiple training epochs
    for n in range ( n_epochs ):
        # this will be replaced by a DataLoader with a DistributedSampler
        n_batches = 10
        for i in range ( n_batches ):
            # simulate a classification problem
            preds = torch . randn ( 10 , 5 ). softmax ( dim = - 1 )
            target = torch . randint ( 5 , ( 10 ,))

            # metric on current batch
            acc = metric ( preds , target )
            if rank == 0 :  # print only for rank 0
                print ( f"Accuracy on batch { i } : { acc } " )

        # metric on all batches and all accelerators using custom accumulation
        # accuracy is same across both accelerators
        acc = metric . compute ()
        print ( f"Accuracy on all data: { acc } , accelerator rank: { rank } " )

        # Resetting internal state such that metric ready for new data
        metric . reset ()

    # cleanup
    dist . destroy_process_group ()


if __name__ == "__main__" :
    world_size = 2  # number of gpus to parallelize over
    mp . spawn ( metric_ddp , args = ( world_size ,), nprocs = world_size , join = True )

Implementando sua própria métrica de módulo

A implementação de sua própria métrica é tão fácil quanto subclassificar uma torch.nn.Module . Simplesmente, a subclasse torchmetrics.Metric e apenas implemente os métodos de update e compute :

 import torch
from torchmetrics import Metric


class MyAccuracy ( Metric ):
    def __init__ ( self ):
        # remember to call super
        super (). __init__ ()
        # call `self.add_state`for every internal state that is needed for the metrics computations
        # dist_reduce_fx indicates the function that should be used to reduce
        # state from multiple processes
        self . add_state ( "correct" , default = torch . tensor ( 0 ), dist_reduce_fx = "sum" )
        self . add_state ( "total" , default = torch . tensor ( 0 ), dist_reduce_fx = "sum" )

    def update ( self , preds : torch . Tensor , target : torch . Tensor ) -> None :
        # extract predicted class index for computing accuracy
        preds = preds . argmax ( dim = - 1 )
        assert preds . shape == target . shape
        # update metric states
        self . correct += torch . sum ( preds == target )
        self . total += target . numel ()

    def compute ( self ) -> torch . Tensor :
        # compute final result
        return self . correct . float () / self . total


my_metric = MyAccuracy ()
preds = torch . randn ( 10 , 5 ). softmax ( dim = - 1 )
target = torch . randint ( 5 , ( 10 ,))

print ( my_metric ( preds , target ))

Métricas funcionais

Semelhante ao torch.nn , a maioria das métricas possui uma versão funcional baseada em módulo e baseada em módulo. As versões funcionais são funções simples do Python que, como entrada, tomam tocha.

 import torch

# import our library
import torchmetrics

# simulate a classification problem
preds = torch . randn ( 10 , 5 ). softmax ( dim = - 1 )
target = torch . randint ( 5 , ( 10 ,))

acc = torchmetrics . functional . classification . multiclass_accuracy (
    preds , target , num_classes = 5
)

Domínios cobertos e métricas de exemplo

No total, a Torchmetrics contém mais de 100 métricas, que abrange os seguintes domínios:

Áudio
Classificação
Detecção
Recuperação de informações
Imagem
Multimodal (texto da imagem)
Nominal
Regressão
Segmentação
Texto

Cada domínio pode exigir algumas dependências adicionais que podem ser instaladas com pip install torchmetrics[audio] , pip install torchmetrics['image'] etc.

Recursos adicionais

Plotagem

A visualização de métricas pode ser importante para ajudar a entender o que está acontecendo com seus algoritmos de aprendizado de máquina. A Torchmetrics possui suporte de plotagem embutido (instale dependências com pip install torchmetrics[visual] ) para quase todas as métricas modulares através do método .plot . Basta chamar o método para obter uma visualização simples de qualquer métrica!

 import torch
from torchmetrics . classification import MulticlassAccuracy , MulticlassConfusionMatrix

num_classes = 3

# this will generate two distributions that comes more similar as iterations increase
w = torch . randn ( num_classes )
target = lambda it : torch . multinomial (( it * w ). softmax ( dim = - 1 ), 100 , replacement = True )
preds = lambda it : torch . multinomial (( it * w ). softmax ( dim = - 1 ), 100 , replacement = True )

acc = MulticlassAccuracy ( num_classes = num_classes , average = "micro" )
acc_per_class = MulticlassAccuracy ( num_classes = num_classes , average = None )
confmat = MulticlassConfusionMatrix ( num_classes = num_classes )

# plot single value
for i in range ( 5 ):
    acc_per_class . update ( preds ( i ), target ( i ))
    confmat . update ( preds ( i ), target ( i ))
fig1 , ax1 = acc_per_class . plot ()
fig2 , ax2 = confmat . plot ()

# plot multiple values
values = []
for i in range ( 10 ):
    values . append ( acc ( preds ( i ), target ( i )))
fig3 , ax3 = acc . plot ( values )

Para exemplos de plotagem de métricas diferentes, tente executar este arquivo de exemplo.

Contribuir!

A equipe Lightning + Torchmetrics está trabalhando duro para adicionar ainda mais métricas. Mas estamos procurando contribuidores incríveis como você para enviar novas métricas e melhorar as existentes!

Junte -se à nossa discórdia para obter ajuda para se tornar um colaborador!

Comunidade

Para obter ajuda ou perguntas, junte -se à nossa enorme comunidade no Discord!

Citação

Estamos empolgados em continuar o forte legado do software de código aberto e fomos inspirados ao longo dos anos por Caffe, Theano, Keras, Pytorch, Torchbearer, Ignite, Sklearn e Fast.ai.

Se você deseja citar essa estrutura, fique à vontade para usar a opção de citação integrada do Github para gerar uma citação no estilo Bibtex ou APA com base nesse arquivo (mas apenas se você adorou?).