Google Cloud Natural Language legge testo non strutturato e ti dice cosa contiene. Misura il sentiment complessivo di un documento, estrae come entità le persone, i luoghi e le organizzazioni che menziona e classifica il testo in una tassonomia di contenuti. L'edizione Enterprise di sgcWebSockets include un client gRPC Natural Language tipizzato sopra TsgcGRPCClient, così puoi raggiungere il servizio language.googleapis.com direttamente da Delphi e C++Builder senza alcun runtime gRPC esterno.
Come funziona
L'API Natural Language è esposta come servizio gRPC e gRPC è costituito da messaggi Protocol Buffers incapsulati su HTTP/2. sgcWebSockets include già uno stack HTTP/2 completo, quindi il client gRPC poggia su un trasporto TsgcHTTP2Client puntato a language.googleapis.com:443 su TLS. TsgcGRPCClient gestisce l'incapsulamento, il content type e i trailer di stato; l'unità tipizzata sgcGRPC_Google_Language gestisce i messaggi di richiesta e risposta.
Ogni richiesta avvolge un documento: il testo da analizzare più il suo tipo (testo semplice o HTML) e un suggerimento di lingua opzionale. Le classi tipizzate serializzano quel documento nel layout di filo Protocol Buffers esatto che l'API si aspetta e analizzano la risposta in proprietà pronte da leggere. Non assembli mai un protobuf a mano né insegui numeri di campo.
L'autenticazione usa un account di servizio Google Cloud. Un JWT autofirmato dell'account di servizio viene scambiato con un token bearer, che viene poi inviato come metadata gRPC su ogni chiamata. Poiché quel token è vincolato all'audience, il JWT viene coniato verso l'endpoint Natural Language in modo che sia accettato da language.googleapis.com.
Configurare il client
Crea un trasporto HTTP/2 per l'host Natural Language, poi collegagli un TsgcGRPCClient e seleziona il content type protobuf binario. Il token bearer ottenuto dall'account di servizio viene aggiunto a DefaultMetadata come header authorization standard, così viaggia su ogni richiesta.
uses
sgcHTTP2_Client, sgcGRPC_Client, sgcGRPC_Types, sgcGRPC_Google_Language;
var
HTTP2: TsgcHTTP2Client;
GRPC: TsgcGRPCClient;
begin
HTTP2 := TsgcHTTP2Client.Create(nil);
HTTP2.Host := 'language.googleapis.com';
HTTP2.Port := 443;
HTTP2.TLS := True;
GRPC := TsgcGRPCClient.Create(nil);
GRPC.Client := HTTP2;
GRPC.ChannelOptions.ContentType := grpcProto;
GRPC.ChannelOptions.Compression := grpcNoCompression;
// bearer token from the service-account JWT exchange
GRPC.DefaultMetadata.Add('authorization', 'Bearer ' + Token);
HTTP2.Active := True;
end;Analizzare il sentiment
L'analisi del sentiment riporta uno score emotivo da -1.0 (negativo) a +1.0 (positivo) e una magnitudine che riflette quanto contenuto emotivo porta il documento. Costruisci un TsgcGRPCLanguageAnalyzeSentimentRequest, imposta il contenuto del documento, chiama il metodo AnalyzeSentiment sul LanguageService, poi carica i byte della risposta in una risposta tipizzata.
var
oRequest: TsgcGRPCLanguageAnalyzeSentimentRequest;
oResponse: TsgcGRPCResponse;
oResult: TsgcGRPCLanguageAnalyzeSentimentResponse;
begin
oRequest := TsgcGRPCLanguageAnalyzeSentimentRequest.Create;
try
oRequest.Document.DocType := 1; // PLAIN_TEXT
oRequest.Document.Content := 'sgcWebSockets makes gRPC in Delphi easy.';
oResponse := GRPC.Call('google.cloud.language.v1.LanguageService',
'AnalyzeSentiment', oRequest.ToBytes);
if oResponse.StatusCode = grpcOK then
begin
oResult := TsgcGRPCLanguageAnalyzeSentimentResponse.Create;
try
oResult.LoadFromBytes(oResponse.Data);
ShowMessage('Score: ' + FloatToStr(oResult.DocumentSentiment.Score) +
' Magnitude: ' + FloatToStr(oResult.DocumentSentiment.Magnitude));
finally
oResult.Free;
end;
end;
finally
oRequest.Free;
end;
end;Estrarre entità
L'analisi delle entità restituisce le cose salienti di cui parla un documento. La risposta è una lista di entità, ognuna con un Name, un EntityType (persona, luogo, organizzazione e così via) e un punteggio di Salience che misura quanto l'entità è centrale per il testo. La risposta tipizzata ti dà una lista indicizzata da scorrere.
var
oRequest: TsgcGRPCLanguageAnalyzeEntitiesRequest;
oResponse: TsgcGRPCResponse;
oResult: TsgcGRPCLanguageAnalyzeEntitiesResponse;
i: Integer;
begin
oRequest := TsgcGRPCLanguageAnalyzeEntitiesRequest.Create;
try
oRequest.Document.DocType := 1; // PLAIN_TEXT
oRequest.Document.Content := Memo1.Text;
oResponse := GRPC.Call('google.cloud.language.v1.LanguageService',
'AnalyzeEntities', oRequest.ToBytes);
oResult := TsgcGRPCLanguageAnalyzeEntitiesResponse.Create;
try
oResult.LoadFromBytes(oResponse.Data);
for i := 0 to oResult.EntityCount - 1 do
Memo2.Lines.Add(oResult.Entity(i).Name + ' (type ' +
IntToStr(oResult.Entity(i).EntityType) + ', salience ' +
FloatToStr(oResult.Entity(i).Salience) + ')');
finally
oResult.Free;
end;
finally
oRequest.Free;
end;
end;Classificare il testo
La classificazione dei contenuti ordina un documento nella tassonomia di categorie di Google, restituendo una lista di categorie ognuna con un Name come /Computers & Electronics/Software e un valore di Confidence. Lo schema è lo stesso: costruisci un TsgcGRPCLanguageClassifyTextRequest, chiama ClassifyText, poi leggi le categorie da TsgcGRPCLanguageClassifyTextResponse con CategoryCount e Category(i). La classificazione ha bisogno di una quantità ragionevole di testo per funzionare bene, quindi forniscile più di una singola frase.
Disponibilità
Il client gRPC Natural Language fa parte dell'edizione Enterprise di sgcWebSockets e gira su Windows, macOS, Linux, iOS e Android, su Delphi e C++Builder. Un esempio completo e pronto all'uso è in Demos\21.GRPC\14.Natural_Language e il client sottostante è documentato sulla pagina prodotto gRPC Client.
Domande o feedback? Contattaci. Riceverai una risposta dalle persone che hanno scritto il codice.