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 inferenza Gremlin in Neptune ML
Come descritto in [Funzionalità di Neptune ML](machine-learning.md#machine-learning-capabilities), Neptune ML supporta modelli di addestramento che possono eseguire i seguenti tipi di attività di inferenza:
+ **Classificazione dei nodi**: previsione della funzionalità categoriale di una proprietà del vertice.
+ **Regressione dei nodi**: previsione di una proprietà numerica di un vertice.
+ **Classificazione degli archi**: previsione della funzionalità categoriale di una proprietà dell'arco.
+ **Regressione degli archi**: previsione di una proprietà numerica di un arco.
+ **Previsione dei collegamenti**: previsione dei nodi di destinazione per un nodo di origine e un arco in uscita specifici oppure i nodi di origine per un nodo di destinazione e un arco in entrata specificati.
[Possiamo illustrare queste diverse attività con esempi che utilizzano il [set di dati da MovieLens 100.000](https://grouplens.org/datasets/movielens/100k/) fornito da Research. GroupLens ](https://grouplens.org/datasets/movielens/) Questo set di dati è costituito da film, utenti e valutazioni dei film da parte degli utenti, da cui è stato creato un grafo delle proprietà come questo:
![\[Esempio di grafico delle proprietà del film utilizzando il set di dati da 100k MovieLens\]](http://docs.aws.amazon.com/it_it/neptune/latest/userguide/images/movie_property_graph_example.png)
**Classificazione dei nodi**: nel set di dati precedente, `Genre` è un tipo di vertice collegato al tipo di vertice `Movie` tramite l'arco `included_in`. Tuttavia, se si modifica il set di dati per rendere `Genre` una funzionalità [categoriale](https://en.wikipedia.org/wiki/Categorical_variable) per il tipo di vertice `Movie`, il problema di dedurre `Genre` per i nuovi film aggiunti al grafo della conoscenza può essere risolto usando modelli di classificazione dei nodi.
**Regressione dei nodi**: se si considera il tipo di vertice `Rating`, che ha proprietà come `timestamp` e `score`, il problema di dedurre il valore numerico `Score` per una valutazione `Rating` può essere risolto usando modelli di regressione dei nodi.
**Classificazione dei bordi**: allo stesso modo, per un `Rated` bordo, se abbiamo una proprietà `Scale` che può avere uno dei valori,,`Love`,`Like`,, `Dislike` `Neutral``Hate`, allora il problema della deduzione `Scale` per l'`Rated`edge per nuovi movies/ratings può essere risolto utilizzando modelli di classificazione dei bordi.
**Regressione degli archi**: allo stesso modo, se per lo stesso arco `Rated` è presente una proprietà `Score` che contiene un valore numerico per la valutazione, questo può essere dedotto usando modelli di regressione degli archi.
**Previsione dei collegamenti**: nell'ambito della previsione dei collegamenti rientrano problemi come trovare i dieci utenti con le maggiori probabilità di valutare un determinato film o trovare i primi dieci film con le maggiori probabilità di essere valutati da un utente specifico.
**Nota**
Per i casi d'uso di Neptune ML, è disponibile un ampio set di notebook progettati per fornire informazioni pratiche su ogni caso d'uso. È possibile creare questi notebook insieme al cluster Neptune quando si utilizza il modello Neptune ML per creare un cluster [Neptune ML](machine-learning-quick-start.md). CloudFormation Questi notebook sono disponibili anche su [github](https://github.com/aws/graph-notebook/tree/main/src/graph_notebook/notebooks/04-Machine-Learning).
**Topics**
+ [
# Predicati Neptune ML utilizzati nelle query di inferenza Gremlin
](machine-learning-gremlin-inference-query-predicates.md)
+ [
# Query di classificazione dei nodi Gremlin in Neptune ML
](machine-learning-gremlin-vertex-classification-queries.md)
+ [
# Query di regressione dei nodi Gremlin in Neptune ML
](machine-learning-gremlin-vertex-regression-queries.md)
+ [
# Query di classificazione degli archi Gremlin in Neptune ML
](machine-learning-gremlin-edge-classification-queries.md)
+ [
# Query di regressione degli archi Gremlin in Neptune ML
](machine-learning-gremlin-edge-regression.md)
+ [
# Query di previsione dei collegamenti Gremlin che utilizzano modelli di previsione dei collegamenti in Neptune ML
](machine-learning-gremlin-link-prediction-queries.md)
+ [
# Elenco delle eccezioni per le query di inferenza Gremlin in Neptune ML
](machine-learning-gremlin-exceptions.md)
# Predicati Neptune ML utilizzati nelle query di inferenza Gremlin
## `Neptune#ml.deterministic`
Questo predicato è un'opzione per le query di inferenza induttiva, ovvero per le query che includono il predicato [`Neptune#ml.inductiveInference`](#machine-learning-gremlin-inference-neptune-ml-inductiveInference).
Quando si utilizza l'inferenza induttiva, il motore Neptune crea il sottografo appropriato per valutare il modello GNN addestrato e i requisiti di questo sottografo dipendono dai parametri del modello finale. In particolare, il parametro `num-layer` determina il numero di hop di attraversamento dai nodi o dagli archi di destinazione e il parametro `fanouts` specifica il numero di vicini da campionare in ogni hop (consulta [Parametri di ottimizzazione degli iperparametri](machine-learning-customizing-hyperparams.md)).
Per impostazione predefinita, le query di inferenza induttiva vengono eseguite in modalità non deterministica, in cui Neptune crea il neighborhood in modo casuale. Quando si effettuano previsioni, questo normale campionamento casuale dei vicini genera talvolta previsioni diverse.
Quando si include `Neptune#ml.deterministic` in una query di inferenza induttiva, il motore Neptune tenta di campionare i vicini in modo deterministico in modo che più invocazioni della stessa query restituiscano sempre gli stessi risultati. Tuttavia, non si può garantire che i risultati siano completamente deterministici, poiché le modifiche al grafo e agli artefatti sottostanti dei sistemi distribuiti possono comunque introdurre fluttuazioni.
Includi il predicato `Neptune#ml.deterministic` in una query in questo modo:
```
.with("Neptune#ml.deterministic")
```
Se il predicato `Neptune#ml.deterministic` è incluso in una query che non include anche `Neptune#ml.inductiveInference`, viene semplicemente ignorato.
## `Neptune#ml.disableInductiveInferenceMetadataCache`
Questo predicato è un'opzione per le query di inferenza induttiva, ovvero per le query che includono il predicato [`Neptune#ml.inductiveInference`](#machine-learning-gremlin-inference-neptune-ml-inductiveInference).
Per le query di inferenza induttiva, Neptune utilizza un file di metadati archiviato in Amazon S3 per decidere il numero di hop e il fanout durante la creazione del neighborhood Neptune normalmente memorizza nella cache i metadati di questo modello per evitare di recuperare ripetutamente il file da Amazon S3. La memorizzazione nella cache può essere disabilitata includendo il predicato `Neptune#ml.disableInductiveInferenceMetadataCache` nella query. Sebbene possa essere più lento per Neptune recuperare i metadati direttamente da Amazon S3, è utile SageMaker quando l'endpoint AI è stato aggiornato dopo la riqualificazione o la trasformazione e la cache è obsoleta.
Includi il predicato `Neptune#ml.disableInductiveInferenceMetadataCache` in una query in questo modo:
```
.with("Neptune#ml.disableInductiveInferenceMetadataCache")
```
Ecco l'aspetto di una query di esempio in un notebook Jupyter:
```
%%gremlin
g.with("Neptune#ml.endpoint", "ep1")
.with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
.with("Neptune#ml.disableInductiveInferenceMetadataCache")
.V('101').properties("rating")
.with("Neptune#ml.regression")
.with("Neptune#ml.inductiveInference")
```
## `Neptune#ml.endpoint`
Il predicato `Neptune#ml.endpoint` viene utilizzato in un passaggio `with()` per specificare l'endpoint di inferenza, se necessario:
```
.with("Neptune#ml.endpoint", "the model's SageMaker AI inference endpoint")
```
È possibile identificare l'endpoint in base all'`id` o al relativo URL. Esempio:
```
.with( "Neptune#ml.endpoint", "node-classification-movie-lens-endpoint" )
```
O:
```
.with( "Neptune#ml.endpoint", "https://runtime.sagemaker.us-east-1.amazonaws.com/endpoints/node-classification-movie-lens-endpoint/invocations" )
```
**Nota**
Se [imposti il parametro `neptune_ml_endpoint`](machine-learning-cluster-setup.md#machine-learning-set-inference-endpoint-cluster-parameter) nel gruppo di parametri del cluster database Neptune DB sull'`id` o sull'URL dell'endpoint, non è necessario includere il predicato `Neptune#ml.endpoint` in ogni query.
## `Neptune#ml.iamRoleArn`
`Neptune#ml.iamRoleArn`viene utilizzato in un `with()` passaggio per specificare l'ARN del ruolo IAM di esecuzione SageMaker AI, se necessario:
```
.with("Neptune#ml.iamRoleArn", "the ARN for the SageMaker AI execution IAM role")
```
Per informazioni su come creare il ruolo IAM per l'esecuzione dell' SageMaker IA, consulta[Crea un ruolo personalizzato NeptuneSageMaker IAMRole](machine-learning-manual-setup.md#ml-manual-setup-sm-role).
**Nota**
Se [imposti il `neptune_ml_iam_role` parametro](machine-learning-cluster-setup.md#machine-learning-enabling-create-param-group) nel gruppo di parametri del cluster Neptune DB sull'ARN del SageMaker tuo ruolo IAM di esecuzione AI, non è necessario includere `Neptune#ml.iamRoleArn` il predicato in ogni query.
## Neptune\$1ml.inductiveInference
In Gremlin l'inferenza trasduttiva è abilitata per impostazione predefinita. Per creare una query di [inferenza induttiva in tempo reale](machine-learning-overview-evolving-data.md#inductive-vs-transductive-inference), includi il predicato `Neptune#ml.inductiveInference` in questo modo:
```
.with("Neptune#ml.inductiveInference")
```
Se il grafo è dinamico, l'inferenza induttiva è spesso la scelta migliore, ma se il grafo è statico, l'inferenza trasduttiva è più veloce ed efficiente.
## `Neptune#ml.limit`
Il predicato `Neptune#ml.limit` limita facoltativamente il numero di risultati restituiti per ogni entità:
```
.with( "Neptune#ml.limit", 2 )
```
Per impostazione predefinita, il limite è 1 e il numero massimo che è possibile impostare è 100.
## `Neptune#ml.threshold`
Il predicato `Neptune#ml.threshold` stabilisce facoltativamente una soglia limite per i punteggi dei risultati:
```
.with( "Neptune#ml.threshold", 0.5D )
```
Ciò consente di scartare tutti i risultati con punteggi inferiori alla soglia specificata.
## `Neptune#ml.classification`
Il `Neptune#ml.classification` predicato è allegato alla `properties()` fase per stabilire che le proprietà devono essere recuperate dall'endpoint SageMaker AI del modello di classificazione dei nodi:
```
.properties( "property key of the node classification model" ).with( "Neptune#ml.classification" )
```
## `Neptune#ml.regression`
Il `Neptune#ml.regression` predicato è allegato alla `properties()` fase per stabilire che le proprietà devono essere recuperate dall'endpoint SageMaker AI del modello di regressione dei nodi:
```
.properties( "property key of the node regression model" ).with( "Neptune#ml.regression" )
```
## `Neptune#ml.prediction`
Il predicato `Neptune#ml.prediction` è collegato ai passaggi `in()` e `out()` per stabilire che si tratta di una query di previsione dei collegamenti:
```
.in("edge label of the link prediction model").with("Neptune#ml.prediction").hasLabel("target node label")
```
## `Neptune#ml.score`
Il predicato `Neptune#ml.score` viene usato nelle query di classificazione dei nodi o degli archi Gremlin per ottenere un punteggio di attendibilità di machine learning. Il predicato `Neptune#ml.score` deve essere passato insieme al predicato di query nel passaggio `properties()` per ottenere un punteggio di attendibilità di ML per le query di classificazione dei nodi o degli archi.
È possibile trovare un esempio di classificazione dei nodi con [altri esempi di classificazione dei nodi](machine-learning-gremlin-vertex-classification-queries.md#machine-learning-gremlin-node-class-other-queries) e un esempio di classificazione degli archi nella [sezione relativa alla classificazione degli archi](machine-learning-gremlin-edge-classification-queries.md).
# Query di classificazione dei nodi Gremlin in Neptune ML
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
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
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]
```
# Query di regressione dei nodi Gremlin in Neptune ML
La regressione dei nodi è simile alla classificazione dei nodi, tranne per il fatto che il valore dedotto dal modello di regressione per ogni nodo è numerico. Per la regressione dei nodi è possibile usare le stesse query Gremlin usate per la classificazione dei nodi, con le seguenti differenze:
+ Ancora una volta, in Neptune ML i nodi fanno riferimento ai vertici.
+ Il passaggio `properties()` accetta il formato `properties().with("Neptune#ml.regression")` anziché `properties().with("Neptune#ml.classification")`.
+ I predicati `"Neptune#ml.limit`" e `"Neptune#ml.threshold"` non sono applicabili.
+ Quando si filtra in base al valore, è necessario specificare un valore numerico.
Ecco una query di classificazione dei vertici di esempio:
```
g.with("Neptune#ml.endpoint","node-regression-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn", "arn:aws:iam::0123456789:role/sagemaker-role")
.V("movie_1","movie_2","movie_3")
.properties("revenue").with("Neptune#ml.regression")
```
È possibile filtrare in base al valore dedotto utilizzando un modello di regressione, come illustrato negli esempi seguenti:
```
g.with("Neptune#ml.endpoint","node-regression-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.V("movie_1","movie_2","movie_3")
.properties("revenue").with("Neptune#ml.regression")
.value().is(P.gte(1600000))
g.with("Neptune#ml.endpoint","node-regression-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.V("movie_1","movie_2","movie_3")
.properties("revenue").with("Neptune#ml.regression")
.hasValue(P.lte(1600000D))
```
## Utilizzo dell'inferenza induttiva in una query di regressione dei nodi
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 utilizzare una query di inferenza induttiva per ottenere una valutazione che tenga conto del nuovo nodo:
```
%%gremlin
g.with("Neptune#ml.endpoint", "nr-ep")
.with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
.V('101').properties("rating")
.with("Neptune#ml.regression")
.with("Neptune#ml.inductiveInference")
```
Poiché la query è non deterministica, potrebbe restituire risultati leggermente diversi se la si esegue più volte, in base al neighborhood:
```
# First time
==>vp[rating->9.1]
# Second time
==>vp[rating->8.9]
```
Se sono necessari risultati più coerenti, puoi rendere la query deterministica:
```
%%gremlin
g.with("Neptune#ml.endpoint", "nc-ep")
.with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
.V('101').properties("rating")
.with("Neptune#ml.regression")
.with("Neptune#ml.inductiveInference")
.with("Neptune#ml.deterministic")
```
Ora i risultati saranno più o meno gli stessi ogni volta:
```
# First time
==>vp[rating->9.1]
# Second time
==>vp[rating->9.1]
```
# 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]
```
# Query di regressione degli archi Gremlin in Neptune ML
La regressione degli archi è simile alla classificazione degli archi, tranne per il fatto che il valore dedotto dal modello di machine learning è numerico. Per la regressione degli archi, Neptune ML supporta le stesse query utilizzate per la classificazione.
Gli aspetti principali da notare sono:
+ È necessario usare il predicato ML `"Neptune#ml.regression"` per configurare il passaggio `properties()` per questo caso d'uso.
+ I predicati `"Neptune#ml.limit"` e `"Neptune#ml.threshold"` non sono applicabili in questo caso d'uso.
+ Per filtrare in base al valore, è necessario specificare il valore come numerico.
## Sintassi di una query di regressione degli archi Gremlin
Per un grafo semplice in cui `User` è il nodo di testa, `Movie` è il nodo di coda e `Rated` è l'arco che li collega, ecco un esempio di query di regressione degli archi che trova il valore di valutazione numerico, qui denominato punteggio, per l'arco `Rated`:
```
g.with("Neptune#ml.endpoint","edge-regression-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.E("rating_1","rating_2","rating_3")
.properties("score").with("Neptune#ml.regression")
```
Puoi anche filtrare in base a un valore dedotto dal modello di regressione ML. Per gli archi `Rated` esistenti (da `User` a `Movie`) identificati da `"rating_1"`, `"rating_2"` e `"rating_3"`, dove la proprietà dell'arco `Score` sia presente per queste classificazioni, è possibile usare una query come la seguente per dedurre `Score` per gli archi in cui è maggiore o uguale a 9:
```
g.with("Neptune#ml.endpoint","edge-regression-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.E("rating_1","rating_2","rating_3")
.properties("score").with("Neptune#ml.regression")
.value().is(P.gte(9))
```
## Utilizzo dell'inferenza induttiva in una query di regressione 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 un punteggio che tenga conto del nuovo arco:
```
%%gremlin
g.with("Neptune#ml.endpoint", "er-ep")
.with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
.E('e101').properties("score")
.with("Neptune#ml.regression")
.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
==>ep[score->96]
# Second time
==>ep[score->91]
```
Se sono necessari risultati più coerenti, puoi rendere la query deterministica:
```
%%gremlin
g.with("Neptune#ml.endpoint", "er-ep")
.with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
.E('e101').properties("score")
.with("Neptune#ml.regression")
.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
==>ep[score->96]
# Second time
==>ep[score->96]
```
# Query di previsione dei collegamenti Gremlin che utilizzano modelli di previsione dei collegamenti in Neptune ML
I modelli di previsione dei collegamenti possono risolvere problemi come i seguenti:
+ **Previsione del nodo di testa**: dati un vertice e un tipo di arco, quali sono i vertici da cui provengono i collegamenti di tale vertice?
+ **Previsione del nodo di coda**: dati un vertice e un tipo di arco, quali sono i vertici a cui si collega tale vertice?
**Nota**
La previsione degli archi non è ancora supportata in Neptune ML.
Per gli esempi seguenti, si consideri un semplice grafo con i vertici `User` e `Movie` collegati dall'arco `Rated`.
Ecco un esempio di query di previsione del nodo di testa, usata per prevedere i primi cinque utenti con le maggiori probabilità di valutare i film, `"movie_1"`, `"movie_2"` e `"movie_3"`:
```
g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.with("Neptune#ml.limit", 5)
.V("movie_1", "movie_2", "movie_3")
.in("rated").with("Neptune#ml.prediction").hasLabel("user")
```
Eccone una simile per la previsione del nodo di coda, usata per prevedere i primi cinque film con le maggiori probabilità di essere valutati dall'utente `"user_1"`:
```
g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.V("user_1")
.out("rated").with("Neptune#ml.prediction").hasLabel("movie")
```
L'etichetta dell'arco e l'etichetta del vertice previsto sono obbligatorie. Se una delle due viene omessa, verrà generata un'eccezione. Ad esempio, la seguente query senza un'etichetta del vertice previsto genera un'eccezione:
```
g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.V("user_1")
.out("rated").with("Neptune#ml.prediction")
```
Analogamente, la seguente query senza un'etichetta dell'arco genera un'eccezione:
```
g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.V("user_1")
.out().with("Neptune#ml.prediction").hasLabel("movie")
```
Per i messaggi di errore specifici restituiti da queste eccezioni, consulta l'[elenco delle eccezioni di Neptune ML](machine-learning-gremlin-exceptions.md).
## Altre query di previsione dei collegamenti
Puoi usare il passaggio `select()` con il passaggio `as(`) per generare i vertici previsti insieme ai vertici di input:
```
g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.V("movie_1").as("source")
.in("rated").with("Neptune#ml.prediction").hasLabel("user").as("target")
.select("source","target")
g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.V("user_1").as("source")
.out("rated").with("Neptune#ml.prediction").hasLabel("movie").as("target")
.select("source","target")
```
Puoi eseguire query illimitate, come queste:
```
g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.V("user_1")
.out("rated").with("Neptune#ml.prediction").hasLabel("movie")
g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint")
.with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role")
.V("movie_1")
.in("rated").with("Neptune#ml.prediction").hasLabel("user")
```
## Utilizzo dell'inferenza induttiva in una query di previsione dei collegamenti
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('newV1')
.addV('label2').property(id,'102').as('newV2')
.V('1').as('oldV1')
.V('2').as('oldV2')
.addE('eLabel1').from('newV1').to('oldV1')
.addE('eLabel2').from('oldV2').to('newV2')
```
È quindi possibile utilizzare una query di inferenza induttiva per prevedere il nodo di testa, tenendo conto del nuovo nodo:
```
%%gremlin
g.with("Neptune#ml.endpoint", "lp-ep")
.with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
.V('101').out("eLabel1")
.with("Neptune#ml.prediction")
.with("Neptune#ml.inductiveInference")
.hasLabel("label2")
```
Risultato:
```
==>V[2]
```
Allo stesso modo, è possibile utilizzare una query di inferenza induttiva per prevedere il nodo di coda, tenendo conto del nuovo nodo:
```
%%gremlin
g.with("Neptune#ml.endpoint", "lp-ep")
.with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole")
.V('102').in("eLabel2")
.with("Neptune#ml.prediction")
.with("Neptune#ml.inductiveInference")
.hasLabel("label1")
```
Risultato:
```
==>V[1]
```
# Elenco delle eccezioni per le query di inferenza Gremlin in Neptune ML
Questo è un elenco completo di eccezioni che possono verificarsi durante l'esecuzione di query di inferenza Neptune ML Gremlin. Queste eccezioni coprono una serie di problemi, dai problemi con il ruolo o l'endpoint IAM specificato, ai passaggi Gremlin non supportati e alle limitazioni sul numero di query di inferenza ML per query. Ogni voce include un messaggio dettagliato che descrive il problema.
+ **`BadRequestException`**: non è possibile caricare le credenziali per il ruolo fornito.
*Messaggio*: `Unable to load credentials for role: the specified IAM Role ARN.`
+ **`BadRequestException`**— Il ruolo IAM specificato non è autorizzato a richiamare l'endpoint SageMaker AI.
*Messaggio*: `User: the specified IAM Role ARN is not authorized to perform: sagemaker:InvokeEndpoint on resource: the specified endpoint.`
+ **`BadRequestException`**: l'endpoint specificato non esiste.
*Messaggio*: `Endpoint the specified endpoint not found.`
+ **`InternalFailureException`**: non è possibile recuperare i metadati di inferenza induttiva in tempo reale di Neptune ML da Amazon S3.
*Messaggio*: `Unable to fetch Neptune ML - Real-Time Inductive Inference metadata from S3. Check the permissions of the S3 bucket or if the Neptune instance can connect to S3.`
+ **`InternalFailureException`**: Neptune ML non trova il file dei metadati per l'inferenza induttiva in tempo reale in Amazon S3.
*Messaggio*: `Neptune ML cannot find the metadata file for Real-Time Inductive Inference in S3.`
+ **`InvalidParameterException`**: l'endpoint specificato non è valido dal punto di vista sintattico.
*Messaggio*: `Invalid endpoint provided for external service query.`
+ **`InvalidParameterException`**— L' SageMaker esecuzione IAM Role ARN specificata non è sintatticamente valida.
*Messaggio*: `Invalid IAM role ARN provided for external service query.`
+ **`InvalidParameterException`**: nel passaggio `properties()` di una query sono specificate più chiavi delle proprietà.
*Messaggio*: `ML inference queries are currently supported for one property key.`
+ **`InvalidParameterException`**: in una query vengono specificate più etichette degli archi.
*Messaggio*: `ML inference are currently supported only with one edge label.`
+ **`InvalidParameterException`**: in una query sono specificati più vincoli per le etichette dei vertici.
*Messaggio*: `ML inference are currently supported only with one vertex label constraint.`
+ **`InvalidParameterException`**: nella stessa query sono presenti entrambi i predicati `Neptune#ml.classification` e `Neptune#ml.regression`.
*Messaggio*: `Both regression and classification ML predicates cannot be specified in the query.`
+ **`InvalidParameterException`**: è stata specificata più di un'etichetta dell'arco nel passaggio `in()` o `out()` di una query di previsione dei collegamenti.
*Messaggio*: `ML inference are currently supported only with one edge label.`
+ **`InvalidParameterException`**: è stata specificata più di una chiave delle proprietà con Neptune\$1ml.score.
*Messaggio*: `Neptune ML inference queries are currently supported for one property key and one Neptune#ml.score property key.`
+ **`MissingParameterException`**: l'endpoint non è stato specificato nella query o come parametro del cluster database.
*Messaggio*: `No endpoint provided for external service query.`
+ **``MissingParameterException**— Il ruolo IAM per l'esecuzione dell' SageMaker IA non è stato specificato nella query o come parametro del cluster DB.
*Messaggio*: `No IAM role ARN provided for external service query.`
+ **`MissingParameterException`**: la chiave della proprietà non è presente nel passaggio `properties()` in una query.
*Messaggio*: `Property key needs to be specified using properties() step for ML inference queries.`
+ **`MissingParameterException`**: non è stata specificata alcuna un'etichetta dell'arco nel passaggio `in()` o `out()` di una query di previsione dei collegamenti.
*Messaggio*: `Edge label needs to be specified while using in() or out() step for ML inference queries.`
+ **`MissingParameterException`**: non è stata specificata alcuna chiave della proprietà con Neptune\$1ml.score.
*Messaggio*: `Property key needs to be specified along with Neptune#ml.score property key while using the properties() step for Neptune ML inference queries.`
+ **`UnsupportedOperationException`**: in una query di previsione dei collegamenti è stato usato un passaggio `both()`.
*Messaggio*: `ML inference queries are currently not supported with both() step.`
+ **`UnsupportedOperationException`**: non è stata specificata alcuna etichetta del vertice previsto nel passaggio `has()` con il passaggio `in()` o `out()` in una query di previsione dei collegamenti.
*Messaggio*: `Predicted vertex label needs to be specified using has() step for ML inference queries.`
+ **`UnsupportedOperationException`**: le query di inferenza induttiva ML Gremlin non sono attualmente supportate con passaggi non ottimizzati.
*Messaggio*: `Neptune ML - Real-Time Inductive Inference queries are currently not supported with Gremlin steps which are not optimized for Neptune. Check the Neptune User Guide for a list of Neptune-optimized steps.`
+ **`UnsupportedOperationException`**: le query di inferenza di Neptune ML non sono attualmente supportate all'interno di un passaggio `repeat`.
*Messaggio*: `Neptune ML inference queries are currently not supported inside a repeat step.`
+ **`UnsupportedOperationException`**: attualmente non sono supportate più query di inferenza Neptune ML per ogni query Gremlin.
*Messaggio*: `Neptune ML inference queries are currently supported only with one ML inference query per gremlin query.`