Implementierung der Installation und Deinstallation von CUDA und CUDNN in Ubuntu

sudo vim /etc/modprobe.d/blacklist.conf

schwarze Liste Jugendstil
Optionen nouveau modeset=0

sudo update-initramfs -u

grep neu

NVIDIA-Linux-x86_64-410.93.run

Strg-Alt+F1

sudo service lightdm stop

sudo apt-get remove --purge nvidia*
sudo chmod +x NVIDIA-Linux-x86_64-410.93.run
sudo ./NVIDIA-Linux-x86_64-410.93.run --uninstall

sudo ./NVIDIA-Linux-x86_64-410.93.run

sudo service lightdm starten

Neustart

sudo /usr/local/cuda-8.0/bin/uninstall_cuda_8.0.pl

sudo rm -rf /usr/local/cuda-8.0/

chmod +x cuda_10.0.130_410.48_linux.run

./cuda_10.0.130_410.48_linux.run

(Stimmen Sie den Bedingungen zu? Sie müssen zustimmen, um mit der Installation fortzufahren.)
akzeptieren/ablehnen/beenden: akzeptieren

(Hier nicht den Treiber installieren, da der neuste Treiber installiert wurde. Andernfalls kann es sein, dass eine alte Version des Grafiktreibers installiert wird, was zu wiederholten Anmeldungen führt)
NVIDIA Accelerated Graphics-Treiber für Linux-x86_64 410.48 installieren?
(j)a/(n)ein/(n)ein: n

Das CUDA 10.0 Toolkit installieren? (Möchten Sie CUDA 10 installieren? Dies muss installiert sein.)
(j)es/(n)ein/(q)it: j

Geben Sie den Toolkit-Speicherort ein (Installationspfad, verwenden Sie den Standardpfad, drücken Sie einfach die Eingabetaste).
 [Standard ist /usr/local/cuda-10.0]: 

Möchten Sie einen symbolischen Link unter /usr/local/cuda installieren? (Stimmen Sie der Erstellung eines Softlinks zu)
(j)es/(n)ein/(q)it: j

Die CUDA 10.0-Beispiele installieren? (Der Test muss nicht installiert werden, er ist bereits vorhanden)
(j)a/(n)ein/(n)ein: n

Installieren des CUDA-Toolkits in /usr/local/cuda-10.0 …

exportiere CUDA_HOME=/usr/local/cuda-10.0
exportiere LD_LIBRARY_PATH=${CUDA_HOME}/lib64
export PATH=${CUDA_HOME}/bin:${PATH}

test@test:~$ nvcc -V
nvcc: NVIDIA (R) Cuda-Compilertreiber
Copyright (c) 2005-2018 NVIDIA Corporation
Erstellt am Sat_Aug_25_21:08:01_CDT_2018
Cuda-Kompilierungstools, Version 10.0, V10.0.130

cd /usr/local/cuda-10.0/samples/1_Utilities/deviceQuery
machen
./Geräteabfrage

./deviceQuery wird gestartet …

 CUDA Device Query (Runtime API)-Version (statische Verknüpfung mit CUDART)

1 CUDA-fähiges Gerät erkannt

Gerät 0: „GeForce RTX 2070“
 CUDA-Treiberversion / Runtime-Version 10.0 / 10.0
 CUDA-Funktion Haupt-/Nebenversionsnummer: 7.5
 Gesamtmenge des globalen Speichers: 7950 MBytes (8335982592 Bytes)
 (36) Multiprozessoren, (64) CUDA Cores/MP: 2304 CUDA Cores
 Maximale GPU-Taktrate: 1620 MHz (1,62 GHz)
 Speichertaktrate: 7001 MHz
 Speicherbusbreite: 256 Bit
 L2-Cache-Größe: 4194304 Bytes
 Maximale Texturdimensionsgröße (x,y,z) 1D=(131072), 2D=(131072, 65536), 3D=(16384, 16384, 16384)
 Maximale geschichtete 1D-Texturgröße, (Anzahl) Schichten 1D=(32768), 2048 Schichten
 Maximale geschichtete 2D-Texturgröße, (Anzahl) Schichten 2D=(32768, 32768), 2048 Schichten
 Gesamtmenge des konstanten Speichers: 65536 Bytes
 Gesamtmenge des gemeinsam genutzten Speichers pro Block: 49152 Bytes
 Gesamtzahl der pro Block verfügbaren Register: 65536
 Kettfadengröße: 32
 Maximale Anzahl Threads pro Multiprozessor: 1024
 Maximale Anzahl Threads pro Block: 1024
 Maximale Dimensionsgröße eines Threadblocks (x,y,z): (1024, 1024, 64)
 Maximale Dimensionsgröße einer Rastergröße (x,y,z): (2147483647, 65535, 65535)
 Maximaler Speicherabstand: 2147483647 Bytes
 Texturausrichtung: 512 Bytes
 Gleichzeitiges Kopieren und Kernel-Ausführen: Ja mit 3 Kopier-Engine(s)
 Laufzeitlimit für Kernel: Ja
 Integrierter GPU-Sharing-Hostspeicher: Nein
 Unterstützt seitengesperrtes Host-Speichermapping: Ja
 Ausrichtungsanforderung für Oberflächen: Ja
 Gerät hat ECC-Unterstützung: Deaktiviert
 Gerät unterstützt Unified Addressing (UVA): Ja
 Gerät unterstützt Compute Preemption: Ja
 Unterstützt kooperativen Kernelstart: Ja
 Unterstützt MultiDevice Co-op Kernel Launch: Ja
 Geräte-PCI-Domänen-ID / Bus-ID / Standort-ID: 0 / 1 / 0
 Rechenmodus:
  < Standard (mehrere Host-Threads können ::cudaSetDevice() gleichzeitig mit Gerät verwenden) >

deviceQuery, CUDA-Treiber = CUDART, CUDA-Treiberversion = 10.0, CUDA-Runtime-Version = 10.0, NumDevs = 1
Ergebnis = PASS

cudnn-10.0-linux-x64-v7.4.2.24.tgz

tar -zxvf cudnn-10.0-linux-x64-v7.4.2.24.tgz

cuda/include/cudnn.h
cuda/NVIDIA_SLA_cuDNN_Support.txt
cuda/lib64/libcudnn.so
cuda/lib64/libcudnn.so.7
cuda/lib64/libcudnn.so.7.4.2
cuda/lib64/libcudnn_static.a

cp cuda/lib64/* /usr/local/cuda-10.0/lib64/
cp cuda/include/* /usr/local/cuda-10.0/include/

cat /usr/local/cuda/include/cudnn.h | grep CUDNN_MAJOR -A 2

pip3 installieren https://download.pytorch.org/whl/cu100/torch-1.0.0-cp35-cp35m-linux_x86_64.whl
pip3 installieren torchvision

Taschenlampe importieren
importiere torch.nn als nn
importiere torch.nn.functional als F
importiere torch.optim als optim
importiere torch.backends.cudnn als cudnn
aus Torchvision importierte Datensätze, transformiert


Klasse Net(nn.Modul):
 def __init__(selbst):
  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 vorwärts(selbst, 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=selbsttraining)
  x = selbst.fc2(x)
  gibt F.log_softmax(x, dim=1) zurück


def train(Modell, Gerät, Train_Loader, Optimierer, Epoche):
 modell.train()
 für batch_idx, (Daten, Ziel) in enumerate(train_loader):
  Daten, Ziel = Daten.zu(Gerät), Ziel.zu(Gerät)
  optimizer.zero_grad()
  Ausgabe = Modell(Daten)
  Verlust = F.nll_loss(Ausgabe, Ziel)
  Verlust.rückwärts()
  Optimierer.Schritt()
  wenn batch_idx % 10 == 0:
   drucken('Zug-Epoche: {} [{}/{} ({:.0f}%)]\tVerlust: {:.6f}'.format(
    Epoche, batch_idx * len(Daten), len(train_loader.dataset),
      100. * batch_idx / länge(train_loader), verlust.item()))

def main():
 cudnn.benchmark = Wahr
 torch.manual_seed(1)
 Gerät = Torch.Device("cuda")
 kwargs = {'num_workers': 1, 'pin_memory': True}
 train_loader = torch.utils.data.DataLoader(
  Datensätze.MNIST('../data', Zug=True, Download=True,
      transform = transformiert.Komponieren([
       transformiert.ToTensor(),
       transformiert.Normalisieren((0,1307,), (0,3081,))
      ])),
  Batchgröße = 64, Shuffle = True, **kwargs)

 Modell = Net().to(Gerät)
 Optimierer = optim.SGD(Modell.Parameter(), lr=0,01, Impuls=0,5)

 für Epoche im Bereich (1, 11):
  Zug (Modell, Gerät, Train_Loader, Optimierer, Epoche)


wenn __name__ == '__main__':
 hauptsächlich()