Pytorch - Cummin

Larysa Witczak

Pytorch to open source framework dla języka programowania Pythona.

Tensor to wielowymiarowa tablica, która jest używana do przechowywania danych. Aby użyć tensora, musimy zaimportować moduł pochodni.

Aby utworzyć tensor, zastosowana metoda to TENSOR ().

Składnia:

latarka.tensor (dane)

Gdzie dane są wielowymiarową tablicą.

latarka.Cummin ()

Skumulowane minimum elementów w dwuwymiarowym tensorze na rzędach lub kolumnach jest zwracane przez pochodnię.Cummin (). Zwraca także wskaźniki zwróconych wartości minimalnych.

Składnia:

latarka.Cummin (tensor_object, DIM)

Parametry:

Tensor_Object jako pierwszy parametr. Musi być dwuwymiarowy.
DIM = 0 Określa obliczenia kolumnowe i DIM = 1 Określa obliczenia rzędowe.

Przykład 1:

W tym przykładzie utworzymy tensor, który ma cztery wiersze i cztery kolumny i zwrócimy skumulowane minimum każdego elementu w rzędu.

#Import Moduł pochodni
Importuj pochodnię
#Tensor
data1 = pochodnia.tensor ([[2,3,4,5], [1,3,5,3], [2,3,2,1], [2,3,4,2]]))
#wyświetlacz
Drukuj („Rzeczywisty tensor:”)
Drukuj (dane 1)
Drukuj („skumulowane minimum w całym rzędzie:”)
#Return Skumulowane minimum
Drukuj (pochodnia.Cummin (dane 1,1))

Wyjście:

Rzeczywisty tensor:
tensor ([[2, 3, 4, 5],
[1, 3, 5, 3],
[2, 3, 2, 1],
[2, 3, 4, 2]])
Skumulowane minimum w całym rzędzie:
latarka.return_types.Cummin (
Wartości = tensor ([[2, 2, 2, 2],
[1, 1, 1, 1],
[2, 2, 2, 1],
[2, 2, 2, 2]]),
indeksy = tensor ([[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 2, 3],
[0, 0, 0, 3])))

Pracujący:
Rząd-1: 2, minimum (2,3), minimum (2,3,4), minimum (2,3,4,5) = [2, 2, 2, 2]

Tak więc, [2,2,2,2] pozycje indeksu w rzeczywistym tensor są - [0,0,0,0]

Row-2: 1, minimum (1,3), minimum (1,3,5), minimum (1,3,5,3) = [1,1,1,1]

Tak więc, [1,1,1,1] pozycje indeksu w rzeczywistym tensorze wynoszą - [0,0,0,0]

Rząd-3: 2, minimum (2,3), minimum (2,3,2), minimum (2,3,2,1) = [2,2,2,1]

Tak więc, [2,2,2,1] pozycje indeksu w rzeczywistym tensor są - [0,0,2,3]

Row-4: 2, minimum (2,3), minimum (2,3,4), minimum (2,3,4,2) = [2,2,2,2]

Tak więc, [2,2,2,2] pozycje indeksu w rzeczywistym tensor są - [0,0,0,3]

Przykład 2:

W tym przykładzie utworzymy tensor, który ma cztery wiersze i cztery kolumny i zwrócimy skumulowane minimum każdego elementu w kolumnie.

#Import Moduł pochodni
Importuj pochodnię
#Tensor
data1 = pochodnia.tensor ([[2,3,4,5], [1,3,5,3], [2,3,2,1], [2,3,4,2]]))
#wyświetlacz
Drukuj („Rzeczywisty tensor:”)
Drukuj (dane 1)
Drukuj („skumulowane minimum w całej kolumnie:”)
#Return Skumulowane minimum
Drukuj (pochodnia.Cummin (dane 1,0))

Wyjście:

Rzeczywisty tensor:
tensor ([[2, 3, 4, 5],
[1, 3, 5, 3],
[2, 3, 2, 1],
[2, 3, 4, 2]])
Skumulowane minimum w kolumnie:
latarka.return_types.Cummin (
Wartości = tensor ([[2, 3, 4, 5],
[1, 3, 4, 3],
[1, 3, 2, 1],
[1, 3, 2, 1]]),
indeksy = tensor ([[0, 0, 0, 0],
[1, 1, 0, 1],
[1, 2, 2, 2],
[1, 3, 2, 2])))

Pracujący:

Kolumna 1: 2, minimum (2,1), minimum (2,1,2), minimum (2,1,2,2) = [2, 1,1,1]

Tak więc, [2, 1,1,1] pozycje indeksu w rzeczywistym tensor są - [0,1,1,1]

Kolumna-2: 3, minimum (3,3), minimum (3,3,3), minimum (3,3,3,3) = [3,3,3,3]

Tak więc, [3,3,3,3] pozycje indeksu w rzeczywistym tensor są - [0,1,2,3]

Kolumna-3: 4, minimum (4,5), minimum (4,5,2), minimum (4,5,2,4) = [4,4,2,2]

Tak więc, [4,4,2,2] pozycje indeksu w rzeczywistym tensorze to - [0,0,2,2]

Kolumna-4: 5, minimum (5,3), minimum (5,3,1), minimum (5,3,1,2) = [5,3,1,1]

Tak więc, [5,3,1,1] pozycje indeksu w rzeczywistym tensorze wynoszą - [0,1,2,2]

Pracuj z CPU

Jeśli chcesz uruchomić funkcję Cummin () na procesorze, musimy utworzyć tensor z funkcją CPU (). Będzie to działać na komputerze procesora.

W tej chwili, kiedy tworzymy tensor, możemy użyć funkcji CPU ().

Składnia:

latarka.tensor (dane).procesor()

Przykład 1:

W tym przykładzie utworzymy tensor, który ma cztery wiersze i cztery kolumny na procesorze i zwrócimy skumulowane minimum każdego elementu w rzędzie.

#Import Moduł pochodni
Importuj pochodnię
#Tensor
data1 = pochodnia.tensor ([[2,3,4,5], [1,3,5,3], [2,3,2,1], [2,3,4,2]])).procesor()
#wyświetlacz
Drukuj („Rzeczywisty tensor:”)
Drukuj (dane 1)
Drukuj („skumulowane minimum w całym rzędzie:”)
#Return Skumulowane minimum
Drukuj (pochodnia.Cummin (dane 1,1))

Wyjście:

Pracujący:

Rząd-1: 2, minimum (2,3), minimum (2,3,4), minimum (2,3,4,5) = [2, 2, 2, 2]

Tak więc, [2,2,2,2] pozycje indeksu w rzeczywistym tensor są - [0,0,0,0]

Row-2: 1, minimum (1,3), minimum (1,3,5), minimum (1,3,5,3) = [1,1,1,1]

Tak więc, [1,1,1,1] pozycje indeksu w rzeczywistym tensorze wynoszą - [0,0,0,0]

Rząd-3: 2, minimum (2,3), minimum (2,3,2), minimum (2,3,2,1) = [2,2,2,1]

Tak więc, [2,2,2,1] pozycje indeksu w rzeczywistym tensor są - [0,0,2,3]

Row-4: 2, minimum (2,3), minimum (2,3,4), minimum (2,3,4,2) = [2,2,2,2]

Tak więc, [2,2,2,2] pozycje indeksu w rzeczywistym tensor są - [0,0,0,3]

Przykład 2:

W tym przykładzie utworzymy tensor, który ma cztery wiersze i cztery kolumny na procesorze i zwrócimy skumulowane minimum każdego elementu w kolumnie.

#Import Moduł pochodni
Importuj pochodnię
#Tensor
data1 = pochodnia.tensor ([[2,3,4,5], [1,3,5,3], [2,3,2,1], [2,3,4,2]])).procesor()
#wyświetlacz
Drukuj („Rzeczywisty tensor:”)
Drukuj (dane 1)
Drukuj („skumulowane minimum w całej kolumnie:”)
#Return Skumulowane minimum
Drukuj (pochodnia.Cummin (dane 1,0))