Forem: Brandon Minnick

Android Image Classification with TensorFlow Lite & Azure Custom Vision Service

Brandon Minnick — Thu, 09 Apr 2020 20:59:09 +0000

This is a guest blog by Daniel Hindrikes. Daniel is a Microsoft MVP, Speaker, and Xamarin + Cloud Solution Architect at tretton37

Image Classification allows our Xamarin apps to recognize objects in a photo.

Being able to take a photo and recognize its contents is becoming more and more common. We experience it in our banking apps when making a mobile deposit, in our photo apps when adding filters, and in our HotDog apps to determine whether or not our meal is a hotdog.

Thanks to Azure Custom Vision Service, we don't have to learn complex machine learning algorithms to implement image classification.

This article will walkthrough how to implement it using Azure's Custom Vision Service, TensorFlow Lite (an open source machine learning platform) and Xamarin.Android.

Note: For Xamarin.iOS, we can also use Azure's Custom Vision Service with CoreML, but we'll save that for another blog post.

Image Classification Libraries

We'll be leveraging Azure Custom Vision Service and TensorFlow Lite to implement our image classification.

1. Azure Custom Vision Service

Azure's Custom Vision Service makes it easy to create and train machine learning models - no previous Artificial Intelligence (AI) or Machine Learning (ML) experience is necessary.

Using the Custom Vision Service Web Portal, we can do the following without writing any AI/ML code:

Upload a training image
Tag / Label the object(s) in the image
Repeat (the model gets better with more training data)
That's it - Custom Vision Service takes care of the rest!

2. TensorFlow Lite

TensorFlow Lite is an open source machine learning platform that allows us to use TensorFlow on IoT and Mobile devices.

Both TensoryFlow Lite and TensorFlow are completely open-source on GitHub.

Implementing Image Classification with Azure + Xamarin.Android

The completed Image Classification sample app is available here on GitHub: https://github.com/dhindrik/MushroomDetector/

1. Training the Model

Using the Custom Vision Service Web Portal, we will first train models for image classification.

1) In the Custom Vision Service Web Portal, click New Project

2) In the Create new project window, make the following selections:

Name: XamarinImageClassification
Description: Identify Objects in Images
Resource: [Create a new resource]
Project Type: Classification
Classification Types: Multilabel (Multiple tags per image)
Domains: General (compact)
Export Capabilities: Basic platforms

3) In the Create new project window, click Create project

4) In the XamarinImageClassification window, click Add images

5) Select images that contain the object to identify

6) In the Image Upload window, add a tag

Note: In this example, we are tagging images of mushrooms

7) In the Image upload window, click Upload

Note: Continue uploading images until you have at least 5 images for each tag

8) In the XamarinImageClassification window, in the top-right of the window, click the Train Model button (the green image of gears)

9) In the Choose Training Type window, select Quick Training

10) In the Choose Training Type window, select Train

2. Export Trained Models from Azure Custom Vision Service

Now that we've trained our model, let's export it for use in our mobile app.

This allows us to use the model without an internet connection which improves the user's privacy because their photos will never leave their mobile device.

To export our model, lets do the following:

1) On the XamarinImageClassifcation window, on the top of the page, select the Performance tab

2) On The Performance tab, tap the Export button (the downward-pointing arrow)

3) On the Choose your platform window, select TensorFlow

4) In the Choose your platform dropdown, select TensorFlow Lite

5) In the Choose your platform window, select Download

3. Import TensorFlowLite into our Xamarin.Android App

1) In our Xamarin.Android project, install the TensorFlow Lite NuGet Package

Note: This NuGet Package is an open-source project created by the Xamarin team at Microsoft. It contains C# bindings for the orginal TensorFlow Lite library which makes it possible to use in our Xamarin.Android app

2) Unzip the exported model that we downloaded from the Custom Vision Service Web Portal

Note: Inside the zip-file, are labels.txt and model.tflite:

labels.txt contains the image tags created during the training preparation at the Custom Vision website

models.tflite is the machine learning model that we use to make our predictions

3) In Visual Studio, in the Xamarin.Android project, right-click on the Assets folder

4) On the right-click menu, select Add > Existing Item...

5) In the Add Existing Item menu, select both of the recently unzipped files:

models.tflite
labels.txt

6) In Visual Studio, in the Xamarin.Android > Assets folder, right-click on labels.txt

7) In the right-click menu, select Properties

8) In the Properties window, select Build Action > Android Asset

9) In Visual Studio, in the Xamarin.Android > Assets folder, right-click on models.tflite

10) In the right-click menu, select Properties

11) In the Properties window, select Build Action > Android Asset

4. Implement Image Classification Code for Xamarin.Android

Now that we've imported the model, it is time to write code.

The completed Image Classification sample app is available here on GitHub: https://github.com/dhindrik/MushroomDetector/

In the Xamarin.Android project, add both ImageClassifcationModel.cs and TensorflowClassifier.cs:

ImageClassificationModel.cs

public class ImageClassificationModel 
{ 
    public ImageClassificationModel(string tagName, float probability) 
    { 
        TagName = tagName; 
        Probability = probability; 
    } 

    public float Probability { get; } 
    public string TagName { get; } 
}

TensorflowClassifier.cs

using System.Collections.Generic;
using System.IO;
using System.Linq;
using Android.App;
using Android.Graphics;
using Java.IO;
using Java.Nio;
using Java.Nio.Channels;

public class TensorflowClassifier
{
    //FloatSize is a constant with the value of 4 because a float value is 4 bytes
    const int FloatSize = 4;
    //PixelSize is a constant with the value of 3 because a pixel has three color channels: Red Green and Blue
    const int PixelSize = 3;

    public List<ImageClassificationModel> Classify(byte[] image)
    {
        var mappedByteBuffer = GetModelAsMappedByteBuffer();
        var interpreter = new Xamarin.TensorFlow.Lite.Interpreter(mappedByteBuffer);

        //To resize the image, we first need to get its required width and height
        var tensor = interpreter.GetInputTensor(0);
        var shape = tensor.Shape();

        var width = shape[1];
        var height = shape[2];

        var byteBuffer = GetPhotoAsByteBuffer(image, width, height);

        //use StreamReader to import the labels from labels.txt
        var streamReader = new StreamReader(Application.Context.Assets.Open("labels.txt"));

        //Transform labels.txt into List<string>
        var labels = streamReader.ReadToEnd().Split('\n').Select(s => s.Trim()).Where(s => !string.IsNullOrEmpty(s)).ToList();

        //Convert our two-dimensional array into a Java.Lang.Object, the required input for Xamarin.TensorFlow.List.Interpreter
        var outputLocations = new float[1][] { new float[labels.Count] };
        var outputs = Java.Lang.Object.FromArray(outputLocations);

        interpreter.Run(byteBuffer, outputs);
        var classificationResult = outputs.ToArray<float[]>();

        //Map the classificationResult to the labels and sort the result to find which label has the highest probability
        var classificationModelList = new List<ImageClassificationModel>();

        for (var i = 0; i < labels.Count; i++)
        {
            var label = labels[i]; classificationModelList.Add(new ImageClassificationModel(label, classificationResult[0][i]));
        }

        return classificationModelList;
    }

    //Convert model.tflite to Java.Nio.MappedByteBuffer , the require type for Xamarin.TensorFlow.Lite.Interpreter
    private MappedByteBuffer GetModelAsMappedByteBuffer()
    {
        var assetDescriptor = Application.Context.Assets.OpenFd("model.tflite");
        var inputStream = new FileInputStream(assetDescriptor.FileDescriptor);

        var mappedByteBuffer = inputStream.Channel.Map(FileChannel.MapMode.ReadOnly, assetDescriptor.StartOffset, assetDescriptor.DeclaredLength);

        return mappedByteBuffer;
    }

    //Resize the image for the TensorFlow interpreter
    private ByteBuffer GetPhotoAsByteBuffer(byte[] image, int width, int height)
    {
        var bitmap = BitmapFactory.DecodeByteArray(image, 0, image.Length);
        var resizedBitmap = Bitmap.CreateScaledBitmap(bitmap, width, height, true);

        var modelInputSize = FloatSize * height * width * PixelSize;
        var byteBuffer = ByteBuffer.AllocateDirect(modelInputSize);
        byteBuffer.Order(ByteOrder.NativeOrder());

        var pixels = new int[width * height];
        resizedBitmap.GetPixels(pixels, 0, resizedBitmap.Width, 0, 0, resizedBitmap.Width, resizedBitmap.Height);

        var pixel = 0;

        //Loop through each pixels to create a Java.Nio.ByteBuffer
        for (var i = 0; i < width; i++)
        {
            for (var j = 0; j < height; j++)
            {
                var pixelVal = pixels[pixel++];

                byteBuffer.PutFloat(pixelVal >> 16 & 0xFF);
                byteBuffer.PutFloat(pixelVal >> 8 & 0xFF);
                byteBuffer.PutFloat(pixelVal & 0xFF);
            }
        }

        bitmap.Recycle();

        return byteBuffer;
    }
}

That's it! Now we can pass an image into TensorflowClassifier.Classify to retrieve our ImageClassificationModel.

Learn More

Check out the links below:

Introducing GitTrends: GitHub Insights

Brandon Minnick — Mon, 02 Mar 2020 21:12:28 +0000

iOS	Android

I am so excited to release GitTrends on Product Hunt today! https://www.producthunt.com/posts/gittrends-github-insights

GitTrends helps you to monitor your GitHub Repositories:
✅ Connect to GitHub
✅ Monitor GitHub Repo Views
✅ Monitor GitHub Repo Clones
✅ Discover Referring Sites

I created GitTrends because I love contributing to open source libraries, but I had trouble keeping track of which repos were receiving traffic and which ones were not. For example, I recently discovered that a repo I hadn't updated in +2 years was still getting 10-20 views per week.

All of the code is totally open source on GitHub and I absolutely welcome new feature requests and PRs!

📝 Leave us a comment on Product Hunt
⭐️ Open a Feature Request on GitHub

GitHub Login	Repo Traffic	Referring Sites

Resources

Mobile App

Xamarin - build native apps for Android, iOS, and macOS using .NET code and platform-specific user interfaces
Xamarin.Essentials - provides cross-platform APIs for their mobile applications
Xamarin.Forms - an open-source UI framework to build Android, iOS, and Windows applications from a single shared codebase
AppCenter - continuously build, test, release, and monitor mobile apps
AsyncAwaitBestPractices - Extensions for System.Threading.Tasks.Task
Autofac - an IoC container for .NET
Debug Rainbows - Xamarin.Forms UI layout tool
HTML Agility Pack - an agile HTML parser that builds a read/write DOM and supports plain XPATH or XSLT
Polly - .NET resilience and transient-fault-handling library that allows developers to express policies such as Retry, Circuit Breaker, Timeout, Bulkhead Isolation, and Fallback in a fluent and thread-safe manner
Refit - Refit is a REST library for .NET that converts REST APIs into live interfaces
Sqlite-net - an open source, minimal library to allow .NET, .NET Core, and Mono applications to store data in SQLite 3 databases
Syncfusion - a UI Component Suite for Building Powerful Web, Desktop, and Mobile Apps

Cloud Backend

.NET Core - an open-source, general-purpose development platform maintained by Microsoft and the .NET community on GitHub
Azure Functions - a serverless compute service that lets you run event-triggered code without having to explicitly provision or manage infrastructure
Azure Functions Dependency Injection - Azure Functions supports the dependency injection (DI) software design pattern, which is a technique to achieve Inversion of Control (IoC) between classes and their dependencies
Polly + HttpClientFactory - the recommended approach for retries with exponential backoff is to take advantage of more advanced .NET libraries
Refit + HttpClientFactory - IHttpClientFactory can be used in combination with third-party libraries such as Refit

Xamarin: Efficiently Using a SQLite Database

Brandon Minnick — Thu, 20 Feb 2020 22:06:46 +0000

The most popular SQLite ORM for Xamarin is SQLite-net. Let's explore the most efficient way to use it in our apps!

If you'd like to skip to the completed code, jump to Section 9: Put It All Together.

A completed sample app using this implementation is also available here: https://github.com/brminnick/GitTrends

1. Locate the App Data Directory

Both iOS and Android have a specific/unique file directory for each app, and this is where we'll store the .db3 database file. We can easily locate it using Xamarin.Essentials.FileSystem.

Note: Be sure to first add the Xamarin.Essentials NuGet Package and follow its Getting Started Instructions.

static readonly string _databasePath = Path.Combine(Xamarin.Essentials.FileSystem.AppDataDirectory, "SqliteDatabase.db3");

2. Use SQLiteOpenFlags

SQLite-net offers an asynchronous API, SQLiteAsyncConnection. This allows us to use async/await when performing database operations.

SQLite also offers a few different options when creating a database connection using SQLiteOpenFlags, and here are the ones I recommend:

SQLiteOpenFlags.ReadWrite
- "The database is opened for reading and writing if possible, or reading only if the file is write protected by the operating system"
SQLiteOpenFlags.Create
- "[The database] is created if it does not already exist"
SQLiteOpenFlags.SharedCache
- Allows for multi-threaded database access
- "When a thread establishes multiple connections to the same database, the connections share a single data and schema cache. This can significantly reduce the quantity of memory and IO required by the system"

new SQLiteAsyncConnection(_databasePath, SQLiteOpenFlags.ReadWrite | SQLiteOpenFlags.Create | SQLiteOpenFlags.SharedCache)

3. Use Lazy Initialization

The official Microsoft Docs say it best:

Lazy initialization of an object means that its creation is deferred until it is first used.

Because File IO operations and creating a database can be expensive (i.e., it requires many CPU cycles and can take longer than expected), we don't want to initialize our database until we need it. This avoids creating our database when the app launches, keeping our app's launch time to a minimum.

static readonly Lazy<SQLiteAsyncConnection> _databaseConnectionHolder = new Lazy<SQLiteAsyncConnection>(() => new SQLiteAsyncConnection(_databasePath, SQLiteOpenFlags.ReadWrite | SQLiteOpenFlags.Create | SQLiteOpenFlags.SharedCache));

static SQLiteAsyncConnection DatabaseConnection => _databaseConnectionHolder.Value;

4. Retrieve the Database Connection

To use the database connection, we must ensure the following:

Ensure Database has been created
- new SQLiteAsyncConnection
Ensure Tables have been created & mapped
- CreateTables(CreateFlags createFlags, params Type[] types)

To accomplish both, I created async Task<SQLiteAsyncConnection> GetDatabaseConnection<T>() where T is the Model's type. This method ensures the database table has been created & mapped before returning the database connection.

protected static async Task<SQLiteAsyncConnection> GetDatabaseConnection<T>()
{
    if (!DatabaseConnection.TableMappings.Any(x => x.MappedType == typeof(T)))
    {
        await DatabaseConnection.CreateTablesAsync(CreateFlags.None, typeof(T)).ConfigureAwait(false);
    }

   return DatabaseConnection;
}

5. Use Write-Ahead Logging

In SQLite-net v1.6.0+, Write Ahead Logging (WAL), is available which brings many performance advantages:

WAL is significantly faster in most scenarios

WAL provides more concurrency as readers do not block writers and a writer does not block readers. Reading and writing can proceed concurrently.

Disk I/O operations tends to be more sequential using WAL.

WAL uses many fewer fsync() operations and is thus less vulnerable to problems on systems where the fsync() system call is broken.

There are also disadvantages to using WAL, most of which however don't impact Xamarin mobile apps. But be sure to understand both the advantages and disadvantages before enabling WAL in your app.

protected static async Task<SQLiteAsyncConnection> GetDatabaseConnection<T>()
{
    if (!DatabaseConnection.TableMappings.Any(x => x.MappedType == typeof(T)))
    {
        // On sqlite-net v1.6.0+, enabling write-ahead logging allows for faster database execution
        await DatabaseConnection.EnableWriteAheadLoggingAsync().ConfigureAwait(false);
        await DatabaseConnection.CreateTablesAsync(CreateFlags.None, typeof(T)).ConfigureAwait(false);
    }

   return DatabaseConnection;
}

6. Always Attempt and Retry

When using multi-threading and async/await to interact with a SQLite database, sometimes this exception is thrown:

SQLite.SQLiteException: database is locked

Anecdotally, I've noticed this exception gets thrown more often in SQLite-net v1.6.0+ when WAL is enabled.

When this exception happens, we just need to retry our SQL query again after the database has been unlocked.

There is an amazing library called Polly that will catch an exception, wait a specified period of time, then try to execute the function again.

For this, I created AttemptAndRetry<T> which will execute a Func<Task<T>>, but if it throws a SQLite.SQLiteException it will attempt to execute it again asynchronously.

Between retries, I recommend using an Exponential Backoff to ensure there are 2ⁿ milliseconds in between. This means that if the first attempt fails, the first retry will happen 2¹ (2) milliseconds later (1 millisecond is a really long time for a CPU). If the second attempt fails, its subsequent retry will happen 2² (4) milliseconds later. And if third attempt fails, its subsequent retry will happen 2³ (8) milliseconds later, etc.

In this example, we will retry 10 times, meaning the final attempt will occur 2 seconds after its previous try, and all 11 attempts (1 attempt + 10 retries) will occur over a total timespan of 4.094 seconds. In other words, if each attempt fails, including the final attempt, the database will throw a SQLite.SQLiteException after approximately 4 seconds.

protected static Task<T> AttemptAndRetry<T>(Func<Task<T>> action, int numRetries = 10)
{
    return Policy.Handle<SQLite.SQLiteException>().WaitAndRetryAsync(numRetries, pollyRetryAttempt).ExecuteAsync(action);

    static TimeSpan pollyRetryAttempt(int attemptNumber) => TimeSpan.FromMilliseconds(Math.Pow(2, attemptNumber));
}

7. Use `ConfigureAwait(false)`

You may notice that every time I use the await keyword, I also use .ConfigureAwait(false). This is done to increase performance.

ConfigureAwait(false) ensures that the background thread doesn't return to the calling thread (which can be the Main Thread, aka the UI Thread). For Xamarin apps, we want to avoid using the Main Thread for database operations to ensure our app doesn't freeze and remains responsive.

I highly recommend watching this session I delivered at NDC Oslo to learn more: "Correcting Common Async Await Mistakes in .NET".

8. Use ValueTask

New in .NET Standard 2.1 is System.Threading.Tasks.ValueTask.
(If you can't yet upgrade to .NET Standard 2.1, you can still use ValueTask by installing the System.Threading.Tasks.Extensions NuGet Package.)

If you're new to ValueTask, check out this great write-up: Understanding the Whys, Whats, and Whens of ValueTask.

tl;dr VaueTask can be used to improve async/await performance when the hot-path of a method doesn't require the await keyword.

GetDatabaseConnection only uses the await keyword the first time it is called. Thus its hot-path does not use require await, making it the perfect use-case for ValueTask.

To implement ValueTask for GetDatabaseConnection<T>, just replace Task<SQLiteAsyncConnection> with ValueTask<SQLiteAsyncConnection>:

protected static async ValueTask<SQLiteAsyncConnection> GetDatabaseConnection<T>()
{
    if (!DatabaseConnection.TableMappings.Any(x => x.MappedType == typeof(T)))
    {
        // On sqlite-net v1.6.0+, enabling write-ahead logging allows for faster database execution
        await DatabaseConnection.EnableWriteAheadLoggingAsync().ConfigureAwait(false);
        await DatabaseConnection.CreateTablesAsync(CreateFlags.None, typeof(T)).ConfigureAwait(false);
    }

   return DatabaseConnection;
}

9. Put It All Together

Putting all of these best practices together, I've created abstract class BaseDatabase. I copy/paste this abstract class into all of my Xamarin applications where I use a database.

A completed sample app using this implementation is available here: https://github.com/brminnick/GitTrends

BaseDatabase.cs

Be sure to first add the following NuGet Packages to your app:

SQLite-Net
Xamarin.Essentials
- Used to locate the app's data Directory
- Getting Started Instructions
Polly
- Used to attempt database actions and automatically retry if unsuccessful
- (Polly doesn't require any initialization code)
ValueTask (Not required for .NET Standard 2.1+)

using System.Threading.Tasks;

using SQLite;

using Xamarin.Essentials;
using Xamarin.Forms;

namespace MyNamespace
{
    public abstract class BaseDatabase
    {
        static readonly string _databasePath = Path.Combine(FileSystem.AppDataDirectory, "SqliteDatabase.db3");
        static readonly Lazy<SQLiteAsyncConnection> _databaseConnectionHolder = new Lazy<SQLiteAsyncConnection>(() => new SQLiteAsyncConnection(_databasePath, SQLiteOpenFlags.ReadWrite | SQLiteOpenFlags.Create | SQLiteOpenFlags.SharedCache));

        static SQLiteAsyncConnection DatabaseConnection => _databaseConnectionHolder.Value;

        protected static async Task<SQLiteAsyncConnection> GetDatabaseConnection<T>()
        {
            if (!DatabaseConnection.TableMappings.Any(x => x.MappedType == typeof(T)))
            {
                // On sqlite-net v1.6.0+, enabling write-ahead logging allows for faster database execution
                await DatabaseConnection.EnableWriteAheadLoggingAsync().ConfigureAwait(false);
                await DatabaseConnection.CreateTablesAsync(CreateFlags.None, typeof(T)).ConfigureAwait(false);
            }

            return DatabaseConnection;
        }

        protected static Task<T> AttemptAndRetry<T>(Func<Task<T>> action, int numRetries = 10)
        {
            return Policy.Handle<SQLite.SQLiteException>().WaitAndRetryAsync(numRetries, pollyRetryAttempt).ExecuteAsync(action);

            static TimeSpan pollyRetryAttempt(int attemptNumber) => TimeSpan.FromMilliseconds(Math.Pow(2, attemptNumber));
        }
    }
}

Example: Inheriting from BaseDatabase

namespace MyNamespace
{
    public class CustomerDatabase : BaseDatabase
    {
        public async Task<List<CustomerModel>> GetAllCustomers()
        {
            var databaseConnection = await GetDatabaseConnection<CustomerModel>().ConfigureAwait(false);

            return await AttemptAndRetry(() => databaseConnection.Table<CustomerModel>().ToListAsync()).ConfigureAwait(false);
        }
    }
}

Conclusion

I highly recommend using BaseDatabase.cs in all of your Xamarin apps to take advantage of these awesome performance improvements!

Lazy Loading - ensure your app launches quickly
Write Ahead Logging - faster/more-efficient database writes
Attempt And Retry - use Polly to retry database writes
ConfigureAwait(false) - avoid unnecessarily returning to the Main Thread
ValueTask - avoid unnecessary memory allocations

#25DaysOfServerless Day 18 Solution: Wrapping the Perfect Gift

Brandon Minnick — Thu, 19 Dec 2019 01:00:08 +0000

Hello Friends!

The challenge on Day 18 of #25DaysOfServerless is to ensure that each gift is perfectly wrapped according to the following rules

Placed in a box
Box is wrapped
A bow / ribbon placed on top

Let's accomplish this using Azure Blob Storage, Azure Computer Vision API, and Azure Functions.

Example

Using this example of a perfectly wrapped gift, the Computer Vision API confirms the following Tags:

Box
Gift Wrapping
Ribbon
Present

Creating the Solution

Step 0: Install Tools

In this step, we will install the necessary commandline tools in order to complete the solution.

1 - Install .NET Core v3.1

In a browser, navigate to the Download .NET Core Website
On the Download .NET Core Website, install .NET Core 3.1

2 - Install the Azure CLI

(Windows) Download the MSI Installer
(macOS) In the terminal, enter the following command:

brew update && brew install azure-cli

3 - Install Azure Functions Core Tools v3.x

(Windows) In the terminal, enter the following command:

npm install -g azure-functions-core-tools@3

(macOS) In the terminal, enter the following command:

brew tap azure/functions
brew install azure-functions-core-tools@3
# if upgrading on a machine that has 2.x installed
brew link --overwrite azure-functions-core-tools@3

4 - Install Git Command Line Tools

In a browser, navigate to the Git Downloads Page
On the Git Downloads Page, install git for your specific operating system

Step 1: Downloading the Solution Repo

In this step, we will fork and clone the solution repo to our local machine.

0 - Star the Solution Repo

Note Starring the repo will help it become more discoverable, helping more devs find the solution

In a browser, navigate to the Perfect-Gift repo
In the browser, tt the top of the page, click Star

1 - Fork the Solution Repo

In a browser, navigate to the Perfect-Gift repo
In the browser, tt the top of the page, click Star

2 - Clone the newly Forked Repo

In the terminal, enter the following command:

git clone https://github.com/[your github user name]/Perfect-Gift

Note Replace [your github user name] with your GitHub User name

Step 2: Log into Azure CLI

1 - In the terminal, enter the following command to login into Azure CLI:

az login

Note: Stand by until the Azure CLI opens your browser to the Azure Login page

Step 3: Create Azure Resources

In this step, we'll generate the following Azure Resources:

Azure Resource Group
- This is a folder in azure that will hold our resources
Azure Blob Storage
- This is where we'll upload and store the images of our gifts
Computer Vision API Key
- This API will use machine learning to confirm that our gift has been perfectly wrapped
Azure Functions
- This server less function will run each time a new photo is uploaded to Azure Blob Storage to confirm that the image contains a perfectly wrapped gift

1 - In the terminal, enter the following command to create an Azure Resource Group

az group create --name PerfectGift --location EastUS

2 - In the terminal, enter the following command to create a free Computer Vision resource

az cognitiveservices account create --resource-group PerfectGift --name PerfectGiftComputerVision --sku F0 --kind ComputerVision --location EastUS

3 - In the terminal, in the JSON response, note the value of endpoint

Note: For the EastUS, the endpoint should be https://eastus.api.cognitive.microsoft.com. We will use this value later in our serverless function.

4 - In the terminal, enter the following command to retrieve the newly generated Computer Vision API Key

az cognitiveservices account keys list --resource-group PerfectGift --name PerfectGiftComputerVision

5 - In the terminal, in the JSON response, note the value of key1

Note: The JSON response will provide two keys. Both keys are valid, and we'll be using key1 for our serverless function.
{
  "key1": "[YOUR API KEY]",
  "key2": "[YOUR API KEY]"
}

6 - In the terminal, enter the following command to create an Azure Storage account:

az storage account create --name giftstorage[YOUR NAME] --location EastUS --resource-group PerfectGift --sku Standard_LRS

Note: Replace [Your Name] with your name to ensure the storage account name is unique, e.g. giftstoragebrandon

7 - In the terminal, enter the following command retrive the Azure Storage Connection String

az storage account show-connection-string --name giftstorage[YOUR NAME]

Note: Replace [Your Name] with your name

8 - In the terminal, in the JSON response, copy the value of connectionString

Note: We will use connectionString in the next step to create a new storage container

9 - In the terminal, enter the following command to create container called gifts in our Azure Storage account:

az storage container create --name gifts --connection-string "[YOUR CONNECTION STRING]"

Note: Replace [YOUR CONNECTION STRING] with the vaulue of connectionString retreived in the previous step, e.g. az storage container create --name gifts --connection-string "abc123def456ghi789=="

10 - In the terminal, enter the following command to create an Azure Function App:

az functionapp create --resource-group PerfectGift --consumption-plan-location EastUS --name PerfectGift-[Your Name] --storage-account  giftstorage[YOUR NAME] --runtime dotnet

Note: Replace [Your Name] with your name to ensure the function app name is unique, e.g. PerfectGift-Brandon

11 - In the terminal, enter the following to set the Azure Functions Runtime to v3:

az functionapp config appsettings set --resource-group PerfectGift --name PerfectGift-Brandon --settings "FUNCTIONS_EXTENSION_VERSION=~3"

12 - In the terminal, enter the following to add the Computer Vision API key and endpoint to the newly created Azure Function App:

az functionapp config appsettings set --resource-group PerfectGift --name PerfectGift-[YOUR NAME] --settings "VisionApiKey=[YOUR API KEY]" "VisionApiBaseUrl=[YOUR COMPUTER VISION ENDPOINT]"

Note: Replace [YOUR NAME] with your name, replace [YOUR API KEY] with the value of key1 and replace [YOUR COMPUTER VISION ENDPOINT] with the value of endpoint
e.g. az functionapp config appsettings set --resource-group PerfectGift --name PerfectGift-Brandon --settings "VisionApiKey=abc123" "VisionApiBaseUrl=https://eastus.api.cognitive.microsoft.com"

Step 4: Publish Azure Function

In this step, we will publish the solution found in PerfectGift.csproj to Azure.

1 - In the terminal, enter the following command to navigate to the folder containing PerfectGift.csproj in the cloned solution repo

(Windows)

cd [Path to cloned solution repo]\Perfect-Gift\PerfectGift\

(macOS)

cd [Path to cloned solution repo]/Perfect-Gift/PerfectGift

2 - In the terminal, enter the following command to publish PerfectGift.csproj to our Azure Function App:

func azure functionapp publish PerfectGift-[YOUR NAME]

Note: Replace [YOUR NAME] with your name

Step 5: Upload Perfectly Wrapped Gift Images

Our serverless functon is now ready to verify our gift images!

In this step, we will upload images to Azure Blob Storage and confirm that our serverless function automatically verifies the image is a perfectly wrapped gift. If the image is not of a perfectly wrapped gift, it will automatically be removed from Azure Blob Storage.

1 - Download this sample image of a perfectly wrapped gift

2 - Move & rename the downloaded image of a perfectly wrapped gift:

(Windows) Save the file as C:\Downloads\gift.jpg
(macOS) Save the file as ~/Download/gift.jpg

3 - In the terminal, enter the following command to upload our image of a perfectly wrapped gift

az storage blob upload --container-name gifts --connection-string "[YOUR CONNECTION STRING]" --file [FILE PATH TO GIFT IMAGE] --name Gift1

Note: Replace [YOUR CONNECTION STRING] with the value of connectionString and replace [FILE PATH TO GIFT IMAGE] with the file path to your wrapped gift image
e.g. az storage blob upload --container-name gifts --connection-string "abc123def456ghi789==" --file cd:\Downloads\gift.jpg --name Gift1

4 - In the terminal, enter the following command to confirm the image has been not been deleted from storage:

az storage blob list --container-name gifts --connection-string "[YOUR CONNECTION STRING]"

Note: Replace [YOUR CONNECTION STRING] with the value of connectionString and replace [FILE PATH TO GIFT IMAGE] with the file path to your wrapped gift image
e.g. az storage blob list --container-name gifts --connection-string "abc123def456ghi789=="

5 - In the JSON response, confirm "name": "Gift1"

6 - Download this sample image of a wrapped gift missing a bow

7 - Move & rename the downloaded image of a wrapped gift missing a bow:

(Windows) Save the file as C:\Downloads\nobow.jpg
(macOS) Save the file as ~/Download/nobow.jpg

In the terminal, enter the following command to upload our image of a perfectly wrapped gift

az storage blob list --container-name gifts --connection-string "[YOUR CONNECTION STRING]" --file [FILE PATH TO NO BOW GIFT IMAGE] --name Gift2

Note: Replace [YOUR CONNECTION STRING] with the value of connectionString and replace [FILE PATH TO GIFT IMAGE] with the file path to your wrapped gift image

e.g. az storage blob upload --container-name gifts --connection-string "abc123def456ghi789==" --file cd:\Downloads\nobow.jpg --name Gift2

9 - In the terminal, enter the following command to confirm the image has been not been deleted from storage:

az storage blob list --container-name gifts --connection-string "[YOUR CONNECTION STRING]"

Note: Replace [YOUR CONNECTION STRING] with the value of connectionString and replace [FILE PATH TO GIFT IMAGE] with the file path to your wrapped gift image

e.g. az storage blob list --container-name gifts --connection-string "abc123def456ghi789=="

10 - In the JSON response, confirm that "name": "Gift2" does not exist

Note: It may take a minute for the Blob Trigger Function to analyze the uploaded image.

If "name": "Gift2" does still exist, run az storage blob list --container-name gifts --connection-string "[YOUR CONNECTION STRING]" again in a few minutes

Step 6: Celebrate 🎉

We now have a working Blob Trigger that automatically verifies our gifts have been perfectly wrapped!

We have successfully completed the Day 18 Challenge of #25DaysOfServerless!

Introducing #25DaysOfServerless, an Azure Functions Challenge

Brandon Minnick — Mon, 25 Nov 2019 15:23:31 +0000

Hello Friends!

We are excited to announce #25DaysOfServerless, a 25-day event to create a 25 new serverless workloads leveraging Azure Functions.

Rules

Solve the daily challenge in the programming language of your choice. Then submit your solution via GitHub (and share it on Twitter), and we'll showcase the best solutions every week!

If you're new to serverless, we'll have hints to help you! All you need is a GitHub account to post your solution and a sense of adventure.

Example

'Tis the season for gift giving, and we need a solution to share images of our gifts! One problem though: we can only share png files.

For this challenge, create an Azure Function triggered by Azure Blob Storage that will verify that each photo uploaded to our Azure Blob Storage container is a png; if it is not, delete the photo from the container.

We can create a simple BlobTrigger in Azure Functions to solve this one in C#!

[FunctionName(nameof(GiftPhotoValidationFunction))]
public static async Task Run([BlobTrigger(_containerName)] CloudBlockBlob blockBlob, ILogger log)
{
    log.LogInformation("Validating Gift Image is a PNG");

    if (blockBlob.Name.EndsWith(".png", StringComparison.InvariantCultureIgnoreCase))
    {
        log.LogInformation("Confirmed PNG");
    }
    else
    {
        log.LogInformation($"Photo {blockBlob.Name} is not a PNG");

        log.LogInformation($"Deleting {blockBlob.Name} from container");

        await blockBlob.DeleteAsync().ConfigureAwait(false);

        log.LogInformation($"Deleted {blockBlob.Name}");
    }
}

Get Started

Starting December 1st, visit https://www.25daysofserverless.com to find the daily challenge, and follow both @AzureAdvocates and #25DaysOfServerless on Twitter.

If you're new to Azure, sign up for a Free Azure Account before #25DaysOfServerless kicks off on December 1st!

Forem: Brandon Minnick

Android Image Classification with TensorFlow Lite & Azure Custom Vision Service

Image Classification Libraries

1. Azure Custom Vision Service

2. TensorFlow Lite

Implementing Image Classification with Azure + Xamarin.Android

1. Training the Model

2. Export Trained Models from Azure Custom Vision Service

3. Import TensorFlowLite into our Xamarin.Android App

4. Implement Image Classification Code for Xamarin.Android

ImageClassificationModel.cs

TensorflowClassifier.cs

Learn More

Introducing GitTrends: GitHub Insights

Resources

Mobile App

Cloud Backend

Xamarin: Efficiently Using a SQLite Database

1. Locate the App Data Directory

2. Use SQLiteOpenFlags

3. Use Lazy Initialization

4. Retrieve the Database Connection

5. Use Write-Ahead Logging

6. Always Attempt and Retry

7. Use ConfigureAwait(false)

8. Use ValueTask

9. Put It All Together

BaseDatabase.cs

Example: Inheriting from BaseDatabase

Conclusion

#25DaysOfServerless Day 18 Solution: Wrapping the Perfect Gift

Example

Creating the Solution

Step 0: Install Tools

Step 1: Downloading the Solution Repo

Step 2: Log into Azure CLI

Step 3: Create Azure Resources

Step 4: Publish Azure Function

Step 5: Upload Perfectly Wrapped Gift Images

Step 6: Celebrate 🎉

Introducing #25DaysOfServerless, an Azure Functions Challenge

Rules

Example

Get Started

7. Use `ConfigureAwait(false)`