Comment utiliser les services Google Cloud Machine Learning pour Android

Les nouvelles de nos jours regorgent de mots à la mode tels que l’automatisation, l’intelligence artificielle et l’apprentissage automatique. C’est probablement pourquoi de plus en plus d’utilisateurs de smartphones commencent à rechercher des applications plus intelligentes. En tant que développeur d’applications Android régulier, cependant, vous n’avez probablement pas les ressources nécessaires pour créer de telles applications à partir de zéro.

Heureusement, Google a récemment lancé un Cloud Machine Learning plate-forme, qui offre des réseaux de neurones qui ont été pré-formés pour effectuer une variété de tâches. La plupart de ses modèles sont non seulement très précis, mais s’améliorent constamment. Et devine quoi? Vous pouvez les utiliser en effectuant simplement quelques appels d’API REST!

Dans ce didacticiel, je vais vous présenter la plateforme Cloud Machine Learning et vous montrer comment l’utiliser pour créer une application Android intelligente capable de reconnaître des objets du monde réel et de les nommer dans plusieurs langues.

Conditions préalables

Pour tirer le meilleur parti de ce tutoriel, tout ce dont vous avez besoin est:

• la dernière version de Studio Android
• un appareil exécutant Android 4.4 ou supérieur
• et un Google Cloud Platform Compte

1. Acquérir une clé API

Pour pouvoir utiliser les services d’apprentissage automatique de Google dans votre application Android, vous avez besoin d’une clé API. Vous pouvez en obtenir un en créant un nouveau projet dans Google Cloud Platform console.

Commencez par vous connecter à la console et appuyez sur le Créer un nouveau projet bouton. Dans la boîte de dialogue qui apparaît, donnez un nom significatif au projet.

Une fois le projet créé, accédez à Gestionnaire d’API> Tableau de bord et appuyez sur le Activer l’API bouton.

Dans l’écran suivant, sous le Google Cloud Machine Learning en-tête, vous pourrez voir toutes les différentes API d’apprentissage automatique disponibles. Dans ce didacticiel, nous n’utiliserons que le Vision et Traduction Apis.

Pour activer l’API Vision, cliquez sur son lien et appuyez sur le bouton Activer bouton.

De même, pour activer l’API Translation, cliquez sur son lien et appuyez sur le bouton Activer bouton.

Vous n’aurez besoin que d’une seule clé pour utiliser les deux API. Pour l’obtenir, rendez-vous au Identifiants onglet, appuyez sur Créer des identifiants et sélectionnez Clé API.

Vous devriez maintenant voir une fenêtre contextuelle contenant votre clé API secrète.

2. Créer un nouveau projet Android

Lancez Android Studio et créez un nouveau projet avec une activité vide. Je vous suggère de choisir au moins le niveau d’API 19 pour le SDK minimum pris en charge.

Bien que ce ne soit pas obligatoire, il est toujours judicieux d’utiliser une bibliothèque réseau robuste pour communiquer avec la plate-forme Google Cloud Machine Learning. Dans ce didacticiel, nous utiliserons une de ces bibliothèques appelée Carburant. Ajoutez-le en tant que compile dépendance dans le app modules build.gradle fichier:

compile 'com.github.kittinunf.fuel:fuel-android:1.5.0'

presse Synchroniser maintenant pour mettre à jour votre projet.

Ensuite, notre application aura besoin du INTERNET l’autorisation de communiquer avec les serveurs de Google. Par conséquent, ajoutez la ligne suivante dans le fichier manifeste du projet:

<uses-permission android:name="android.permission.INTERNET"/>

Enfin, ajoutez votre clé API au values ​​/ strings.xml fichier:

<string name="mykey">ABCDEF12345-abcdef12345-123</string>

3. Utilisation de l’API Vision

L’API Vision vous aide à créer des applications qui peuvent voir et donner un sens à l’environnement de l’utilisateur. La détection des visages, la détection des émotions, la reconnaissance optique des caractères et l’annotation d’images font partie de ses nombreuses fonctionnalités. Pour l’instant, nous allons nous concentrer uniquement sur la puissante fonction d’annotation d’image, également appelée détection d’étiquettes, qui, à mon avis, est très utile.

Comme vous pouvez vous y attendre, l’API attend une image comme l’une de ses entrées. Par conséquent, créons maintenant un écran où l’utilisateur peut prendre des photos à l’aide de l’appareil photo de l’appareil.

Étape 1: créer une mise en page

La disposition de notre écran doit avoir un Button widget sur lequel l’utilisateur peut appuyer pour prendre une photo, un ImageView widget pour afficher l’image, et un TextView widget pour afficher les étiquettes, ou annotations, générées par l’API. En conséquence, ajoutez le code suivant au fichier XML de mise en page de votre activité:

<Button android:text="Take a picture"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:id="@+id/takePictureButton"
    android:onClick="takePicture"/>

<ImageView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_below="@id/takePictureButton"
    android:id="@+id/previewImage"
    android:layout_centerHorizontal="true"/>

<TextView
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:id="@+id/resultsText"
    android:layout_below="@id/previewImage"/>

Notez que nous avons associé un onClick gestionnaire avec le bouton. Nous le définirons à l’étape suivante.

Étape 2: créer une intention

En créant une nouvelle intention avec le ACTION_IMAGE_CAPTURE action et en la passant au startActivityForResult() méthode, vous pouvez demander à l’application appareil photo par défaut de l’appareil de l’utilisateur de prendre des photos et de les transmettre à votre application. Par conséquent, ajoutez le code suivant à votre Activity classe:

public final static int MY_REQUEST_CODE = 1;

public void takePicture(View view) {
    Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
    startActivityForResult(intent, MY_REQUEST_CODE);
}

Pour recevoir les images capturées par l’application de caméra par défaut, vous devez remplacer le onActivityResult() méthode de votre Activity classe. À l’intérieur de la méthode, vous aurez accès à un Bundle objet contenant toutes les données d’image. Vous pouvez rendre les données d’image en les convertissant simplement en un Bitmap et en le passant au ImageView widget.

@Override
protected void onActivityResult(int requestCode, int resultCode,
                                Intent data) {
    if(requestCode == MY_REQUEST_CODE && resultCode == RESULT_OK) {

        // Convert image data to bitmap
        Bitmap picture = (Bitmap)data.getExtras().get("data");

        // Set the bitmap as the source of the ImageView
        ((ImageView)findViewById(R.id.previewImage))
                                .setImageBitmap(picture);

        // More code goes here
    }
}

Si vous exécutez l’application maintenant et prenez une photo, vous verrez que la taille de l’image est assez petite. C’est très bien, cependant: l’API Cloud Vision est très précise, même avec des miniatures d’image.

Étape 3: codez l’image

L’API Vision ne peut pas utiliser Bitmap objets directement. Au lieu de cela, il attend une chaîne codée en Base64 de données d’image compressées.

Pour compresser les données d’image, vous pouvez utiliser le compress() méthode de la Bitmap classe. En tant qu’arguments, la méthode attend le format de compression à utiliser, la qualité de sortie souhaitée et un ByteArrayOutputStream objet. Le code suivant compresse le bitmap à l’aide du format JPEG et s’assure également que la qualité de l’image résultante est suffisamment élevée:

ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
picture.compress(Bitmap.CompressFormat.JPEG, 90, byteStream);

Vous pouvez maintenant générer la chaîne Base64 en utilisant le encodeToString() méthode de la Base64 classe.

String base64Data = Base64.encodeToString(byteStream.toByteArray(), 
                                          Base64.URL_SAFE);

Étape 4: Traitez l’image

Après tout ce dur travail, vous disposez de tout ce dont vous avez besoin pour interagir avec l’API Vision. Commencez par créer une chaîne contenant à la fois l’URL de l’API et votre clé API:

String requestURL = 
        "https://vision.googleapis.com/v1/images:annotate?key=" +
         getResources().getString(R.string.mykey);

Pour envoyer des données à l’API, vous devez créer une requête HTTP POST. Le corps de la demande doit être un document JSON contenant les données d’image encodées en Base64. Pour la détection d’étiquettes, le document doit également avoir un features tableau contenant la valeur LABEL_DETECTION. Voici le format du document JSON:

{"requests": [{
      "image": {
        "content": <Base64-encoded image data>
      },
      "features": [{
          "type": "LABEL_DETECTION"
      }]
}]}

Bien qu’il soit possible de coder manuellement le document JSON, sa création par programme est moins sujette aux erreurs. Le code suivant vous montre comment le faire en utilisant le JSONObject et JSONArray Des classes:

// Create an array containing
// the LABEL_DETECTION feature
JSONArray features = new JSONArray();
JSONObject feature = new JSONObject();
feature.put("type", "LABEL_DETECTION");
features.put(feature);

// Create an object containing
// the Base64-encoded image data
JSONObject imageContent = new JSONObject();
imageContent.put("content", base64Data);

// Put the array and object into a single request
// and then put the request into an array of requests
JSONArray requests = new JSONArray();
JSONObject request = new JSONObject();
request.put("image", imageContent);
request.put("features", features);
requests.put(request);
JSONObject postData = new JSONObject();
postData.put("requests", requests);

// Convert the JSON into a
// string
String body = postData.toString();

À ce stade, nous pouvons utiliser le post() méthode de la Fuel classe pour effectuer la requête HTTP POST. Comme seul argument, la méthode attend l’URL de l’API. Vous devez également inclure le content-length et content-type en-têtes dans la requête. Pour ce faire, utilisez le header() méthode. De même, pour ajouter le document JSON au corps de la requête POST, utilisez le post() méthode.

Enfin, en appelant le responseString() méthode et en passant une nouvelle instance de Handler classe, vous pouvez obtenir de manière asynchrone la réponse de la requête sous forme de chaîne. En conséquence, ajoutez le code suivant:

Fuel.post(requestURL)
    .header(
        new Pair<String, Object>("content-length", body.length()),
        new Pair<String, Object>("content-type", "application/json")
        )
    .body(body.getBytes())
    .responseString(new Handler<String>() {
        @Override
        public void success(@NotNull Request request,
                            @NotNull Response response,
                            String data) {
            // More code goes here
        }

        @Override
        public void failure(@NotNull Request request,
                            @NotNull Response response,
                            @NotNull FuelError fuelError) {}
    });

Lorsque vous utilisez la fonction de détection d’étiquettes, l’API Vision renvoie un document JSON contenant des étiquettes. En plus de chaque étiquette, vous obtenez également un score précisant la précision de l’étiquette. Le document ressemble à ceci:

{"responses":[{
  "labelAnnotations": [
    {
      "mid": "/m/id1",
      "description": "label1",
      "score": 0.91
    },
    {
      "mid": "/m/id2",
      "description": "label2",
      "score": 0.90
    },
  ...
}]}

Pour l’instant, parcourons en boucle tous les objets du labelAnnotations tableau et ajoutez la valeur de chaque description clé de la TextView widget de notre mise en page. Voici comment vous pouvez faire cela dans le success() méthode de la Handler classe:

// Access the labelAnnotations arrays
JSONArray labels = new JSONObject(data)
                    .getJSONArray("responses")
                    .getJSONObject(0)
                    .getJSONArray("labelAnnotations");

String results = "";

// Loop through the array and extract the
// description key for each item
for(int i=0;i<labels.length();i++) {
    results = results + 
              labels.getJSONObject(i).getString("description") +
              "n";
}

// Display the annotations inside the TextView
((TextView)findViewById(R.id.resultsText)).setText(results);

Vous pouvez maintenant exécuter l’application, prendre une photo de n’importe quel objet à proximité et voir les étiquettes que l’API Vision génère pour lui.

4. Utilisation de l’API Translation

L’API Cloud Translation, comme son nom l’indique, peut traduire du texte vers et depuis plus de 100 langues. En l’utilisant efficacement, vous pouvez créer des applications intelligentes capables de communiquer avec vos utilisateurs dans leur propre langue.

À l’étape précédente, vous avez vu que les étiquettes générées par notre application sont en anglais. Ajoutons-y maintenant un bouton pour traduire ces étiquettes en allemand.

Étape 1: mettre à jour la mise en page

Ajouter un Button widget vers la fin de la mise en page de votre activité en utilisant le code suivant:

<Button
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:layout_below="@+id/resultsText"
    android:text="in German"
    android:onClick="translateToGerman"/>

Notez que ce bouton a également un onClick gestionnaire d’événements qui doit être défini dans votre Activity classe.

Étape 2: Traduire les étiquettes

L’utilisation de l’API Translation est beaucoup plus simple que celle de l’API Vision, principalement parce que vous n’avez pas besoin de créer un document JSON pour définir votre demande. Au lieu de cela, vous pouvez simplement lui passer des paramètres dans une chaîne de requête.

Créer le translateToGerman() et, à l’intérieur, créez une chaîne contenant l’URL de l’API de traduction.

public void translateToGerman(View view) {
    String requestURL = 
        "https://translation.googleapis.com/language/translate/v2";

    // More code goes here
}

Pour ajouter des champs à la chaîne de requête de l’URL ci-dessus, nous pouvons utiliser un List de Pair objets. Les champs suivants sont importants:

• key, en spécifiant votre clé API secrète
• source, en spécifiant la langue à partir de laquelle vous souhaitez traduire
• target, en spécifiant la langue dans laquelle vous souhaitez traduire
• q, en spécifiant le texte que vous souhaitez traduire

Le code suivant vous montre comment configurer l’API pour traduire de l’anglais vers l’allemand:

List<Pair<String, String>> params = new ArrayList<>();
// Add API key
params.add(new Pair<String, String>("key", 
                        getResources().getString(R.string.mykey)));

// Set source and target languages
params.add(new Pair<String, String>("source", "en"));
params.add(new Pair<String, String>("target", "de"));

Parce que la chaîne de requête peut contenir plusieurs q champs, nous en ajouterons un pour chaque étiquette présente dans notre mise en page TextView widget. Voici comment:

String[] queries = ((TextView)findViewById(R.id.resultsText))
                    .getText().toString().split("n");

for(String query:queries) {
    params.add(new Pair<String, String>("q", query));
}

Enfin, vous pouvez appeler le get() méthode de la Fuel classe pour envoyer une requête HTTP GET à l’API Translation. Cette fois aussi, vous pouvez utiliser le responseString() pour obtenir la réponse de manière asynchrone sous forme de chaîne.

Fuel.get(requestURL, params).responseString(new Handler<String>() {
    @Override
    public void success(@NotNull Request request, 
                        @NotNull Response response,
                        String data) {
        // More code here
    }

    @Override
    public void failure(@NotNull Request request, 
                        @NotNull Response response, 
                        @NotNull FuelError fuelError) { }
});

La réponse de l’API Translation est un document JSON contenant un tableau de traductions. Il a le format suivant:

{ "data": { "translations": [
  {
    "translatedText": "...."
  },
  {
    "translatedText": "...."
  },
  ...
] } }

Pour l’instant, à l’intérieur du success() méthode de la Handler classe, parcourons simplement le translations tableau du document JSON ci-dessus et mettez à jour le contenu du TextView widget utilisant les valeurs associées au translatedText clés.

// Access the translations array
JSONArray translations = new JSONObject(data)
                        .getJSONObject("data")
                        .getJSONArray("translations");

// Loop through the array and extract the translatedText
// key for each item
String result = "";
for(int i=0;i<translations.length();i++) {
    result += translations.getJSONObject(i)
                .getString("translatedText") + "n";
}

// Update the contents of the TextView widget
((TextView)findViewById(R.id.resultsText)).setText(result);

Si vous exécutez l’application maintenant, générez des étiquettes pour une image et appuyez sur le deuxième bouton, vous devriez pouvoir voir les étiquettes en allemand.

Conclusion

Dans ce didacticiel, vous avez appris à utiliser les API Cloud Vision et Cloud Translation, qui font partie de la plateforme Google Cloud Machine Learning, dans une application Android. Il existe de nombreuses autres API de ce type proposées par la plate-forme. Vous pouvez en savoir plus à leur sujet en vous référant au documentation officielle.

Pendant que vous êtes ici, consultez certains de nos autres didacticiels sur la façon d’utiliser l’apprentissage automatique et les services cloud dans vos applications Android!