Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Query di classificazione degli archi Gremlin in Neptune ML
Per la classificazione degli archi Gremlin in Neptune ML:
+ Il modello viene addestrato su una proprietà degli archi. Il set di valori univoci di questa proprietà è definito come un set di classi.
+ Il valore della classe o della proprietà categoriale di un arco può essere dedotto dal modello di classificazione degli archi, utile quando questa proprietà non è già collegata all'arco.
+ Per recuperare una o più classi da un modello di classificazione degli archi, è necessario utilizzare il passaggio `with()` con il predicato `"Neptune#ml.classification"` per configurare il passaggio `properties()`. Il formato di output è simile a quello previsto se si trattasse di proprietà degli archi.
**Nota**
La classificazione degli archi funziona solo con i valori delle proprietà stringa. Ciò significa che i valori delle proprietà numeriche come `0` o `1` non sono supportati, sebbene gli equivalenti stringa `"0"` e `"1"` lo siano. Allo stesso modo, i valori delle proprietà booleane `true` e `false` non sono supportati, ma `"true"` e `"false"` funzionano.
Ecco un esempio di query di classificazione degli archi che richiede un punteggio di attendibilità usando il predicato `Neptune#ml.score` :
```
g.with("Neptune#ml.endpoint","edge-classification-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.E("relationship_1","relationship_2","relationship_3")
.properties("knows_by", "Neptune#ml.score").with("Neptune#ml.classification")
```
E la risposta avrà un aspetto simile al seguente:
```
==>p[knows_by->"Family"]
==>p[Neptune#ml.score->0.01234567]
==>p[knows_by->"Friends"]
==>p[Neptune#ml.score->0.543210]
==>p[knows_by->"Colleagues"]
==>p[Neptune#ml.score->0.10101]
```
## Sintassi di una query di classificazione degli archi Gremlin
Per un grafo semplice in cui `User` è il nodo di testa e il nodo di coda e `Relationship` è l'arco che li collega, ecco un esempio di query di classificazione degli archi:
```
g.with("Neptune#ml.endpoint","edge-classification-social-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.E("relationship_1","relationship_2","relationship_3")
.properties("knows_by").with("Neptune#ml.classification")
```
L'output di questa query ha un aspetto simile al seguente:
```
==>p[knows_by->"Family"]
==>p[knows_by->"Friends"]
==>p[knows_by->"Colleagues"]
```
Nella query precedente i passaggi `properties()` e `E()` vengono utilizzati nel modo seguente:
+ Il passaggio `E()` contiene il set di archi per cui recuperare le classi dal modello di classificazione degli archi:
```
.E("relationship_1","relationship_2","relationship_3")
```
+ Il passaggio `properties()` contiene la chiave su cui è stato addestrato il modello e include `.with("Neptune#ml.classification")` per indicare che si tratta di una query di inferenza ML per la classificazione degli archi.
Attualmente non sono supportate più chiavi delle proprietà in un passaggio `properties().with("Neptune#ml.classification")`. Ad esempio, la query seguente restituisce un'eccezione:
```
g.with("Neptune#ml.endpoint","edge-classification-social-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.E("relationship_1","relationship_2","relationship_3")
.properties("knows_by", "other_label").with("Neptune#ml.classification")
```
Per i messaggi di errore specifici, consulta [Elenco delle eccezioni per le query di inferenza Gremlin in Neptune ML](machine-learning-gremlin-exceptions.md).
È possibile usare un passaggio `properties().with("Neptune#ml.classification")` in combinazione con uno dei seguenti passaggi:
+ `value()`
+ `value().is()`
+ `hasValue()`
+ `has(value,"")`
+ `key()`
+ `key().is()`
+ `hasKey()`
+ `has(key,"")`
+ `path()`
## Utilizzo dell'inferenza induttiva in una query di classificazione degli archi
Si supponga di dover aggiungere un nuovo arco a un grafo esistente in un notebook Jupyter, in questo modo:
```
%%gremlin
g.V('1').as('fromV')
.V('2').as('toV')
.addE('eLabel1').from('fromV').to('toV').property(id, 'e101')
```
È quindi possibile utilizzare una query di inferenza induttiva per ottenere una valutazione che tenga conto del nuovo arco:
```
%%gremlin
g.with("Neptune#ml.endpoint", "ec-ep")
.with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
.E('e101').properties("scale", "Neptune#ml.score")
.with("Neptune#ml.classification")
.with("Neptune#ml.inductiveInference")
```
Poiché la query è non deterministica, potrebbe restituire risultati leggermente diversi se la si esegue più volte, in base al neighborhood casuale:
```
# First time
==>vp[scale->Like]
==>vp[Neptune#ml.score->0.12345678]
# Second time
==>vp[scale->Like]
==>vp[Neptune#ml.score->0.21365921]
```
Se sono necessari risultati più coerenti, puoi rendere la query deterministica:
```
%%gremlin
g.with("Neptune#ml.endpoint", "ec-ep")
.with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
.E('e101').properties("scale", "Neptune#ml.score")
.with("Neptune#ml.classification")
.with("Neptune#ml.inductiveInference")
.with("Neptune#ml.deterministic")
```
Ora i risultati saranno più o meno gli stessi ogni volta che si esegue la query:
```
# First time
==>vp[scale->Like]
==>vp[Neptune#ml.score->0.12345678]
# Second time
==>vp[scale->Like]
==>vp[Neptune#ml.score->0.12345678]
```