Scenario<\/h3>\n
In our recent engagement with Vectorform<\/a>, we built a simple Android application that allows a user to obtain a\u00a0food’s nutritional values based on a photo of that food.\u00a0 To make this scenario simpler, we will assume that the target photo has either a single food item in it or that the user will indicate the food item in question.<\/p>\n The main functionality of the app (image recognition) is powered by Custom Vision, where we will detect what the item is: for example, an apple or a tomato. Once we know what the food is, our goal of finding nutritional info from publicly available services is easy.<\/p>\n To put it simply, Custom Vision\u00a0is the younger sibling of Microsoft’s\u00a0Computer Vision API<\/a> with one\u00a0big difference: in Custom Vision, you can fine-tune a predictive model to the dataset at hand (hence the “Custom” part). Custom Vision\u00a0utilizes the concept of Transfer Learning<\/a>, a method in which a powerful pre-trained model (ResNet, AlexNet) is taught to pay more attention to the distinctive features seen in user-provided dataset and classes.<\/p>\n Obtaining labeled data for our app took several hours.\u00a0 We wanted to use food pictures taken by real people (not stock photos) and to have 100-200 images per class.\u00a0 Flickr<\/a> has quite a variety of client-side tools that allow image search and bulk download. Search results, however, were not 100% accurate and required a bit of cleanup (like removing a few photos of dogs and kids from a\u00a0dataset representing the food class “cupcake”).<\/p>\n Once the data was downloaded (one image class per folder) it was split into train and test subsets. This is an optional step that you can take if you desire a more detailed evaluation of model performance.<\/p>\n We created the script prepareTrainTestImages.py<\/em><\/a>\u00a0 to partition the data into\u00a03\/4 for training and 1\/4 for testing.<\/p>\n Now let’s go to CustomVision.ai<\/a>\u00a0and try training different food classification models. When doing this for the first time you may want to use this overview<\/a> as a\u00a0point of reference.<\/p>\n We will try building a few models, starting with a super simple model with 5 classes, then expanding the model to classify 14 types of food. Next, we will see if grouping the classes is helpful in improving prediction accuracy.<\/p>\n To get started, we’ll begin by classifying the following foods. For the purposes of this example, we’ll select foods that are visually distinct from each other:<\/p>\n Creating a classification model in CSV is easy:<\/p>\n Once the model is trained, the statistics below are displayed in the Custom Vision\u00a0portal for each iteration. We had pretty good model performance out of the box with both precision and recall exceeding 90%! Precision metrics tell us the percentage of correct predictions for a given image. Recall measures how much a classifier can detect (what percentage of the apples in the test were classified as such).<\/p>\n Custom Vision\u00a0introduces\u00a0a \u201cProbability Threshold\u201d slider (we used the default value of 90%) that is used to calculate Precision and Recall. When interpreting the predictions you get a probability per tag; for example,\u00a0the probability that picture A contains an apple is 95%. \u00a0If the probability threshold is 90%, then this example will be taken into consideration as a “correct prediction”. \u00a0Depending on your application needs, you may want to set a higher\/lower probability threshold.<\/p>\n By going to the “Training Images” tab, you can view the images that confused the model. Some “cake” samples below were incorrectly classified as “sandwich”. And honestly, they do resemble a sandwich a bit. To get a more detailed analysis of how each class performs, we have created a script that will send test images to the model endpoint and evaluate results. See evalWebservice.py<\/em><\/a> (in the\u00a0GitHub repository<\/a>).<\/p>\n The script expects a CSV file with two columns as input.\u00a0 Column 1 should have a path to test the image. Column 2 should have the name of a true class (matching the exact “tag” name in the Custom Vision\u00a0UI). To run the script again, modify your endpoint\/key accordingly.<\/p>\n Once the script is done testing the endpoint, the following table will display: This visualization is called a\u00a0Confusion Matrix<\/a>; items on the diagonal are cases where the model’s prediction is correct (that is, 95 images were predicted to be sandwiches and they were in fact sandwiches). In\u00a0our model, train and test images contain one type of food and when interpreting Custom Vision\u00a0predictions and building Confusion Matrix we focus on the one with the highest probability.<\/p>\n The numbers that are off the main diagonal show where the model made classification mistakes. Nine bananas were incorrectly classified as cakes, and seven cakes as sandwiches.\u00a0 Those mistakes give us good insight that the color and the texture-rich variety of cakes make it quite complex for the model to learn the requisite class features; as a result, this class is\u00a0easy to confuse with something else.<\/p>\n In this console output of evalWebservice.py<\/em><\/a>,\u00a0 we see that “apples” are the most correctly predicted food (with high precision, high recall and thus high F1-score).<\/a>\u00a0 “Cake” has the lowest precision: only 86% present of “cake” predictions were correct (comparing to the glorious 90%+ for other classes).<\/p>\n Our 5-class model did reasonably well and it took us only a\u00a0few minutes to train! \u00a0Most of the time was spent uploading the images.<\/p>\n If we expand the model, adding nine more food classes, let’s see what happens.<\/p>\n In our first iteration, we purposefully provided classes of food items with quite different appearances. Now, we will be providing some similar-looking foods to see how well the Custom Vision-based model can distinguish items like apples vs. tomatoes (both are round, shiny, often red objects), cakes vs. cupcakes vs. ice cream (colorful, varied textures), sandwiches vs. burgers (different types of bread\/buns). Despite the variety of items this time, we’ll give Custom Vision\u00a0only 100-300 training images per class. Again, our images are mostly amateur photography and of varied quality. \u00a0For a\u00a0very simple model, you could try an even smaller amount of training data.<\/p>\n Here are the results of training this model with 14 classes (ouch!):<\/p>\n <\/p>\n As the classifier is shown a larger variety of classes (some of which are very tricky!) it starts making more mistakes.<\/p>\n Let’s look at the Confusion Matrix to understand where the classifier is making most of its mistakes.<\/p>\n As we can see “tomato” has a splendid recall (out of 99 tomatoes in test set, 98 were correctly classified). However, the precision of the “tomato” class is damaged by the addition of “bellpepper”. A similar situation exists with “sandwich” and “burger”. “Fries”, “greenSalad” and “cans”, however, are performing quite well.<\/p>\n If we look at the columns of the Confusion Matrix we can see that the “iceCream” class is leading the board as the class that other items are most often confused with. We can see 24 bananas were incorrectly\u00a0classified as “iceCream” (do we have lots of white-yellow ice cream in the training set?), as well as 31 cakes and 44 cupcakes (probably because cupcakes and ice cream cones often have similar swirly tops).<\/p>\n Now let’s deal with some of the problematic classes. We’ll do this by creating a layered model, in which we use two models to address the problematic classes.<\/p>\n We’ll let the uber-model\u00a0determine if something falls into the general sandwich-burger food type. Then we’ll make an additional call to a specialized small model that was trained only on 2 classes: #1 Sandwich, and #2 Burger. We’ll do the same with the tomato-bell pepper case.<\/p>\n <\/p>\n Let’s train the uber-model first (where we combined several foods together).<\/p>\n Note: we’re using the same train and test images, and just grouping them differently.<\/em><\/p>\n After training, we see a definite boost in overall Precision and Recall for the model: 8% in precision and 4.5% in the recall.<\/p>\n Now let’s train Layer 2 models for tomatoes vs. bell peppers and sandwiches vs. burgers and see how\u00a0the classification performance is.<\/p>\n There is definitely an improvement!<\/p>\n Previously, \u00a0most of the bell peppers (36 out of 49) were classified as tomatoes and 0 bell peppers were classified correctly. In the layered model, we are starting to get correct predictions for bell peppers. \u00a0It’s quite fascinating, especially if we remember that we’re training on the same set of images!<\/p>\n As an observation, since the uber-model in Layer 1 has combined the classes of tomatoes and bell peppers (mostly red, somewhat round, glossy objects), some of the “apples” started to get misclassified as the class “belltomato”. That’s understandable, as a red apple does look similar to a tomato. Adding more data to the classes or maybe creating a “belltomatapple” class may be helpful in the next iteration.<\/p>\n With sandwiches and burgers, there is also a positive trend. In the original iteration, zero burger predictions were made, and pretty much all burgers were incorrectly classified as sandwiches. In the layered model, we had 39 correct burger predictions.<\/p>\n A layered model approach is only one of many options to consider to improve model’s performance. Increasing the number of train images and further refinement of image quality are definitely worth trying as well.<\/p>\n To demonstrate the full power of the Custom Vision\u00a0classification we built, we created a mobile application on Android that would capture a food-related image, hit our endpoint to determine what food is pictured in the image, use the Nutritionix service to get nutritional information about that food, then display the results to the user.<\/p>\n The app provides several ways to capture an image for use:<\/p>\n Once we were done with adding support for classifying food items via the Custom Vision\u00a0endpoint in the Android application, we used a nutrition API that provides relevant nutritional information about the image sent to the Custom Vision\u00a0endpoint. \u00a0In this demo, we leveraged the Nutritionix Nutrition API<\/a>.<\/p>\n In the following sections, we will describe and show the code for the integration\/consumption of the Custom Vision\u00a0endpoint.<\/p>\n Below is an example of how you can call Microsoft\u2019s Custom Vision\u00a0using Java on an Android app.<\/p>\n The snippet below requires an API endpoint from the Microsoft Custom Vision.<\/p>\n Here we declare the required user permissions, application activities, and application services.<\/p>\n At the top of our Main file, we declare our Custom Vision\u00a0endpoint as well as the Nutritionix endpoint (using a custom string formatter)<\/p>\n In order to get the results from our Async Background API calls, BroadcastReceivers are created and configured for each service (Custom Vision\u00a0API & Nutritionix API).<\/p>\n In order to call the Custom Vision\u00a0Endpoint, we build a RequestPackage either with the image URL provided or the device image, converted to a byteArray, and then set the request method to “POST”.<\/p>\n After packaging that RequestPackage object into our intent, which we constructed from the Custom Vision\u00a0Class (IrisService.class<\/em>), we can then start the service. When the result from that API call is returned, it will be received by the The static helper method\u00a0 In order to successfully make the HTTP request,\u00a0an Custom Vision Service brings domain-specific Deep Neural Network-powered image recognition to your fingertips. Building a quick proof of concept app with a handful of classes is very simple. You can also easily make a prediction endpoint to experiment with, which works well in domains where the\u00a0number of classes is finite and the visual appearances of those classes are distinct. Simplicity comes with a\u00a0cost, however, as you can customize the training data, but not the algorithms. Additionally, as we’ve seen in this post, closely related classes need to be specifically addressed with techniques like layered models.<\/p>\n Nevertheless, Custom Vision\u00a0is suitable for a broad range of domains. For example, you could use this technique to detect\u00a0items in a customer’s online cart, recognize UI elements, pre-filter images into categories to simplify further analyses, and so on.<\/p>\n The code for this example is available in our GitHub repository<\/a>.<\/p>\n Custom Vision Service official documentation, overview and tutorials \u00a0are here<\/a>.<\/p>\n Cover image from Unsplash<\/a>, used under CC0 license<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":" How we created an app to identify foods and their nutritional content by using the new Custom Vision Service to leverage domain-specific image recognition powered by DNNs.<\/p>\n","protected":false},"author":21373,"featured_media":10981,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[19],"tags":[42,139,206,250,259],"class_list":["post-2935","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-machine-learning","tag-android","tag-custom-vision-service","tag-image","tag-microsoft-cognitive-services","tag-mobile"],"acf":[],"blog_post_summary":" How we created an app to identify foods and their nutritional content by using the new Custom Vision Service to leverage domain-specific image recognition powered by DNNs.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/ise\/wp-json\/wp\/v2\/posts\/2935","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/ise\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/ise\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/ise\/wp-json\/wp\/v2\/users\/21373"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/ise\/wp-json\/wp\/v2\/comments?post=2935"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/ise\/wp-json\/wp\/v2\/posts\/2935\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/ise\/wp-json\/wp\/v2\/media\/10981"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/ise\/wp-json\/wp\/v2\/media?parent=2935"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/ise\/wp-json\/wp\/v2\/categories?post=2935"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/ise\/wp-json\/wp\/v2\/tags?post=2935"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}What is Custom Vision Service?<\/h2>\n
Obtaining\u00a0the data<\/h2>\n
Training the model<\/h2>\n
Tiny model<\/h3>\n
\n
\n
![\"Precision](\"https:\/\/devblogs.microsoft.com\/cse\/wp-content\/uploads\/sites\/55\/2020\/03\/5classes_PR.png\")
<\/p>\n![\"misclassified](\"https:\/\/devblogs.microsoft.com\/cse\/wp-content\/uploads\/sites\/55\/2017\/05\/cake_sandw.png\")
<\/p>\n![\"Confusion](\"https:\/\/devblogs.microsoft.com\/cse\/wp-content\/uploads\/sites\/55\/2017\/05\/3.png\")
<\/p>\n![\"Precision,](\"https:\/\/devblogs.microsoft.com\/cse\/wp-content\/uploads\/sites\/55\/2017\/05\/4.png\")
<\/p>\nBigger model<\/h2>\n
\n
![\"Precision](\"https:\/\/devblogs.microsoft.com\/cse\/wp-content\/uploads\/sites\/55\/2017\/05\/5-1.png\")
<\/p>\n![\"\"](\"https:\/\/devblogs.microsoft.com\/cse\/wp-content\/uploads\/sites\/55\/2017\/05\/6-1.png\")
<\/p>\n“Layered” Model<\/h2>\n
![\"Layered](\"https:\/\/devblogs.microsoft.com\/cse\/wp-content\/uploads\/sites\/55\/2017\/05\/7.png\")
<\/p>\n![\"Confusion](\"https:\/\/devblogs.microsoft.com\/cse\/wp-content\/uploads\/sites\/55\/2017\/05\/8.png\")
<\/p>\nAndroid App<\/h2>\n
\n
![\"App](\"https:\/\/devblogs.microsoft.com\/cse\/wp-content\/uploads\/sites\/55\/2017\/05\/app_home_screenshot.png\")
<\/p>\nCode<\/h3>\n
AndoridManifest.xml<\/h3>\n
<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<manifest xmlns:android=\"http:\/\/schemas.android.com\/apk\/res\/android\"\r\n package=\"com.claudiusmbemba.irisdemo\">\r\n\r\n <uses-feature\r\n android:name=\"android.hardware.camera\"\r\n android:required=\"true\" \/>\r\n\r\n <uses-permission android:name=\"android.permission.INTERNET\" \/>\r\n <uses-permission android:name=\"android.permission.ACCESS_NETWORK_STATE\" \/>\r\n <uses-permission android:name=\"android.permission.CAMERA\" \/>\r\n <uses-permission android:name=\"android.permission.WRITE_EXTERNAL_STORAGE\" \/>\r\n\r\n <application\r\n android:allowBackup=\"true\"\r\n android:icon=\"@mipmap\/ic_launcher\"\r\n android:label=\"@string\/app_name\"\r\n android:roundIcon=\"@mipmap\/ic_launcher_round\"\r\n android:supportsRtl=\"true\"\r\n android:theme=\"@style\/AppTheme\">\r\n <activity\r\n android:name=\".MainActivity\"\r\n android:label=\"@string\/app_name\"\r\n android:theme=\"@style\/AppTheme.NoActionBar\">\r\n <intent-filter>\r\n <action android:name=\"android.intent.action.MAIN\" \/>\r\n\r\n <category android:name=\"android.intent.category.LAUNCHER\" \/>\r\n <\/intent-filter>\r\n <\/activity>\r\n\r\n <service\r\n android:name=\".services.IrisService\"\r\n android:exported=\"false\" \/>\r\n\r\n <activity android:name=\".NutritionActivity\" \/>\r\n\r\n <service\r\n android:name=\".services.NutritionixService\"\r\n android:exported=\"false\" \/>\r\n <\/application>\r\n\r\n<\/manifest><\/pre>\n
Main.java<\/h3>\n
# Variable declarations\r\n ... (removed for brevity)\r\n \/\/TODO: CHANGE ME!!\r\n private final String ENDPOINT = \"your-cvs-endpoint-url\";\r\n private final String NUTRI_ENDPOINT = \"https:\/\/api.nutritionix.com\/v1_1\/search\/%s\";\r\n public static final String FOOD_RESULT = \"FOOD_RESULT\";\r\n public static final String NUTRITION_RESULT = \"NUTRITION_RESULT\";\r\n public static final String IRIS_REQUEST = \"IRIS_REQUEST\";\r\n ... (removed for brevity)<\/pre>\n
BroadcastReceivers<\/h3>\n
private BroadcastReceiver irisReceiver = new BroadcastReceiver() {\r\n @Override\r\n public void onReceive(Context context, final Intent intent) {\r\n\r\n runOnUiThread(new Runnable() {\r\n @Override\r\n public void run() {\r\n if (intent.getExtras().containsKey(IrisService.IRIS_SERVICE_ERROR)) {\r\n String msg = intent.getStringExtra(IrisService.IRIS_SERVICE_ERROR);\r\n resultTV.setText(msg);\r\n Toast.makeText(getApplicationContext(), msg, Toast.LENGTH_SHORT).show();\r\n } else if (intent.getExtras().containsKey(IrisService.IRIS_SERVICE_PAYLOAD)) {\r\n IrisData irisData = (IrisData) intent\r\n .getParcelableExtra(IrisService.IRIS_SERVICE_PAYLOAD);\r\n food_result = irisData.getClassifications().get(0);\r\n clearText();\r\n String msg = String.format(\"I'm %.0f%% confident that this is a %s \\n\", food_result.getProbability() * 100, food_result.getClass_());\r\n resultTV.append(msg);\r\n\r\n for (int i = 0; i < irisData.getClassifications().size(); i++) {\r\n Log.i(TAG, \"onReceive: \" + irisData.getClassifications().get(i).getClass_());\r\n }\r\n requestNutritionInfo();\r\n }\r\n }\r\n });\r\n\r\n }\r\n };\r\n\r\n private BroadcastReceiver nutritionixReceiver = new BroadcastReceiver() {\r\n @Override\r\n public void onReceive(Context context, Intent intent) {\r\n if (intent.getExtras().containsKey(NutritionixService.NUTRITION_SERVICE_ERROR)) {\r\n String msg = intent.getStringExtra(NutritionixService.NUTRITION_SERVICE_ERROR);\r\n Toast.makeText(getApplicationContext(), msg, Toast.LENGTH_SHORT).show();\r\n } else if (intent.getExtras().containsKey(NutritionixService.NUTRITION_SERVICE_PAYLOAD)) {\r\n NutritionixData results = (NutritionixData) intent.getParcelableExtra(NutritionixService.NUTRITION_SERVICE_PAYLOAD);\r\n nutritionixHit = results.getHits().get(0);\r\n nutritionButton.setEnabled(true);\r\n }\r\n }\r\n };<\/pre>\nHitting the Custom Vision Endpoint<\/h3>\n
irisReceiver<\/code> BroadcastReceiver mentioned above.<\/p>\n private void requestIrisService(final String type) {\r\n\r\n final Bitmap croppedImage = image.getCroppedImage();\r\n\r\n AsyncTask.execute(new Runnable() {\r\n @Override\r\n public void run() {\r\n RequestPackage requestPackage = new RequestPackage();\r\n Intent intent = new Intent(MainActivity.this, IrisService.class);\r\n requestPackage.setParam(IRIS_REQUEST, \"IRIS\");\r\n\r\n if (type.equals(URL)) {\r\n requestPackage.setEndPoint(String.format(ENDPOINT, URL));\r\n requestPackage.setParam(\"Url\", urlText.getText().toString());\r\n } else if (type.equals(IMAGE)) {\r\n ByteArrayOutputStream stream = new ByteArrayOutputStream();\r\n croppedImage.compress(Bitmap.CompressFormat.JPEG, 50, stream);\r\n byte[] byteArray = stream.toByteArray();\r\n Log.d(TAG, \"requestIrisService: byte array size = \" + byteArray.length);\r\n requestPackage.setEndPoint(String.format(ENDPOINT, IMAGE));\r\n intent.putExtra(IrisService.REQUEST_IMAGE, byteArray);\r\n }\r\n\r\n requestPackage.setMethod(\"POST\");\r\n intent.putExtra(IrisService.REQUEST_PACKAGE, requestPackage);\r\n\r\n try {\r\n startService(intent);\r\n } catch (Exception e) {\r\n runOnUiThread(new Runnable() {\r\n @Override\r\n public void run() {\r\n resultTV.setVisibility(View.GONE);\r\n Toast.makeText(getApplicationContext(), \"Image too large.\", Toast.LENGTH_LONG).show();\r\n }\r\n });\r\n\r\n e.printStackTrace();\r\n }\r\n }\r\n });\r\n }<\/pre>\nHelpers\/HttpHelper.java<\/h3>\n
Making the Http Request<\/h4>\n
makeRequest()<\/code>\u00a0below is called by the service class IrisService.class<\/code>. It\u00a0passes in the RequestPackage mentioned above and an optional InputStream (if using an image).<\/p>\nOkHttpClient<\/code> client object is constructed and a Request.Builder<\/code> is configured with the Custom Vision\u00a0predictionKey passed as a request header. Then, the client is used to execute the request. Eventually, it returns a successful stringified response body or throws a caught error if something went wrong.<\/p>\npublic static String makeRequest(RequestPackage requestPackage, InputStream data)\r\n throws Exception {\r\n\r\n String address = requestPackage.getEndpoint();\r\n\r\n OkHttpClient client = new OkHttpClient();\r\n\r\n Request.Builder requestBuilder = new Request.Builder();\r\n\r\n iris = (requestPackage.getParams().containsKey(MainActivity.IRIS_REQUEST)) ? true : false;\r\n\r\n if (requestPackage.getMethod().equals(\"POST\")) {\r\n RequestBody requestBody = null;\r\n if (iris) {\r\n \/\/TODO: CHANGE ME!!\r\n requestBuilder.addHeader(\"Prediction-Key\",\"a5427...\");\r\n if (requestPackage.getParams().containsKey(\"Url\")) {\r\n requestBuilder.addHeader(\"Content-Type\",\"application\/json\");\r\n JSONObject json = new JSONObject(requestPackage.getParams());\r\n requestBody = RequestBody.create(MediaType.parse(\"application\/json; charset=utf-8\"), String.valueOf(json));\r\n } else {\r\n if (data != null) {\r\n requestBuilder.addHeader(\"Content-Type\",\"application\/octet-stream\");\r\n requestBody = RequestBodyUtil.create(MediaType.parse(\"application\/octet-stream; charset=utf-8\"), data);\r\n } else {\r\n throw new Exception(\"No image data found\");\r\n }\r\n }\r\n } else {\r\n MultipartBody.Builder builder = new MultipartBody.Builder()\r\n .setType(MultipartBody.FORM);\r\n Map<String, String> params = requestPackage.getParams();\r\n for (String key : params.keySet()) {\r\n builder.addFormDataPart(key, params.get(key));\r\n }\r\n requestBody = builder.build();\r\n }\r\n requestBuilder.method(\"POST\", requestBody);\r\n } else if (requestPackage.getMethod().equals(\"GET\")) {\r\n address = String.format(\"%s?%s\", address, requestPackage.getEncodedParams());\r\n }\r\n\r\n requestBuilder.url(address);\r\n\r\n Request request = requestBuilder.build();\r\n Response response = client.newCall(request).execute();\r\n if (response.isSuccessful()) {\r\n return response.body().string();\r\n } else {\r\n throw new IOException(\"Exception: response code \" + response.code());\r\n }\r\n }<\/pre>\nScreenshots<\/h2>\n
![\"Making](\"https:\/\/devblogs.microsoft.com\/cse\/wp-content\/uploads\/sites\/55\/2017\/05\/app_thinking_screenshot.png\")
<\/p>\n![\"CVS](\"https:\/\/devblogs.microsoft.com\/cse\/wp-content\/uploads\/sites\/55\/2017\/05\/app_result_screenshot.png\")
<\/p>\n![\"Cropping](\"https:\/\/devblogs.microsoft.com\/cse\/wp-content\/uploads\/sites\/55\/2017\/05\/app_cropper_screenshot.png\")
<\/p>\n<\/h2>\n
Conclusions<\/h2>\n
Additional Information<\/h2>\n
\n