torcia.GT e torcia.GE Funzioni in Pytorch

In questo tutorial di Pytorch, vedremo come eseguire operazioni di confronto usando la torcia.gt () e torcia.GE () Metodi in Pytorch

Pytorch è un framework open source disponibile con un linguaggio di programmazione Python. Possiamo elaborare i dati in Pytorch sotto forma di tensore.

Un tensore è un array multidimensionale utilizzato per archiviare i dati. Per l'utilizzo di un tensore, dobbiamo importare il modulo Torch.

Per creare un tensore, il metodo utilizzato è tensore ().

Sintassi

torcia.tensore (dati)

Dove i dati sono un array multidimensionale.

torcia.funzione gt ()

IL torcia.LT () in Pytorch viene utilizzato per confrontare tutti gli elementi in due tensori (più grande di). Restituisce vero se l'elemento nel primo tensore è maggiore dell'elemento nel secondo tensore e restituisce falso se l'elemento nel primo tensore non è maggiore dell'elemento nel secondo tensore. Ci vogliono due parametri.

Sintassi

torcia.GT (tensor_object1, tensor_object2)

Parametri

1. tensor_object1 è il primo tensore
2. tensor_object2 è il secondo tensore

Ritorno
Restituirà un tensore con i valori booleani.

Esempio 1
In questo esempio, creeremo tensori monodimensionali: data1 e data2 con 5 valori numerici per eseguire GT ().

Modulo Torcia #IMport
Torcia di importazione
#Crea un tensore 1D - Data1 con 5 valori numerici
data1 = torcia.Tensor ([0,45,67,0,23])
#Crea un tensore 1D - data2 con 5 valori numerici
data2 = torcia.Tensor ([0,0,55,78,23])
#Schermo
Stampa ("Primo tensore:", data1)
Stampa ("Secondo tensore:", data2)
#gt () su data1 e data2
Stampa ("Elementi nel primo tensore sono maggiori degli elementi nel secondo tensore? : ", torcia.GT (data1, data2))

Produzione

Primo tensore: tensore ([0, 45, 67, 0, 23])
Secondo tensore: tensore ([0, 0, 55, 78, 23])

Gli elementi nel primo tensore sono maggiori degli elementi nel secondo tensore? : tensore ([falso, vero, vero, falso, falso])

Lavorando

1. 0 maggiore di 0 - falso
2. 45 maggiore di 0 - vero
3. 67 maggiore di 55 - vero
4. 0 maggiore di 78 - falso
5. 23 maggiore di 23 - falso

Esempio 2
In questo esempio, creeremo tensori bidimensionali: data1 e data2 con 5 valori numerici ciascuno in una riga ed eseguire GT ().

Modulo Torcia #IMport
Torcia di importazione
#Crea un tensore 2D - Data1 con 5 valori numerici in ogni riga
data1 = torcia.tensore ([[23,45,67,0,0], [12,21,34,56,78]]))
#Crea un tensore 2D - data2 con 5 valori numerici in ogni riga
data2 = torcia.tensore ([[0,0,55,78,23], [10,20,44,56,0]])
#Schermo
Stampa ("Primo tensore:", data1)
Stampa ("Secondo tensore:", data2)
#gt () su data1 e data2
Stampa ("Elementi nel primo tensore sono maggiori degli elementi nel secondo tensore? : ", torcia.GT (data1, data2))

Produzione

Primo tensore: tensore ([[23, 45, 67, 0, 0],
[12, 21, 34, 56, 78]])

Secondo tensore: tensore ([[0, 0, 55, 78, 23],
[10, 20, 44, 56, 0]])

Gli elementi nel primo tensore sono maggiori degli elementi nel secondo tensore? : Tensore ([[vero, vero, vero, falso, falso],
[Vero, vero, falso, falso, vero]])

Lavorando

1. 23 maggiore di 0 - vero, 12 maggiore di 10 - vero
2. 45 maggiore di 0 - vero, 21 maggiore di 20 - vero
3. 67 maggiore di 55 - vero, 34 maggiore di 44 - falso
4. 0 maggiore di 78 - falso, 56 maggiore di 56 - falso
5. 0 maggiore di 23 - falso, 78 maggiore di 0 - vero

Lavorare con la CPU
Se si desidera eseguire una funzione GT () sulla CPU, allora dobbiamo creare un tensore con una funzione CPU (). Questo funzionerà su una macchina CPU.

Quando stiamo creando un tensore, in questo momento, possiamo usare la funzione CPU ().

Sintassi

torcia.tensore (dati).processore()

Esempio
In questo esempio, creeremo tensori bidimensionali: data1 e data2 con 5 valori numerici ciascuno in riga ed eseguire GT ().

Modulo Torcia #IMport
Torcia di importazione
#Crea un tensore 2D - Data1 con 5 valori numerici in ogni riga
data1 = torcia.tensore ([[23,45,67,0,0], [12,21,34,56,78]])).processore()
#Crea un tensore 2D - data2 con 5 valori numerici in ogni riga
data2 = torcia.tensore ([[0,0,55,78,23], [10,20,44,56,0]]).processore()
#Schermo
Stampa ("Primo tensore:", data1)
Stampa ("Secondo tensore:", data2)
#gt () su data1 e data2
Stampa ("Elementi nel primo tensore sono maggiori degli elementi nel secondo tensore? : ", torcia.GT (data1, data2))

Produzione

Primo tensore: tensore ([[23, 45, 67, 0, 0],
[12, 21, 34, 56, 78]])

Secondo tensore: tensore ([[0, 0, 55, 78, 23],
[10, 20, 44, 56, 0]])

Sono gli elementi nel primo tensore maggiori degli elementi nel secondo tensore?
tensore ([[vero, vero, vero, falso, falso],
[Vero, vero, falso, falso, vero]])

Lavorando

1. 23 maggiore di 0 - vero, 12 maggiore di 10 - vero
2. 45 maggiore di 0 - vero, 21 maggiore di 20 - vero
3. 67 maggiore di 55 - vero, 34 maggiore di 44 - falso
4. 0 maggiore di 78 - falso, 56 maggiore di 56 - falso
5. 0 maggiore di 23 - falso, 78 maggiore di 0 - vero

torcia.funzione ge ()

IL torcia.La funzione GE () in Pytorch viene utilizzata per confrontare tutti gli elementi in due tensori (maggiore o uguale a). Restituisce vero se l'elemento nel primo tensore è maggiore o uguale all'elemento nel secondo tensore e falso se l'elemento nel primo tensore non è né maggiore o uguale all'elemento nel secondo tensore. Ci vogliono due parametri.

Sintassi

torcia.GE (tensor_object1, tensor_object2)
Parametri

1. tensor_object1 è il primo tensore


2. tensor_object2 è il secondo tensore

Ritorno
Restituirà un tensore con i valori booleani.
Esempio 1
In questo esempio, creeremo tensori monodimensionali: data1 e data2 con 5 valori numerici per eseguire ge ().
[cc lang = "python" width = "100%" altezza = "100%" sfuggito = "true" tema = "blackboard" NowRap = "0"]
Modulo Torcia #IMport
Torcia di importazione
#Crea un tensore 1D - Data1 con 5 valori numerici
data1 = torcia.Tensor ([0,45,67,0,23])
#Crea un tensore 1D - data2 con 5 valori numerici
data2 = torcia.Tensor ([0,0,55,78,23])
#Schermo
Stampa ("Primo tensore:", data1)
Stampa ("Secondo tensore:", data2)
#GE () su data1 e data2
Stampa ("Elementi nel primo tensore sono maggiori o uguali agli elementi nel secondo tensore? : ", torcia.GE (data1, data2))

Produzione

Primo tensore: tensore ([0, 45, 67, 0, 23])
Secondo tensore: tensore ([0, 0, 55, 78, 23])
Gli elementi nel primo tensore sono maggiori o uguali agli elementi nel secondo tensore? : tensore ([vero, vero, vero, falso, vero])

Lavorando

1. 0 maggiore o uguale a 0 - vero
2. 45 maggiore o uguale a 0 - vero
3. 67 maggiore o uguale a 55 - vero
4. 0 maggiore o uguale a 78 - falso
5. 23 SS maggiore o uguale a 23 - vero

Esempio 2
In questo esempio, creeremo tensori bidimensionali: data1 e data2 con 5 valori numerici ciascuno in riga ed eseguire GE ().

Modulo Torcia #IMport
Torcia di importazione
#Crea un tensore 2D - Data1 con 5 valori numerici in ogni riga
data1 = torcia.tensore ([[23,45,67,0,0], [12,21,34,56,78]]))
#Crea un tensore 2D - data2 con 5 valori numerici in ogni riga
data2 = torcia.tensore ([[0,0,55,78,23], [10,20,44,56,0]])
#Schermo
Stampa ("Primo tensore:", data1)
Stampa ("Secondo tensore:", data2)
#GE () su data1 e data2
Stampa ("Elementi nel primo tensore sono maggiori o uguali agli elementi nel secondo tensore? : ", torcia.GE (data1, data2))

Produzione

Primo tensore: tensore ([[23, 45, 67, 0, 0],
[12, 21, 34, 56, 78]])

Secondo tensore: tensore ([[0, 0, 55, 78, 23],
[10, 20, 44, 56, 0]])

Gli elementi nel primo tensore sono maggiori o uguali agli elementi nel secondo tensore? : tensore ([[vero, vero, vero, falso, falso],
[Vero, vero, falso, vero, vero]])

Lavorando

1. 23 maggiore o uguale a 0 - vero, 12 maggiore o uguale a 10 - vero
2. 45 maggiore o uguale a 0 - vero, 21 maggiore o uguale a 20 - vero
3. 67 maggiore o uguale a 55 - vero, 34 maggiore o uguale a 44 - falso
4. 0 maggiore o uguale a 78 - falso, 56 maggiore o uguale a 56 - vero
5. 0 maggiore o uguale a 23 - falso, 78 maggiore o uguale a 0 - vero

Lavorare con la CPU
Se si desidera eseguire una funzione GE () sulla CPU, allora dobbiamo creare un tensore con una funzione CPU (). Questo funzionerà su una macchina CPU.

Quando stiamo creando un tensore, in questo momento, possiamo usare la funzione CPU ().

Sintassi

torcia.tensore (dati).processore()

Esempio
In questo esempio, creeremo tensori bidimensionali: data1 e data2 con 5 valori numerici ciascuno in riga ed eseguire GE ().

Modulo Torcia #IMport
Torcia di importazione
#Crea un tensore 2D - Data1 con 5 valori numerici in ogni riga
data1 = torcia.tensore ([[23,45,67,0,0], [12,21,34,56,78]])).processore()
#Crea un tensore 2D - data2 con 5 valori numerici in ogni riga
data2 = torcia.tensore ([[0,0,55,78,23], [10,20,44,56,0]]).processore()
#Schermo
Stampa ("Primo tensore:", data1)
Stampa ("Secondo tensore:", data2)
#GE () su data1 e data2
Stampa ("Elementi nel primo tensore sono maggiori o uguali agli elementi nel secondo tensore? : ", torcia.GE (data1, data2))

Produzione

Primo tensore: tensore ([[23, 45, 67, 0, 0],
[12, 21, 34, 56, 78]])

Secondo tensore: tensore ([[0, 0, 55, 78, 23],
[10, 20, 44, 56, 0]])

Gli elementi nel primo tensore sono maggiori o uguali agli elementi nel secondo tensore? tensore ([[vero, vero, vero, falso, falso],
[Vero, vero, falso, vero, vero]])

Lavorando

1. 23 maggiore o uguale a 0 - vero, 12 maggiore o uguale a 10 - vero
2. 45 maggiore o uguale a 0 - vero, 21 maggiore o uguale a 20 - vero
3. 67 maggiore o uguale a 55 - vero, 34 maggiore o uguale a 44 - falso
4. 0 maggiore o uguale a 78 - falso, 56 maggiore o uguale a 56 - vero
5. 0 maggiore o uguale a 23 - falso, 78 maggiore o uguale a 0 - vero

Conclusione

In questa lezione di Pytorch, abbiamo discusso della torcia.gt () e torcia.ge (). Entrambi sono funzioni di confronto utilizzate per confrontare gli elementi in due tensori. La torcia.GT () confronta tutti gli elementi in due tensori (più grande di). Restituisce vero se l'elemento nel primo tensore è maggiore dell'elemento nel secondo tensore e restituisce falso se l'elemento nel primo tensore non è maggiore dell'elemento nel secondo tensore.

La torcia.ge () restituisce vero se l'elemento nel primo tensore è maggiore o uguale all'elemento nel secondo tensore e restituisce falso se l'elemento nel primo tensore non è né maggiore o uguale all'elemento nel secondo tensore. Abbiamo anche discusso di queste funzioni che funzioneranno su una CPU.