diff --git a/ai_services/language/java/pom.xml b/ai_services/language/java/pom.xml index b1cacb4e..4047fe84 100644 --- a/ai_services/language/java/pom.xml +++ b/ai_services/language/java/pom.xml @@ -12,19 +12,19 @@ com.oracle.oci.sdk oci-java-sdk-ailanguage - 3.0.1 + LATEST com.oracle.oci.sdk oci-java-sdk-common - 3.0.1 + LATEST com.oracle.oci.sdk oci-java-sdk-common-httpclient-jersey - 3.0.1 + LATEST org.slf4j @@ -36,11 +36,6 @@ slf4j-simple 2.0.5 - - groupId - languagefromjava - 1.0-SNAPSHOT - @@ -48,4 +43,4 @@ 8 - \ No newline at end of file + diff --git a/ai_services/language/java/readme.md b/ai_services/language/java/readme.md index 6f4a8dac..a8b67187 100644 --- a/ai_services/language/java/readme.md +++ b/ai_services/language/java/readme.md @@ -12,21 +12,29 @@ You can invoke OCI Language capabilities through the OCI SDKs. Download and install the OCI Java SDK so you have access to the libraries you need to use, as described in [this article](https://docs.oracle.com/en-us/iaas/Content/API/SDKDocs/javasdkgettingstarted.htm). -For the sample in this directory, I relied on Maven get the libraries I needed: **oci-java-sdk-ailanguage** and **oci-java-sdk-common**. This is what the dependencies sections looked like in my [pom.xml](pom.xml): +For the sample in this directory, I relied on Maven get the libraries I needed: **oci-java-sdk-ailanguage** , **oci-java-sdk-common** and **oci-java-sdk-common-httpclient-jersey**. This is what the dependencies sections looked like in my [pom.xml](pom.xml): ```xml com.oracle.oci.sdk oci-java-sdk-ailanguage - 2.12.0 + LATEST com.oracle.oci.sdk oci-java-sdk-common LATEST + + + com.oracle.oci.sdk + oci-java-sdk-common-httpclient-jersey + LATEST + + ``` And this is what the imports looked like: @@ -54,6 +62,11 @@ In order for your local code to have the rights to use your OCI services, it nee new ConfigFileAuthenticationDetailsProvider(configFile); ``` +OCI SDK provides some other Authentication methods as well and sample for these methods can found below in links below. +* Instance Principal Authentication - https://github.com/oracle/oci-java-sdk/blob/master/bmc-examples/src/main/java/InstancePrincipalsAuthenticationDetailsProviderExample.java +* Resource Principal Authentication - https://github.com/oracle/oci-java-sdk/blob/master/bmc-examples/src/main/java/FunctionsEphemeralResourcePrincipalAuthenticationDetailsProviderExample.java +* Simple Authentication - https://github.com/oracle/oci-java-sdk/blob/master/bmc-examples/src/main/java/SimpleAuthenticationDetailsProviderExample.java + ## Using OCI Language from Java Essentially, we just need to create a language client to issue the calls, prepare a request with its dependent object, and then send a request to the client, as shown in Steps 2,3 and 4 in the [Java sample code](https://github.com/oracle/oci-data-science-ai-samples/tree/master/ai_services/language/java/src/main/java/com/company). diff --git a/ai_services/language/java/src/main/java/com/company/Main.java b/ai_services/language/java/src/main/java/com/company/Main.java index da529567..17a4cca7 100644 --- a/ai_services/language/java/src/main/java/com/company/Main.java +++ b/ai_services/language/java/src/main/java/com/company/Main.java @@ -1,7 +1,6 @@ package com.company; import com.oracle.bmc.ConfigFileReader; -import com.oracle.bmc.auth.AuthenticationDetailsProvider; -import com.oracle.bmc.auth.ConfigFileAuthenticationDetailsProvider; +import com.oracle.bmc.auth.*; import com.oracle.bmc.ailanguage.AIServiceLanguageClient; import com.oracle.bmc.ailanguage.model.*; import com.oracle.bmc.ailanguage.requests.*; @@ -9,60 +8,372 @@ import java.io.IOException; +import java.net.ConnectException; +import java.net.SocketTimeoutException; import java.util.ArrayList; import java.util.Arrays; +import java.util.List; +import java.util.stream.Collectors; public class Main { + private static AIServiceLanguageClient client; + public static void main(String[] args) { try { - /* Step 1: Just reading a config file with my credentials so the application acts on my behalf */ - final ConfigFileReader.ConfigFile configFile = - ConfigFileReader.parse("", "DEFAULT"); + String text = "Zoom interface is really simple and easy to use. The learning curve is very short thanks to the interface. It is very easy to share the Zoom link to join the video conference. Screen sharing quality is just ok. Zoom now claims to have 300 million meeting participants per day. It chose Oracle Corporation co-founded by Larry Ellison and headquartered in Redwood Shores , for its cloud infrastructure deployments over the likes of Amazon, Microsoft, Google, and even IBM to build an enterprise grade experience for its product. The security feature is significantly lacking as it allows people to zoom bomb"; + String englishLanguageCode = "en"; + + Main aiServiceLanguageExample = new Main(); - final AuthenticationDetailsProvider provider = - new ConfigFileAuthenticationDetailsProvider(configFile); + /* Step 1: Authentication */ + AuthenticationDetailsProvider provider = aiServiceLanguageExample.authenticateWithConfigFile(); + //InstancePrincipalsAuthenticationDetailsProvider provider = aiServiceLanguageExample.authenticateWithServicePrincipal(); + //ResourcePrincipalAuthenticationDetailsProvider provider = aiServiceLanguageExample.authenticateWithResourcePrincipal(); + //AuthenticationDetailsProvider provider = aiServiceLanguageExample.authenticateWithSimpleAuthentication(args); /* Step 2: Create a service client */ - AIServiceLanguageClient client = AIServiceLanguageClient.builder().build(provider); + client = AIServiceLanguageClient.builder().build(provider); + + /* Single Documents APIs */ + DetectLanguageSentimentsResult sentimentsResult = aiServiceLanguageExample.getLanguageSentiments(text); + DetectLanguageEntitiesResult entitiesResult = aiServiceLanguageExample.getLanguageEntities(text); + DetectDominantLanguageResult dominantLanguageResult = aiServiceLanguageExample.getDominantLanguage(text); + DetectLanguageKeyPhrasesResult keyPhrasesResult = aiServiceLanguageExample.getLanguageKeyPhrases(text); + DetectLanguageTextClassificationResult textClassificationResult = aiServiceLanguageExample.getLanguageTextClassification(text); - /* Step 3: Sample of single record API */ - DetectDominantLanguageDetails detectdominantLanguageDetails = - DetectDominantLanguageDetails.builder() - .text("Este es un texto en el idioma de mi madre, la mejor mamá del mundo.").build(); + aiServiceLanguageExample.printSentiments(sentimentsResult); + aiServiceLanguageExample.printEntities(entitiesResult); + aiServiceLanguageExample.printLanguageType(dominantLanguageResult); + aiServiceLanguageExample.printKeyPhrases(keyPhrasesResult); + aiServiceLanguageExample.printTextClassification(textClassificationResult); - DetectDominantLanguageRequest detectDominantLanguageRequest = DetectDominantLanguageRequest.builder() - .detectDominantLanguageDetails(detectdominantLanguageDetails) - .opcRequestId("Just-some-unique-id") - .build(); + /* Sample using more efficient batch APIs */ + getTranslatedText("El idioma español es muy facil de aprender.", "es", "en"); + BatchDetectLanguageSentimentsResult batchSentimentsResult = aiServiceLanguageExample.getLanguageBatchSentiments(text, englishLanguageCode); + BatchDetectLanguageEntitiesResult batchEntitiesResult = aiServiceLanguageExample.getLanguageBatchEntities(text, englishLanguageCode); + BatchDetectDominantLanguageResult batchDominantLanguageResult = aiServiceLanguageExample.getBatchDominantLanguage(text); + BatchDetectLanguageKeyPhrasesResult batchKeyPhrasesResult = aiServiceLanguageExample.getLanguageBatchKeyPhrases(text, englishLanguageCode); + BatchDetectLanguageTextClassificationResult batchTextClassificationResult = aiServiceLanguageExample.getLanguageBatchTextClassification(text, englishLanguageCode); - DetectDominantLanguageResponse response = client. - detectDominantLanguage(detectDominantLanguageRequest); + aiServiceLanguageExample.printBatchSentiments(batchSentimentsResult); + aiServiceLanguageExample.printBatchEntities(batchEntitiesResult); + aiServiceLanguageExample.printBatchLanguageType(batchDominantLanguageResult); + aiServiceLanguageExample.printBatchKPE(batchKeyPhrasesResult); + aiServiceLanguageExample.printBatchTextClass(batchTextClassificationResult); - System.out.println("Detected language: " + - response.getDetectDominantLanguageResult().getLanguages().get(0).getName()); + client.close(); + } + catch(IOException e) { + e.printStackTrace(); + } + } - /* Step 4: Sample using more efficient batch APIs */ - BatchLanguageTranslationDetails batchLanguageTranslationDetails = BatchLanguageTranslationDetails.builder() - .targetLanguageCode("en") - .documents(new ArrayList<>(Arrays.asList(TextDocument.builder() - .key("key1") - .text("El idioma español es muy facil de aprender.") - .languageCode("es").build()))).build(); + //https://github.com/oracle/oci-java-sdk/blob/master/bmc-examples/src/main/java/AuthenticationPolicyExample.java + // Configuring the AuthenticationDetailsProvider. It's assuming there is a default OCI + // config file + // "~/.oci/config", and a profile in that config with the name "DEFAULT". Make changes to + // the following + // line if needed and use ConfigFileReader.parse(configurationFilePath, profile); + private AuthenticationDetailsProvider authenticateWithConfigFile() throws IOException { + try { + // Uncomment below line and provide config file path if your config file is not at default location "~/.oci/config" + // final ConfigFileReader.ConfigFile configFile = + // ConfigFileReader.parse("", "DEFAULT"); + // final AuthenticationDetailsProvider provider = new ConfigFileAuthenticationDetailsProvider(configFile); - BatchLanguageTranslationRequest batchLanguageTranslationRequest = BatchLanguageTranslationRequest.builder() - .batchLanguageTranslationDetails(batchLanguageTranslationDetails) - .opcRequestId("EMFIG6AAEBVTRXALWQTC").build(); + return new ConfigFileAuthenticationDetailsProvider("DEFAULT"); + } catch (Exception e) { + e.printStackTrace(); + throw e; + } + } - /* Send request to the Client */ - BatchLanguageTranslationResponse response1 = client.batchLanguageTranslation(batchLanguageTranslationRequest); - System.out.println("Translation: " + response1.getBatchLanguageTranslationResult().getDocuments().get(0).getTranslatedText()); + //Using Instance Principal + //https://github.com/oracle/oci-java-sdk/blob/master/bmc-examples/src/main/java/InstancePrincipalsAuthenticationDetailsProviderExample.java + private InstancePrincipalsAuthenticationDetailsProvider authenticateWithServicePrincipal() { + final InstancePrincipalsAuthenticationDetailsProvider provider; + try { + provider = InstancePrincipalsAuthenticationDetailsProvider.builder().build(); + return provider; + } catch (Exception e) { + if (e.getCause() instanceof SocketTimeoutException + || e.getCause() instanceof ConnectException) { + System.out.println( + "This sample only works when running on an OCI instance. Are you sure you’re running on an OCI instance? For more info see: https://docs.cloud.oracle.com/Content/Identity/Tasks/callingservicesfrominstances.htm"); + return null; + } + throw e; + } + } + //https://github.com/oracle/oci-java-sdk/blob/master/bmc-examples/src/main/java/FunctionsEphemeralResourcePrincipalAuthenticationDetailsProviderExample.java + //Using Resource Principal + private ResourcePrincipalAuthenticationDetailsProvider authenticateWithResourcePrincipal() { + return ResourcePrincipalAuthenticationDetailsProvider.builder().build(); + } + //https://github.com/oracle/oci-java-sdk/blob/master/bmc-examples/src/main/java/SimpleAuthenticationDetailsProviderExample.java + //SimpleAuthenticationDetailsProvider + private AuthenticationDetailsProvider authenticateWithSimpleAuthentication(String[] args) { + if (args.length != 5) { + throw new IllegalArgumentException( + "This example expects five arguments: tenantId, userId, fingerprint, privateKey and passPhrase"); } - catch(IOException e) { - e.printStackTrace(); + + final String tenantId = args[0]; + final String userId = args[1]; + final String fingerprint = args[2]; + final String privateKey = args[3]; + final String passPhrase = args[4]; + + return SimpleAuthenticationDetailsProvider.builder() + .tenantId(tenantId) + .userId(userId) + .fingerprint(fingerprint) + .privateKeySupplier(new StringPrivateKeySupplier(privateKey)) + .passPhrase(passPhrase) + .build(); + } + + private BatchDetectLanguageSentimentsResult getLanguageBatchSentiments(String text, String languageCode) { + TextDocument sentimentsDocument = TextDocument.builder().key("doc1").text(text).languageCode(languageCode).build(); + java.util.List documents = Arrays.asList(sentimentsDocument); + BatchDetectLanguageSentimentsDetails sentimentsDetails = BatchDetectLanguageSentimentsDetails + .builder() + .documents(documents) + .build(); + BatchDetectLanguageSentimentsRequest request = BatchDetectLanguageSentimentsRequest + .builder() + .batchDetectLanguageSentimentsDetails(sentimentsDetails) + .build(); + BatchDetectLanguageSentimentsResponse response = client.batchDetectLanguageSentiments(request); + return response.getBatchDetectLanguageSentimentsResult(); + } + + private BatchDetectLanguageKeyPhrasesResult getLanguageBatchKeyPhrases(String text, String languageCode) { + TextDocument keyPhraseDocument = TextDocument.builder().key("doc1").text(text).languageCode(languageCode).build(); + java.util.List documents = Arrays.asList(keyPhraseDocument); + BatchDetectLanguageKeyPhrasesDetails keyPhrasesDetails = BatchDetectLanguageKeyPhrasesDetails.builder().documents(documents).build(); + BatchDetectLanguageKeyPhrasesRequest request = BatchDetectLanguageKeyPhrasesRequest.builder().batchDetectLanguageKeyPhrasesDetails(keyPhrasesDetails).build(); + BatchDetectLanguageKeyPhrasesResponse response = client.batchDetectLanguageKeyPhrases(request); + return response.getBatchDetectLanguageKeyPhrasesResult(); + } + + private BatchDetectLanguageTextClassificationResult getLanguageBatchTextClassification(String text, String languageCode) { + TextDocument textClassificationDocument = TextDocument.builder().key("doc1").text(text).languageCode(languageCode).build(); + java.util.List documents = Arrays.asList(textClassificationDocument); + BatchDetectLanguageTextClassificationDetails textClassificationDetails = BatchDetectLanguageTextClassificationDetails.builder().documents(documents).build(); + BatchDetectLanguageTextClassificationRequest request = BatchDetectLanguageTextClassificationRequest.builder().batchDetectLanguageTextClassificationDetails(textClassificationDetails).build(); + BatchDetectLanguageTextClassificationResponse response = client.batchDetectLanguageTextClassification(request); + return response.getBatchDetectLanguageTextClassificationResult(); + } + + private BatchDetectLanguageEntitiesResult getLanguageBatchEntities(String text, String languageCode) { + TextDocument entityDocument = TextDocument.builder().key("doc1").text(text).languageCode(languageCode).build(); + java.util.List documents = Arrays.asList(entityDocument); + BatchDetectLanguageEntitiesDetails entitiesDetails = BatchDetectLanguageEntitiesDetails.builder().documents(documents).build(); + BatchDetectLanguageEntitiesRequest request = BatchDetectLanguageEntitiesRequest.builder().batchDetectLanguageEntitiesDetails(entitiesDetails).build(); + BatchDetectLanguageEntitiesResponse response = client.batchDetectLanguageEntities(request); + return response.getBatchDetectLanguageEntitiesResult(); + } + + private BatchDetectDominantLanguageResult getBatchDominantLanguage(String text) { + DominantLanguageDocument dominantLanguageDocument = DominantLanguageDocument.builder().key("doc1").text(text).build(); + java.util.List documents = Arrays.asList(dominantLanguageDocument); + BatchDetectDominantLanguageDetails dominantLanguageDetails = BatchDetectDominantLanguageDetails.builder().documents(documents).build(); + BatchDetectDominantLanguageRequest request = BatchDetectDominantLanguageRequest.builder().batchDetectDominantLanguageDetails(dominantLanguageDetails).build(); + BatchDetectDominantLanguageResponse response = client.batchDetectDominantLanguage(request); + return response.getBatchDetectDominantLanguageResult(); + } + + private DetectLanguageSentimentsResult getLanguageSentiments(String text) { + DetectLanguageSentimentsDetails sentimentsDetails = DetectLanguageSentimentsDetails.builder().text(text).build(); + DetectLanguageSentimentsRequest request = DetectLanguageSentimentsRequest.builder().detectLanguageSentimentsDetails(sentimentsDetails).build(); + DetectLanguageSentimentsResponse response = client.detectLanguageSentiments(request); + return response.getDetectLanguageSentimentsResult(); + } + + private DetectLanguageEntitiesResult getLanguageEntities(String text) { + DetectLanguageEntitiesDetails entitiesDetails = DetectLanguageEntitiesDetails.builder().text(text).build(); + DetectLanguageEntitiesRequest request = DetectLanguageEntitiesRequest.builder().detectLanguageEntitiesDetails(entitiesDetails).build(); + DetectLanguageEntitiesResponse response = client.detectLanguageEntities(request); + return response.getDetectLanguageEntitiesResult(); + } + + private DetectDominantLanguageResult getDominantLanguage(String text) { + DetectDominantLanguageDetails languageDetails = DetectDominantLanguageDetails.builder().text(text).build(); + DetectDominantLanguageRequest request = DetectDominantLanguageRequest.builder().detectDominantLanguageDetails(languageDetails).build(); + DetectDominantLanguageResponse response = client.detectDominantLanguage(request); + return response.getDetectDominantLanguageResult(); + } + + private DetectLanguageKeyPhrasesResult getLanguageKeyPhrases(String text) { + DetectLanguageKeyPhrasesDetails keyPhrasesDetails = DetectLanguageKeyPhrasesDetails.builder().text(text).build(); + DetectLanguageKeyPhrasesRequest request = DetectLanguageKeyPhrasesRequest.builder().detectLanguageKeyPhrasesDetails(keyPhrasesDetails).build(); + DetectLanguageKeyPhrasesResponse response = client.detectLanguageKeyPhrases(request); + return response.getDetectLanguageKeyPhrasesResult(); + } + + private DetectLanguageTextClassificationResult getLanguageTextClassification(String text) { + DetectLanguageTextClassificationDetails textClassificationDetails = DetectLanguageTextClassificationDetails.builder().text(text).build(); + DetectLanguageTextClassificationRequest request = DetectLanguageTextClassificationRequest.builder().detectLanguageTextClassificationDetails(textClassificationDetails).build(); + DetectLanguageTextClassificationResponse response = client.detectLanguageTextClassification(request); + return response.getDetectLanguageTextClassificationResult(); + } + + private static void getTranslatedText(String text, String sourceLanguageCoce, String targetLanguageCode) { + BatchLanguageTranslationDetails batchLanguageTranslationDetails = BatchLanguageTranslationDetails.builder() + .targetLanguageCode(targetLanguageCode) + .documents(new ArrayList<>(Arrays.asList(TextDocument.builder() + .key("key1") + .text(text) + .languageCode(sourceLanguageCoce).build()))).build(); + + BatchLanguageTranslationRequest batchLanguageTranslationRequest = BatchLanguageTranslationRequest.builder() + .batchLanguageTranslationDetails(batchLanguageTranslationDetails) + .opcRequestId("EMFIG6AAEBVTRXALWQTC").build(); + + BatchLanguageTranslationResponse response1 = client.batchLanguageTranslation(batchLanguageTranslationRequest); + System.out.println("Translation: " + response1.getBatchLanguageTranslationResult().getDocuments().get(0).getTranslatedText()); + } + + private void printBatchSentiments(BatchDetectLanguageSentimentsResult result) { + if (result.getDocuments() != null && result.getDocuments().size() > 0) { + SentimentDocumentResult documentResult = result.getDocuments().get(0); + List aspects = documentResult.getAspects(); + String printFormat = "%s [%s - %s]"; + System.out.println(); + System.out.println("========= Language Batch Aspect Based Sentiment ========"); + aspects.forEach(aspect -> System.out.println(String.format(printFormat, aspect.getText(), aspect.getSentiment(), aspect.getScores()))); + System.out.println("========= End ========"); + System.out.println(); + } + + if (result.getErrors() != null && result.getErrors().size() > 0) { + System.out.println("========= Language Batch Aspect Based Sentiment Error========"); + System.out.println(result.getErrors().get(0).getError().getMessage()); + System.out.println("========= End ========"); + } + } + + private void printBatchEntities(BatchDetectLanguageEntitiesResult result) { + if (result.getDocuments() != null && result.getDocuments().size() > 0) { + EntityDocumentResult documentResult = result.getDocuments().get(0); + List entities = documentResult.getEntities(); + String printFormat = "%s [%s]"; + System.out.println("========= Batch Entities ========"); + entities.forEach(entity -> System.out.println(String.format(printFormat, entity.getText(), entity.getType()))); + System.out.println("========= End ========"); + System.out.println(); + } + + if (result.getErrors() != null && result.getErrors().size() > 0) { + System.out.println("========= Language Batch Entity Error========"); + System.out.println(result.getErrors().get(0).getError().getMessage()); + System.out.println("========= End ========"); + } + } + + private void printBatchKPE(BatchDetectLanguageKeyPhrasesResult result) { + if (result.getDocuments() != null && result.getDocuments().size() > 0) { + KeyPhraseDocumentResult documentResult = result.getDocuments().get(0); + List keyPhrases = documentResult.getKeyPhrases(); + System.out.println("========= Language Batch Key Phrases ========"); + List keyPhrasesStr = keyPhrases.stream().map(keyPhrase -> keyPhrase.getText()+ " ("+keyPhrase.getScore()+")").collect(Collectors.toList()); + System.out.println(String.join(",", keyPhrasesStr)); + System.out.println("========= End ========"); + System.out.println(); + } + + if (result.getErrors() != null && result.getErrors().size() > 0) { + System.out.println("========= Language Batch Key Phrases Error========"); + System.out.println(result.getErrors().get(0).getError().getMessage()); + System.out.println("========= End ========"); } } + + private void printBatchTextClass(BatchDetectLanguageTextClassificationResult result) { + if (result.getDocuments() != null && result.getDocuments().size() > 0) { + TextClassificationDocumentResult documentResult = result.getDocuments().get(0); + List textClassifications = documentResult.getTextClassification(); + String printFormat = "%s (%s)"; + System.out.println("========= Language Batch Text Classification ========"); + textClassifications.forEach(textClassification -> System.out.println(String.format(printFormat, textClassification.getLabel(), textClassification.getScore()))); + System.out.println("========= End ========"); + System.out.println(); + } + + if (result.getErrors() != null && result.getErrors().size() > 0) { + System.out.println("========= Language Batch Text Classification Error========"); + System.out.println(result.getErrors().get(0).getError().getMessage()); + System.out.println("========= End ========"); + } + } + + private void printBatchLanguageType(BatchDetectDominantLanguageResult result) { + if (result.getDocuments() != null && result.getDocuments().size() > 0) { + DominantLanguageDocumentResult documentResult = result.getDocuments().get(0); + List languages = documentResult.getLanguages(); + System.out.println("========= Batch Dominant Language ========"); + List languagesStr = languages.stream().map(language -> language.getName()+ " ("+language.getScore()+")").collect(Collectors.toList()); + System.out.println(String.join(",", languagesStr)); + System.out.println("========= End ========"); + System.out.println(); + } + + if (result.getErrors() != null && result.getErrors().size() > 0) { + System.out.println("========= Batch Dominant Language Error========"); + System.out.println(result.getErrors().get(0).getError().getMessage()); + System.out.println("========= End ========"); + } + } + + private void printSentiments(DetectLanguageSentimentsResult result) { + List aspects = result.getAspects(); + String printFormat = "%s [%s - %s]"; + + System.out.println(); + System.out.println("========= Language Aspect Based Sentiment ========"); + aspects.forEach(aspect -> System.out.println(String.format(printFormat, aspect.getText(), aspect.getSentiment(), aspect.getScores()))); + System.out.println("========= End ========"); + System.out.println(); + } + + private void printEntities(DetectLanguageEntitiesResult result) { + List entities = result.getEntities(); + String printFormat = "%s [%s]"; + System.out.println("========= Entities ========"); + entities.forEach(entity -> System.out.println(String.format(printFormat, entity.getText(), entity.getType()))); + System.out.println("========= End ========"); + System.out.println(); + } + + private void printLanguageType(DetectDominantLanguageResult result) { + System.out.println("========= Dominant Language ========"); + List languages = result.getLanguages(); + List languagesStr = languages.stream().map(language -> language.getName()+ " ("+language.getScore()+")").collect(Collectors.toList()); + System.out.println(String.join(",", languagesStr)); + System.out.println("========= End ========"); + System.out.println(); + } + + private void printKeyPhrases(DetectLanguageKeyPhrasesResult result) { + List keyPhrases = result.getKeyPhrases(); + System.out.println("========= Language Key Phrases ========"); + List keyPhrasesStr = keyPhrases.stream().map(keyPhrase -> keyPhrase.getText()+ " ("+keyPhrase.getScore()+")").collect(Collectors.toList()); + System.out.println(String.join(",", keyPhrasesStr)); + System.out.println("========= End ========"); + System.out.println(); + } + + private void printTextClassification(DetectLanguageTextClassificationResult result) { + List textClassifications = result.getTextClassification(); + String printFormat = "%s (%s)"; + System.out.println("========= Language Topic Labels & Related Words ========"); + System.out.println("========= Language Topic Labels ========"); + textClassifications.forEach(textClassification -> System.out.println(String.format(printFormat, textClassification.getLabel(), textClassification.getScore()))); + System.out.println("========= End ========"); + } } diff --git a/ai_services/language/python/authenticationMethods.py b/ai_services/language/python/authenticationMethods.py new file mode 100644 index 00000000..bf50642f --- /dev/null +++ b/ai_services/language/python/authenticationMethods.py @@ -0,0 +1,41 @@ +import oci + +def authenticateWithConfigFile(): + # It's assuming there is a default OCI config file "~/.oci/config", and a profile in that config with the name "DEFAULT" + # Default config file and profile + default_config = oci.config.from_file() + + ai_client = oci.ai_language.AIServiceLanguageClient(default_config) + + return ai_client + +# https://github.com/oracle/oci-python-sdk/blob/master/examples/resource_principals_example.py +def authenticateWithResourcePrincipal(): + # Create a Response Pricipals signer + print("=" * 80) + print("Intializing new signer") + rps = oci.auth.signers.get_resource_principals_signer() + + # Print the Resource Principal Security Token + # This step is not required to use the signer, it just shows that the security + # token can be retrieved from the signer. + print("=" * 80) + print("Resource Principal Security Token") + print(rps.get_security_token()) + + # Note that the config is passed in as an empty dictionary. A populated config + # is not needed when using a Resource Principals signer + ai_client = oci.ai_language.AIServiceLanguageClient({}, signer=rps) + + return ai_client + +# https://github.com/oracle/oci-python-sdk/blob/master/examples/instance_principals_examples.py +def authenticateWithInstancePrincipal(): + # By default this will hit the auth service in the region returned by http://169.254.169.254/opc/v2/instance/region on the instance. + signer = oci.auth.signers.InstancePrincipalsSecurityTokenSigner() + + # In the base case, configuration does not need to be provided as the region and tenancy are obtained from the InstancePrincipalsSecurityTokenSigner + ai_client = oci.identity.IdentityClient(config={}, signer=signer) + + return ai_client + diff --git a/ai_services/language/python/languagebatchdemo.py b/ai_services/language/python/languagebatchdemo.py index f146639a..023a9474 100644 --- a/ai_services/language/python/languagebatchdemo.py +++ b/ai_services/language/python/languagebatchdemo.py @@ -40,7 +40,7 @@ def fill_aspect_sentiment(Data): max_batch_record = 100 for idx in range(Data[column_name_review].size): - record = oci.ai_language.models.SentimentsDocument(text=Data.iat[idx, Data.columns.get_loc(column_name_review)][0:1000], + record = oci.ai_language.models.TextDocument(text=Data.iat[idx, Data.columns.get_loc(column_name_review)][0:1000], key=str(Data.index[idx]), language_code="en") record_chars = len(record.text) diff --git a/ai_services/language/python/languagebatchsamples.py b/ai_services/language/python/languagebatchsamples.py new file mode 100644 index 00000000..e82ffca3 --- /dev/null +++ b/ai_services/language/python/languagebatchsamples.py @@ -0,0 +1,68 @@ +import oci +from authenticationMethods import * + +key1 = "doc1" +key2 = "doc2" +text1 = "The Indy Autonomous Challenge is the worlds first head-to-head, high speed autonomous race taking place at the Indianapolis Motor Speedway" +text2 = "Using high-performance GPU systems in the Oracle Cloud, OCI will be the cloud engine for the artificial intelligence models that drive the MIT Driverless cars competing in the Indy Autonomous Challenge." +text3 = "OCI ha realizado con éxito la transición de Renault para ejecutar sus cargas de trabajo de computación de alto rendimiento (HPC) de producción en OCI. Específicamente, las cargas de trabajo para Crash Simulation usando PAM-CRASH, ya han superado el rendimiento local anterior en un 19 %. Se trata de un logro importante, ya que la mejora del rendimiento permite a Renault realizar cientos de simulaciones aerodinámicas y de colisión más al año, lo que da como resultado vehículos más seguros y con un consumo de combustible más eficiente. Renault es la tercera victoria automotriz más grande para OCI, extendiendo el alcance de OCI para cubrir los tres mercados automotrices más grandes: EE. UU., APAC y EMEA." + +ai_client = authenticateWithConfigFile() +# ai_client = authenticateWithResourcePrincipal() +# ai_client = authenticateWithInstancePrincipal() + +compartment_id = "ocid1.tenancy.oc1..aaaaaaaaih4krf4od5g2ym7pffbp6feof3rx64522aoxxvv3iuw3tam6fvea" +# compartment_id = "" + +language_code = "en" + +# Batch Detect Dominant Language +doc1 = oci.ai_language.models.DominantLanguageDocument(key=key1, text=text1) +doc2 = oci.ai_language.models.DominantLanguageDocument(key=key2, text=text2) +documents = [doc1, doc2] +batch_detect_dominant_language_details = oci.ai_language.models.BatchDetectDominantLanguageDetails(documents=documents, + compartment_id=compartment_id) +output = ai_client.batch_detect_dominant_language(batch_detect_dominant_language_details) +print(output.data) + +doc1 = oci.ai_language.models.TextDocument(key=key1, text=text1, language_code=language_code) +doc2 = oci.ai_language.models.TextDocument(key=key2, text=text3, language_code=language_code) +documents = [doc1, doc2] + +# Batch Text Classification +batch_detect_language_text_classification_details = oci.ai_language.models.BatchDetectLanguageTextClassificationDetails( + documents=documents, compartment_id=compartment_id) +output = ai_client.batch_detect_language_text_classification(batch_detect_language_text_classification_details) +print(output.data) + +# Batch Named Entity Recoginiton +batch_detect_language_entities_details = oci.ai_language.models.BatchDetectLanguageEntitiesDetails(documents=documents, + compartment_id=compartment_id) +output = ai_client.batch_detect_language_entities(batch_detect_language_entities_details) +print(output.data) + +# Batch Key Phrase Detection +batch_detect_language_key_phrases_details = oci.ai_language.models.BatchDetectLanguageKeyPhrasesDetails( + documents=documents, compartment_id=compartment_id) +output = ai_client.batch_detect_language_key_phrases(batch_detect_language_key_phrases_details) +print(output.data) + +# Aspect based and Sentence level Sentiment Analysis +batch_detect_language_sentiment_details = oci.ai_language.models.BatchDetectLanguageSentimentsDetails( + documents=documents, compartment_id=compartment_id) +output = ai_client.batch_detect_language_sentiments(batch_detect_language_sentiment_details, + level=["ASPECT", "SENTENCE"]) +print(output.data) + +# Language Translation +doc1 = oci.ai_language.models.TextDocument(key=key1, text=text1, language_code=language_code) +doc2 = oci.ai_language.models.TextDocument(key=key2, text=text2, language_code=language_code) +documents = [doc1, doc2] + +batch_language_translation_details = oci.ai_language.models.BatchLanguageTranslationDetails(documents=documents, + compartment_id=compartment_id, + target_language_code="de") +output = ai_client.batch_language_translation(batch_language_translation_details) +print(output.data) + +