[PYTHON] Pytorch super Einführung

Ich habe anhand des offiziellen Dokuments gesucht. Die Syntax ist der von Chayer sehr ähnlich, beachten Sie jedoch, dass einige Funktionen geringfügig voneinander abweichen.

Ein Deep-Learning-Framework für Bilder unter der Leitung von Facebook und der University of New York. Es scheint, dass es vom Kettenhändler gegabelt wurde. Das Bild von torch7 wird auch von Facebook und der New York University geführt.

Da torch7 lua ist und nicht viel abstrahiert, wird die Funktion freigelegt. Pytorch ist ziemlich abstrakt und reduziert den Codierungsaufwand.

Entwickler ab März 2017

Committer's Blog

Adam Paszke http://apaszke.github.io/posts.html Soumith Chintala http://soumith.ch/

Aufregung

Stand März 2017. Ich weiß nicht, ob die Aufregung mit dem Git-Diagramm gemessen werden kann, aber ich war neugierig und habe es verglichen. chainer pytorch keras tensorflow torch7 caffe caffe2 theano deeplearning4j

cntk

Wie erwartet wurden caffe und torch7 nicht sehr aktualisiert. Überraschenderweise cntk ...

2018/6 Im Forum wurde festgestellt, dass cntk, tensorflow, theano und mxnet größtenteils in Keras verpackt waren, aber pytorch ist ein Framework auf hoher Ebene, daher gibt es eine hohe Theorie, dass es nicht verpackt wird. Ich war überrascht, als der Autor von keras schrieb: "Möchten Sie cntk mit keras umhüllen?" In der Ausgabe von cntk fand die cntk-Person einen "Gefällt mir" -Kommentar.

Häufigkeit der Funktionsnutzung

Die Anzahl der Treffer bei der Git-Suche in verschiedenen APIs. Für Ihre Information.

Installation

conda wird empfohlen. Ich versuche, Pip und Numpy auf dem neuesten Stand zu halten. offiziell http://pytorch.org/

conda install pytorch torchvision -c soumith

win

conda install -c peterjc123 pytorch

Über Pytorch

Bei Bedarf können Sie PyTorch erweitern, indem Sie Python-Pakete wie numpy, scipy und Cython wiederverwenden.

Häufig verwendete Funktionen

PyTorch verwendet hier häufig die Funktionen. Ich werde es später erklären.

require_grad: Sie können angeben, ob der Gradient berechnet werden soll. rückwärts: Sie können den Gradienten berechnen. nn.Module: Erbt dies, um eine Netzwerkklasse zu definieren. DataSet und DataLoader: Dient zum stapelweisen Laden von Daten. Datasets.ImageFolder: Bilder können einfach geladen werden, indem sie für jeden Ordner separat angeordnet werden. Danach können Sie es in DataLoader ablegen und für jeden Stapel separat verarbeiten. Transformationen: Bilddaten können vorverarbeitet werden. make_grid: Wenn das Bild angezeigt wird, wird es nebeneinander im Raster angezeigt.

GPU-fähige Tensorbibliothek

Wenn Sie Numpy verwenden, verwenden Sie Tensoren.

PyTorch bietet Tensoren, die sich entweder auf der CPU oder der GPU befinden, und beschleunigt so den Rechenaufwand. Wir bieten eine Vielzahl von Tensorroutinen an, um Ihre wissenschaftlichen Computeranforderungen zu beschleunigen und anzupassen, einschließlich Schneiden, Indizieren, mathematischer Operationen, linearer Algebra und Reduktion.

Dynamisches neuronales Netzwerk: Bandbasierte automatische Differenzierung

PyTorch bietet eine einzigartige Möglichkeit, ein neuronales Netzwerk aufzubauen, das mit einem Kassettenrekorder wiedergegeben wird.

Die meisten Frameworks wie TensorFlow, Theano, Caffe, CNTK usw. Ich betrachte die Welt statisch. Sie müssen ein neuronales Netzwerk aufbauen und dieselbe Struktur immer wieder verwenden. Wenn Sie das Verhalten eines Netzwerks ändern, müssen Sie von vorne beginnen.

Mit PyTorch können Sie das Verhalten Ihres Netzwerks beliebig und ohne Verzögerung und Overhead mithilfe einer Technik ändern, die als automatische Differenzierung im umgekehrten Modus bezeichnet wird. Unsere Inspiration stammt aus mehreren Forschungsarbeiten zu diesem Thema sowie aus aktuellen und früheren Studien wie Autograd, Autograd und Chainer.

Da es vom Kettenhändler gegabelt ist, behauptet es, ein dynamisches Netzwerk zu sein, wie der Kettenhändler behauptet. Bedeutet das, dass Sie das Netzwerk unterwegs ändern können?

mnist Probe

Überprüfe die Version.

python

import torch
print(torch.__version__)

Daten bekommen

train_loader = torch.utils.data.DataLoader(
    datasets.MNIST('../data', train=True, download=True,
                   transform=transforms.Compose([
                       transforms.ToTensor(),
                       transforms.Normalize((0.1307,), (0.3081,))
                   ])),
    batch_size=args.batch_size, shuffle=True, **kwargs)
test_loader = torch.utils.data.DataLoader(
    datasets.MNIST('../data', train=False, transform=transforms.Compose([
                       transforms.ToTensor(),
                       transforms.Normalize((0.1307,), (0.3081,))
                   ])),
    batch_size=args.batch_size, shuffle=True, **kwargs)

Modelldefinition

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
        self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
        self.conv2_drop = nn.Dropout2d()
        self.fc1 = nn.Linear(320, 50)
        self.fc2 = nn.Linear(50, 10)

    def forward(self, x):
        x = F.relu(F.max_pool2d(self.conv1(x), 2))
        x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))
        x = x.view(-1, 320)
        x = F.relu(self.fc1(x))
        x = F.dropout(x, training=self.training)
        x = F.relu(self.fc2(x))
        return F.log_softmax(x)

Modellgenerierung, Einstellung der Optimierungsfunktion

model = Net()
if args.cuda:
    model.cuda()

optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum)

Lernen

def train(epoch):
    model.train()
    for batch_idx, (data, target) in enumerate(train_loader):
        if args.cuda:
            data, target = data.cuda(), target.cuda()
        data, target = Variable(data), Variable(target)
        optimizer.zero_grad()
        output = model(data)
        loss = F.nll_loss(output, target)
        loss.backward()
        optimizer.step()
        if batch_idx % args.log_interval == 0:
            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                epoch, batch_idx * len(data), len(train_loader.dataset),
                100. * batch_idx / len(train_loader), loss.data[0]))

Ausführung des Lernens

for epoch in range(1, args.epochs + 1):
    train(epoch)
    test(epoch)

Es ist nur ein Kettenhändler, und es fallen keine Studienkosten an.

Erste Schritte mit PyTorch

https://github.com/pytorch/tutorials/blob/master/Introduction%20to%20PyTorch%20for%20former%20Torchies.ipynb

Tensor

import torch
a = torch.FloatTensor(10, 20)
# creates tensor of size (10 x 20) with uninitialized memory

a = torch.randn(10, 20)
# initializes a tensor randomized with a normal distribution with mean=0, var=1

a.size()

Da torch.Size eigentlich ein Taple ist, unterstützt es den gleichen Vorgang.

In-Place / Out-of-Place

Durch Hinzufügen von _ am Ende wird der Inhalt der ursprünglichen Variablen geändert.

a.fill_(3.5)
# a has now been filled with the value 3.5

b = a.add(4.0)
# a is still filled with 3.5
# new tensor b is returned with values 3.5 + 4.0 = 7.5

Nullindex

b = a[0,3] #1. Reihe und 4. Spalte
b = a[:,3:5] #4. und 5. Spalte

Anders als der Kamelkoffer.

Nicht alle Funktionen sind camelCase. Beispielsweise ist indexAdd index_add_.

x = torch.ones(5, 5)
print(x)
z = torch.Tensor(5, 2)
z[:,0] = 10
z[:,1] = 100
print(z)
x.index_add_(1, torch.LongTensor([4,0]), z)
print(x)

numpy Brücke

Umwandlung vom Brennertensor in ein numpy Array

a = torch.ones(5)
b = a.numpy()
a.add_(1)
print(a)
print(b)

Konvertieren Sie das Numpy-Array in einen Fackeltensor

import numpy as np
a = np.ones(5)
b = torch.from_numpy(a)
np.add(a, 1, out=a)
print(a)
print(b)

CUDA-Tensor

# let us run this cell only if CUDA is available
if torch.cuda.is_available():
    # creates a LongTensor and transfers it 
    # to GPU as torch.cuda.LongTensor
    a = torch.LongTensor(10).fill_(3).cuda()
    print(type(a))
    b = a.cpu()
    # transfers it to CPU, back to 
    # being a torch.LongTensor

Autograd Autograd führt die Variable-Klasse ein. Dies ist ein Tensor-Wrapper.

from torch.autograd import Variable
x = Variable(torch.ones(2, 2), requires_grad = True)
x.data
x.grad
y = x + 2
z = y * y * 3
out = z.mean()
out.backward()

nn Paket

import torch.nn as nn

Der Status wird nicht im Modul, sondern im Netzwerkdiagramm gespeichert

Beispiel 1: ConvNet

Klasse erstellen

import torch.nn.functional as F

class MNISTConvNet(nn.Module):
    def __init__(self):
        super(MNISTConvNet, self).__init__()
        self.conv1 = nn.Conv2d(1, 10, 5)
        self.pool1 = nn.MaxPool2d(2,2)
        self.conv2 = nn.Conv2d(10, 20, 5)
        self.pool2 = nn.MaxPool2d(2, 2)
        self.fc1   = nn.Linear(320, 50)
        self.fc2   = nn.Linear(50, 10)
    def forward(self, input):
        x = self.pool1(F.relu(self.conv1(input)))
        x = self.pool2(F.relu(self.conv2(x)))
        x = x.view(x.size(0), -1)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        return x

Erstellen Sie eine Instanz der Klasse

net = MNISTConvNet()
print(net)

• Das gesamte torch.nn-Paket ist eine Mini-Charge von Samples und unterstützt nur Eingaben, die kein einzelnes Sample sind. Zum Beispiel nimmt nn.Conv2d einen 4D-Tensor von nSamples x nChannels x Height x Width. Wenn Sie ein Beispiel haben, verwenden Sie input.unsqueeze (0), um eine gefälschte Batch-Dimension hinzuzufügen.

input = Variable(torch.randn(1, 1, 28, 28))
out = net(input)
print(out.size())

# define a dummy target label
target = Variable(torch.LongTensor([3]))

# create a loss function
loss_fn = nn.CrossEntropyLoss() # LogSoftmax + ClassNLL Loss
err = loss_fn(out, target)
print(err)
err.backward()

Die Ausgabe von ConvNet ist eine Variable. Die Verwendung zur Berechnung des Verlusts führt zu Fehlern, die ebenfalls eine Variable sind. Umgekehrt überträgt der Aufruf von err die Abstufung des gesamten ConvNet auf die Gewichte.

Greifen Sie auf die Gewichte und Verläufe einzelner Ebenen zu.

print(net.conv1.weight.grad.size())
print(net.conv1.weight.data.norm()) # norm of the weight
print(net.conv1.weight.grad.data.norm()) # norm of the gradients

Vorwärts- und Rückwärtshaken

Wir haben die Gewichte und Steigungen untersucht. Aber was ist mit dem Überprüfen / Ändern der Ebenenausgabe und der grad_output? Einführung von Haken zu diesem Zweck.

Sie können Funktionen in Modulen oder Variablen registrieren. Der Haken kann ein vorderer oder ein hinterer Haken sein. Forward-Hooks werden ausgeführt, wenn ein Forward-Anruf getätigt wird. Der hintere Haken läuft in der hinteren Phase. Schauen wir uns ein Beispiel an.

# We register a forward hook on conv2 and print some information
def printnorm(self, input, output):
    # input is a tuple of packed inputs
    # output is a Variable. output.data is the Tensor we are interested
    print('Inside ' + self.__class__.__name__ + ' forward')
    print('')
    print('input: ', type(input))
    print('input[0]: ', type(input[0]))
    print('output: ', type(output))
    print('')
    print('input size:', input[0].size())
    print('output size:', output.data.size())
    print('output norm:', output.data.norm())

net.conv2.register_forward_hook(printnorm)

out = net(input)

# We register a backward hook on conv2 and print some information
def printgradnorm(self, grad_input, grad_output):
    print('Inside ' + self.__class__.__name__ + ' backward')    
    print('Inside class:' + self.__class__.__name__)
    print('')    
    print('grad_input: ', type(grad_input))
    print('grad_input[0]: ', type(grad_input[0]))
    print('grad_output: ', type(grad_output))
    print('grad_output[0]: ', type(grad_output[0]))
    print('')    
    print('grad_input size:', grad_input[0].size())
    print('grad_output size:', grad_output[0].size())
    print('grad_input norm:', grad_input[0].data.norm())

net.conv2.register_backward_hook(printgradnorm)

out = net(input)
err = loss_fn(out, target)
err.backward()

Beispiel 2: Wiederkehrendes Netz

Als nächstes wollen wir sehen, wie man mit PyTorch ein rekursives Netz erstellt. Der Status des Netzwerks wird in Ebenen und nicht in Diagrammen gespeichert. Sie können also einfach nn.Linear erstellen und es immer wieder für Wiederholungen verwenden.

class RNN(nn.Module):

    # you can also accept arguments in your model constructor
    def __init__(self, data_size, hidden_size, output_size):
        super(RNN, self).__init__()
        
        self.hidden_size = hidden_size
        input_size = data_size + hidden_size
        
        self.i2h = nn.Linear(input_size, hidden_size)
        self.h2o = nn.Linear(hidden_size, output_size)
    
    def forward(self, data, last_hidden):
        input = torch.cat((data, last_hidden), 1)
        hidden = self.i2h(input)
        output = self.h2o(hidden)
        return hidden, output

rnn = RNN(50, 20, 10)

loss_fn = nn.MSELoss()

batch_size = 10
TIMESTEPS = 5

# Create some fake data
batch = Variable(torch.randn(batch_size, 50))
hidden = Variable(torch.zeros(batch_size, 20))
target = Variable(torch.zeros(batch_size, 10))

loss = 0
for t in range(TIMESTEPS):                  
    # yes! you can reuse the same network several times,
    # sum up the losses, and call backward!
    hidden, output = rnn(batch, hidden)
    loss += loss_fn(output, target)
loss.backward()

Standardmäßig verfügt PyTorch über eine nahtlose CuDNN-Integration für ConvNets und wiederkehrende Netze.

Multi-GPU-Beispiel

Datenparallelverarbeitung ist, wenn Sie einen Beispiel-Mini-Batch in mehrere kleinere Mini-Batches aufteilen und die Berechnungen für jeden Mini-Batch parallel durchführen. Die Datenparallelverarbeitung wird mit torch.nn.DataParallel implementiert. Sie können das Modul in eine DataParallel einbinden und auf mehreren GPUs in einer Batch-Dimension parallelisieren.

Daten parallel

class DataParallelModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.block1=nn.Linear(10, 20)
        
        # wrap block2 in DataParallel
        self.block2=nn.Linear(20, 20)
        self.block2 = nn.DataParallel(self.block2)
        
        self.block3=nn.Linear(20, 20)
        
    def forward(self, x):
        x = self.block1(x)
        x = self.block2(x)
        x = self.block3(x)
        return x

Im CPU-Modus muss der Code nicht geändert werden.

Grundelemente, die Datenparallelität implementieren

Im Allgemeinen kann das nn.parallele Grundelement von pytorch unabhängig verwendet werden. Implementierte ein einfaches MPI-ähnliches Grundelement. replizieren: Replizieren Sie ein Modul auf mehrere Geräte Streuung: Verteilen Sie die Eingabe auf die erste Dimension sammeln: Sammeln und verketten Sie Eingaben in der ersten Dimension parallel_apply: Wendet einen bereits verteilten Satz von Eingaben auf einen bereits verteilten Satz von Modellen an.

Zur besseren Übersicht ist hier die Funktion data_parallel, die unter Verwendung dieser Mengen konstruiert wurde.

def data_parallel(module, input, device_ids, output_device=None):
    if not device_ids:
        return module(input)

    if output_device is None:
        output_device = device_ids[0]

    replicas = nn.parallel.replicate(module, device_ids)
    inputs = nn.parallel.scatter(input, device_ids)
    replicas = replicas[:len(inputs)]
    outputs = nn.parallel.parallel_apply(replicas, inputs)
    return nn.parallel.gather(outputs, output_device)

Ein Teil des Modells auf der CPU und ein Teil auf der GPU

Schauen wir uns ein kleines Beispiel für die Implementierung eines Netzwerks an, von dem sich einige auf der CPU und der GPU befinden.

class DistributedModel(nn.Module):
    def __init__(self):
        super().__init__(
            embedding=nn.Embedding(1000, 10),
            rnn=nn.Linear(10, 10).cuda(0),
        )
        
    def forward(self, x):
        # Compute embedding on CPU
        x = self.embedding(x)
        
        # Transfer to GPU
        x = x.cuda(0)
        
        # Compute RNN on GPU
        x = self.rnn(x)
        return x

Pytorch Beispiel

Es gibt Beispielcode wie ein Bilderzeugungssystem. Ich meine, es gab überhaupt mehr. Es gab so viele, dass ich hier nicht schreiben musste. Wenn Sie es verwenden möchten, suchen Sie bitte mit git. Die Welt war weit.

pix2pix https://github.com/mrzhu-cool/pix2pix-pytorch densenet https://github.com/bamos/densenet.pytorch animeGAN https://github.com/jayleicn/animeGAN yolo2 https://github.com/longcw/yolo2-pytorch gan https://github.com/devnag/pytorch-generative-adversarial-networks Liste der generierten Modelle https://github.com/wiseodd/generative-models functional model https://github.com/szagoruyko/functional-zoo Einfache Beispielliste https://github.com/pytorch/examples/

Deep Learning Tutorial in PyTorch

https://github.com/pytorch/tutorials/blob/master/Deep%20Learning%20with%20PyTorch.ipynb

Machen Sie die Taschenlampen- und Fackelvisionspakete installiert.

conda install torchvision -c soumith
or
pip install torchvision

beginnen

Tensor

Tensole ähneln Numpys Ndarray, Tensoren können jedoch auch auf GPUs verwendet werden.

from __future__ import print_function
import torch
x = torch.Tensor(5, 3)  # construct a 5x3 matrix, uninitialized
x = torch.rand(5, 3)  # construct a randomly initialized matrix
x.size()
y = torch.rand(5, 3)
# addition: syntax 1
x + y

Numpy Brücke

Umwandlung vom Fackeltensor in ein Numpy-Array

a = torch.ones(5)
b = a.numpy()
a.add_(1)
print(a)
print(b) # see how the numpy array changed in value

Konvertieren Sie das Numpy-Array in einen Fackeltensor

import numpy as np
a = np.ones(5)
b = torch.from_numpy(a)
np.add(a, 1, out=a)
print(a)
print(b) # see how changing the np array changed the torch Tensor automatically

~ Schreiben ~

Fackel.Tensor Klasse

torch7 Lernbeispiel für Mnist https://github.com/torch/demos/blob/master/train-a-digit-classifier/train-on-mnist.lua

Modelldefinition

-- define model to train
model = nn.Sequential()
model:add(nn.Reshape(1024))
model:add(nn.Linear(1024,#classes))
model:add(nn.LogSoftMax())

Datenerfassung. Generieren Sie ein Modell.

criterion = nn.ClassNLLCriterion()
trainData = mnist.loadTrainSet(nbTrainingPatches, geometry)
trainData:normalizeGlobal(mean, std)

Lernen definieren

-- training function
function train(dataset)
   -- epoch tracker
   epoch = epoch or 1

~ Abkürzung ~

         gradParameters:zero()

         -- evaluate function for complete mini batch
         local outputs = model:forward(inputs)
         local f = criterion:forward(outputs, targets)

         -- estimate df/dW
         local df_do = criterion:backward(outputs, targets)
         model:backward(inputs, df_do)

~ Abkürzung ~
   end

Führen Sie das Lernen durch

while true do
   -- train/test
   train(trainData)
~ Abkürzung ~

end

torchnet https://github.com/torchnet/torchnet/blob/master/example/mnist.lua

mnist.lua

-- load torchnet:
local tnt = require 'torchnet'

-- use GPU or not:
~ Abkürzung ~

-- function that sets of dataset iterator:
local function getIterator(mode)
~ Abkürzung ~
end

-- set up logistic regressor:
local net = nn.Sequential():add(nn.Linear(784,10))
local criterion = nn.CrossEntropyCriterion()

-- set up training engine:
local engine = tnt.SGDEngine()
~ Abkürzung ~
end

-- set up GPU training:
~ Abkürzung ~

-- train the model:
engine:train{
   network   = net,
   iterator  = getIterator('train'),
   criterion = criterion,
   lr        = 0.2,
   maxepoch  = 5,
}

-- measure test loss and error:
~ Abkürzung ~
print(string.format('test loss: %2.4f; test error: %2.4f',
   meter:value(), clerr:value{k = 1}))

Transferlernen (Feinabstimmung)

Ich fragte mich, was ich tun sollte, wenn ich das Lernen mit Fackel oder Pytorch übertragen wollte. Ich möchte es eines Tages versuchen.

Vom Kaffeemodell zum Kettenmodell

http://toxweblog.toxbe.com/2016/12/22/chainer-alexnet-fine-tuning/

Umwandlung

#Pfad zum Speichern des Kaffeemodells zum Laden und der pkl-Datei
loadpath = "bvlc_alexnet.caffemodel"
savepath = "./chainermodels/alexnet.pkl"
 
from chainer.links.caffe import CaffeFunction
alexnet = CaffeFunction(loadpath)
 
import _pickle as pickle
pickle.dump(alexnet, open(savepath, 'wb'))

Lesen

if ext == ".caffemodel":
    print('Loading Caffe model file %s...' % args.model, file=sys.stderr)
    func = caffe.CaffeFunction(args.model)
    print('Loaded', file=sys.stderr)
elif ext == ".pkl":
    print('Loading Caffe model file %s...' % args.model, file=sys.stderr)
    func = pickle.load(open(args.model, 'rb'))
    print('Loaded', file=sys.stderr)
def predict(x):
        y, = func(inputs={'data': x}, outputs=['fc8'], train=False)
        return F.softmax(y)

Keras zum pkl-Format

Keras Modell speichern

hogehoge_model.save_weights('model.h5', overwrite=True)

Laden des Keras-Modells

hogehoge_model.load_weights('model.h5')

Als pkl speichern

import _pickle as pickle
pickle.dump(hogehoge_model, open('model.pkl', 'wb'))

Lesen Sie pkl

hogehoge_model = pickle.load(open('model.pkl', 'rb'))

Vom Kaffeemodell zum Tensorflow-Format

https://github.com/ethereon/caffe-tensorflow

def convert(def_path, caffemodel_path, data_output_path, code_output_path, phase):
    try:
        transformer = TensorFlowTransformer(def_path, caffemodel_path, phase=phase)
        print_stderr('Converting data...')
        if caffemodel_path is not None:
            data = transformer.transform_data()
            print_stderr('Saving data...')
            with open(data_output_path, 'wb') as data_out:
                np.save(data_out, data)
        if code_output_path:
            print_stderr('Saving source...')
            with open(code_output_path, 'wb') as src_out:
                src_out.write(transformer.transform_source())
        print_stderr('Done.')
    except KaffeError as err:
        fatal_error('Error encountered: {}'.format(err))

Vom Tensorflow zum Fackel7- oder Pytorch-Format

https://github.com/Cadene/tensorflow-model-zoo.torch

python3 inceptionv4/tensorflow_dump.py

th inceptionv4/torch_load.lua
or
python3 inceptionv4/pytorch_load.py

torch-hdf5 https://github.com/deepmind/torch-hdf5 Mit diesem Paket können Sie Torch-Daten in und aus HDF5-Dateien lesen und schreiben. Das Format ist schnell und flexibel und wird von einer Vielzahl anderer Software unterstützt, darunter MATLAB, Python und R.

Wie man sich bewegt https://github.com/deepmind/torch-hdf5/blob/master/doc/usage.md

Für Ubuntu14 und höher

python

sudo apt-get install libhdf5-serial-dev hdf5-tools
git clone https://github.com/deepmind/torch-hdf5
cd torch-hdf5
luarocks make hdf5-0-0.rockspec LIBHDF5_LIBDIR="/usr/lib/x86_64-linux-gnu/"

Ich habe den Code geändert, um den Benchmark ein wenig zu übernehmen, und ihn verschoben.

python

require 'hdf5'

print("Size\t\t", "torch.save\t\t", "hdf5\t")
n = 1
local size = math.pow(2, n)
local data = torch.rand(size)
local t = torch.tic()
torch.save("out.t7", data)
local normalTime = torch.toc(t)
t = torch.tic()
local hdf5file = hdf5.open("out.h5", 'w')
hdf5file["foo"] = data
hdf5file:close()
local hdf5time = torch.toc(t)
print(n, "\t", normalTime,"\t", hdf5time)

Testautomatisierung

Jenkins für Pytorch https://github.com/pytorch/builder

QA

Ich möchte die GPU angeben, die verwendet werden soll, wenn mehrere GPUs vorhanden sind

Versuchen Sie cuda (2) für cuda () oder geben Sie es mit torch.nn.DataParallel an Ich habe verschiedene Dinge getan, aber am Ende habe ich mich darauf festgelegt. Da es sich übrigens um eine GPU-Freigabe handelt, verhält sie sich in anderen Bibliotheken wie Tensorflow gleich. Ein Bild, das die GPU maskiert, weil es ohne Erlaubnis einen anderen GPU-Speicher belegt, z. B. Tensorflow.

CUDA_VISIBLE_DEVICES=2 python main.py

http://www.acceleware.com/blog/cudavisibledevices-masking-gpus http://qiita.com/kikusumk3/items/907565559739376076b9 http://qiita.com/ballforest/items/3f21bcf34cba8f048f1e Wenn es 8gpu oder mehr ist, scheint es nutzlos zu sein, es sei denn, es ist gruppiert. http://qiita.com/YusukeSuzuki@github/items/aa5fcc4b4d06c116c3e8