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 dei nodi Gremlin in Neptune ML
<a name="machine-learning-gremlin-vertex-classification-queries"></a>

Per la classificazione dei nodi Gremlin in Neptune ML
+ Il modello viene addestrato su una proprietà dei vertici. Il set di valori univoci di questa proprietà è definito come un set di classi del nodo o semplicemente classi.
+ La classe del nodo o il valore della proprietà categoriale di un vertice può essere dedotto dal modello di classificazione dei nodi. Questo è utile quando questa proprietà non è già collegata al vertice.
+ Per recuperare una o più classi da un modello di classificazione dei nodi, è 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à dei vertici.

**Nota**  
La classificazione dei nodi 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 una query di classificazione dei nodi di esempio:

```
g.with( "Neptune#ml.endpoint","node-classification-movie-lens-endpoint" )
 .with( "Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role" )
 .with( "Neptune#ml.limit", 2 )
 .with( "Neptune#ml.threshold", 0.5D )
 .V( "movie_1", "movie_2", "movie_3" )
 .properties("genre").with("Neptune#ml.classification")
```

L'output di questa query ha un aspetto simile al seguente:

```
==>vp[genre->Action]
==>vp[genre->Crime]
==>vp[genre->Comedy]
```

Nella query precedente i passaggi `properties()` e `V()` vengono utilizzati nel modo seguente:

Il passaggio `V()` contiene il set di vertici per cui recuperare le classi dal modello di classificazione dei nodi:

```
 .V( "movie_1", "movie_2", "movie_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 dei nodi.

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", "node-classification-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .V( "movie_1", "movie_2", "movie_3" )
 .properties("genre", "other_label").with("Neptune#ml.classification")
```

Per il messaggio di errore specifico, consulta l'[elenco delle eccezioni di 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()`

## Altre query di classificazione dei nodi
<a name="machine-learning-gremlin-node-class-other-queries"></a>

Se sia l'endpoint di inferenza che il ruolo IAM corrispondente sono stati salvati nel gruppo di parametri del cluster database, una query di classificazione dei nodi può essere semplice come questa:

```
g.V("movie_1", "movie_2", "movie_3").properties("genre").with("Neptune#ml.classification")
```

È possibile combinare proprietà e classi dei vertici in una query usando il passaggio `union()`:

```
g.with("Neptune#ml.endpoint","node-classification-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .V( "movie_1", "movie_2", "movie_3" )
 .union(
   properties("genre").with("Neptune#ml.classification"),
   properties("genre")
 )
```

Puoi anche creare una query illimitata come questa:

```
g.with("Neptune#ml.endpoint","node-classification-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .V()
 .properties("genre").with("Neptune#ml.classification")
```

Puoi recuperare le classi dei nodi insieme ai vertici usando il passaggio `select()` insieme al passaggio `as()`:

```
g.with("Neptune#ml.endpoint","node-classification-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .V( "movie_1", "movie_2", "movie_3" ).as("vertex")
 .properties("genre").with("Neptune#ml.classification").as("properties")
 .select("vertex","properties")
```

Puoi anche filtrare in base alle classi di nodi, come illustrato in questi esempi:

```
g.with("Neptune#ml.endpoint", "node-classification-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .V( "movie_1", "movie_2", "movie_3" )
 .properties("genre").with("Neptune#ml.classification")
 .has(value, "Horror")

g.with("Neptune#ml.endpoint","node-classification-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .V( "movie_1", "movie_2", "movie_3" )
 .properties("genre").with("Neptune#ml.classification")
 .has(value, P.eq("Action"))

g.with("Neptune#ml.endpoint","node-classification-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .V( "movie_1", "movie_2", "movie_3" )
 .properties("genre").with("Neptune#ml.classification")
 .has(value, P.within("Action", "Horror"))
```

È possibile ottenere un punteggio di attendibilità di classificazione dei nodi usando il predicato `Neptune#ml.score`:

```
 g.with("Neptune#ml.endpoint","node-classification-movie-lens-endpoint")
 .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
 .V( "movie_1", "movie_2", "movie_3" )
 .properties("genre", "Neptune#ml.score").with("Neptune#ml.classification")
```

E la risposta avrà un aspetto simile al seguente:

```
==>vp[genre->Action]
==>vp[Neptune#ml.score->0.01234567]
==>vp[genre->Crime]
==>vp[Neptune#ml.score->0.543210]
==>vp[genre->Comedy]
==>vp[Neptune#ml.score->0.10101]
```

## Utilizzo dell'inferenza induttiva in una query di classificazione dei nodi
<a name="machine-learning-gremlin-node-class-inductive"></a>

Si supponga di dover aggiungere un nuovo nodo a un grafo esistente in un notebook Jupyter, in questo modo:

```
%%gremlin
g.addV('label1').property(id,'101').as('newV')
 .V('1').as('oldV1')
 .V('2').as('oldV2')
 .addE('eLabel1').from('newV').to('oldV1')
 .addE('eLabel2').from('oldV2').to('newV')
```

È quindi possibile usare una query di inferenza induttiva per ottenere un genere e un punteggio di attendibilità che riflettano il nuovo nodo:

```
%%gremlin
g.with("Neptune#ml.endpoint", "nc-ep")
 .with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
 .V('101').properties("genre", "Neptune#ml.score")
 .with("Neptune#ml.classification")
 .with("Neptune#ml.inductiveInference")
```

Se la query è stata eseguita più volte, tuttavia, i risultati restituiti potrebbero essere leggermente diversi:

```
# First time
==>vp[genre->Action]
==>vp[Neptune#ml.score->0.12345678]

# Second time
==>vp[genre->Action]
==>vp[Neptune#ml.score->0.21365921]
```

Puoi decidere rendere deterministica la stessa query:

```
%%gremlin
g.with("Neptune#ml.endpoint", "nc-ep")
 .with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
 .V('101').properties("genre", "Neptune#ml.score")
 .with("Neptune#ml.classification")
 .with("Neptune#ml.inductiveInference")
 .with("Neptune#ml.deterministic")
```

In tal caso, i risultati sarebbero più o meno gli stessi ogni volta:

```
# First time
==>vp[genre->Action]
==>vp[Neptune#ml.score->0.12345678]
# Second time
==>vp[genre->Action]
==>vp[Neptune#ml.score->0.12345678]
```