SSW

UPDATED TO .NET Core 3.x I have been a great fan of Serilog and Seq for over 2 years and I delivered great value to many of my clients. After many projects of integrating Serilog and Seq into ASP.NET Core applications, I finally found my favorite way to integrate them. There are few things this…

TL;DR; check my GitHub project for bank transaction classification. https://github.com/jernejk/MLSample.SimpleTransactionTagging

UPDATE: If you are looking to learn Machine Learning with minimum code and effort, check out Simplified Machine Learning for Developers with ML.NET. The post below was created before ML.NET Model Builder was released and I made a video about it.
Goal
For a long time, I was trying to get into practical machine learning but I found machine learning wasn’t very accessible for most of the devs.
Recently as a challenge, I tried to make a lightning talk, where I tried to explain how to solve a relatable yet usable everyday problem with machine learning in just 15-20 minutes.
For the demo, I have decided to do bank transaction category classification, as this is something I do every week. While I use a financing service Toshl that collects and classifies all of my bank transactions, I still had to spend ~1 hour every week to fix misclassified transactions. I wanted to fix this problem without needing to write a complicated rule engine and machine learning seemed to be the right approach.
For this example, we’ll use .NET Core with ML.NET and a couple of transactions. You can look at https://github.com/dotnet/machinelearning-samples/. We’ll use Multi-class classification, which is perfect for our problem.
My data is coming from the finance app Toshl which already has the correct category labels for each transaction.
Code
First, I started by looking GitHub Issue Labeler and simply modifying its training data to be my transactions. That surprisingly worked pretty well and I have started a new project that was based on that prototype.
After that, I have decided with the following structure for input which was loaded from JSON. Description and transaction type are used as inputs (features) and category as expected result (label).

[DataContract]
public class TransactionData
{
[DataMember(Name = “desc”)]
public string Description { get; set; }

[DataMember(Name = “category”)]
public string Category { get; set; }

[DataMember(Name = “transactionType”)]
public string TransactionType { get; set; }
}

Next data structure is the prediction model. Column name needs to PredictedLabel, while property name can be anything you like.

public class TransactionPrediction
{
[ColumnName(“PredictedLabel”)]
public string Category;
}

I have loaded the data from JSON.Next step is to train a model and save it.This step doesn’t have verification of the model, which is highly recommended but not necessary for ML. (it’s like an integration test for very fragile code)

public class BankTransactionTrainingService
{
public void Train(IEnumerable trainingData, string modelSavePath)
{
var mlContext = new MLContext(seed: 0);

// Configure ML pipeline
var pipeline = LoadDataProcessPipeline(mlContext);
var trainingPipeline = GetTrainingPipeline(mlContext, pipeline);
var trainingDataView = mlContext.Data.LoadFromEnumerable(trainingData);

// Generate training model.
var trainingModel = trainingPipeline.Fit(trainingDataView);

// Save training model to disk.
mlContext.Model.Save(trainingModel, trainingDataView.Schema, modelSavePath);
}

private IEstimator LoadDataProcessPipeline(MLContext mlContext)
{
// Configure data pipeline based on the features in TransactionData.
// Description and TransactionType are the inputs and Category is the expected result.
var dataProcessPipeline = mlContext
.Transforms.Conversion.MapValueToKey(inputColumnName: nameof(TransactionData.Category), outputColumnName: “Label”)
.Append(mlContext.Transforms.Text.FeaturizeText(inputColumnName: nameof(TransactionData.Description), outputColumnName: “TitleFeaturized”))
.Append(mlContext.Transforms.Text.FeaturizeText(inputColumnName: nameof(TransactionData.TransactionType), outputColumnName: “DescriptionFeaturized”))
// Merge two features into a single feature.
.Append(mlContext.Transforms.Concatenate(“Features”, “TitleFeaturized”, “DescriptionFeaturized”))
.AppendCacheCheckpoint(mlContext);

return dataProcessPipeline;
}

private IEstimator GetTrainingPipeline(MLContext mlContext, IEstimator pipeline)
{
// Use the multi-class SDCA algorithm to predict the label using features.
// For StochasticDualCoordinateAscent the KeyToValue needs to be PredictedLabel.
return pipeline
.Append(GetScadaTrainer(mlContext))
.Append(mlContext.Transforms.Conversion.MapKeyToValue(“PredictedLabel”));
}

private IEstimator GetScadaTrainer(MLContext mlContext)
{
return mlContext.MulticlassClassification.Trainers.SdcaMaximumEntropy(“Label”, “Features”);
}
}

The code below will load the model and predict the category.

public class BankTransactionLabelService
{
private readonly MLContext _mlContext;
private PredictionEngine _predEngine;

public BankTransactionLabelService()
{
_mlContext = new MLContext(seed: 0);
}

public void LoadModel(string modelPath)
{
ITransformer loadedModel;
using (var stream = new FileStream(modelPath, FileMode.Open, FileAccess.Read, FileShare.Read))
loadedModel = _mlContext.Model.Load(stream, out var modelInputSchema);
_predEngine = _mlContext.Model.CreatePredictionEngine(loadedModel);
}

public string PredictCategory(TransactionData transaction)
{
var prediction = new TransactionPrediction();
_predEngine.Predict(transaction, ref prediction);
return prediction?.Category;
}
}

And that’s all from machine learning!
Let’s see how everything comes together.

public static void Main(string[] args)
{
// Some manually chosen transactions with some modifications.
Console.WriteLine(“Loading training data…”);
var trainingData = JsonConvert.DeserializeObject(File.ReadAllText(“training.json”));

Console.WriteLine(“Training the model…”);
var trainingService = new BankTransactionTrainingService();
trainingService.Train(trainingData, “Model.zip”);

Console.WriteLine(“Prepare transaction labeler…”);
var labelService = new BankTransactionLabelService();
labelService.LoadModel(“Model.zip”);

Console.WriteLine(“Predict some transactions based on their description and type…”);

// Should be “coffee & tea”.
MakePrediction(labelService, “AMERICAN CONCEPTS PT BRISBANE”, “expense”);

// The number in the transaction is always random but it will work despite that. Result: rent
MakePrediction(labelService, “ANZ M-BANKING PAYMENT TRANSFER 513542 TO SPIRE REALITY”, “expense”);

// In fact, searching just for part of the transaction will give us the same result.
MakePrediction(labelService, “SPIRE REALITY”, “expense”);

// If we change the transaction type, we’ll get a reimbursement instead.
MakePrediction(labelService, “SPIRE REALITY”, “income”);
}

private static void MakePrediction(BankTransactionLabelService labelService, string description, string transactionType)
{
string prediction = labelService.PredictCategory(new TransactionData
{
Description = description,
TransactionType = transactionType
});

Console.WriteLine($”{description} ({transactionType}) = > {prediction}”);
}

In the above example, we tried to identify a coffee shop, rent in 2 different ways and a reimbursement coming from the same description as rent. With machine learning, we can now predict category even if it’s not completely correct, almost like a fuzzy search.
Conclusion
In conclusion, it took me 2 hours to write my initial prototype and about 4 hours to clean up incorrect data. (I’m working with 1k+ real transactions) The results are very good with about 95% accuracy!
With ML.NET most of the work is in selecting the right machine learning configuration and preparing test data. For example, description and transaction type are great features for predicting labels. In contrast, adding features like amount, date/time which more often than not is not directly linked to the label, may result in predictions to be way off or unable anything at all.
In the past, I have made a few attempts to classify my transactions via a rule engine and failed to deliver great long term value with few days of work. The project was abandoned because the projected effort of maintaining the rules was too great.

It is a great time to be a technologist. I am spending lots of my time at the moment thinking about drones, AI & IOT, about where these technologies intersect, and where they can help people.I was very happy when I got asked today to do a quick 10 minute presentation on ‘Where are we at with drones’.
Rather than just deliver it once I thought I’d capture some thoughts here.
eSmart Systems – Using drones for power line inspection
Maintenance of electrical grids is not only time consuming and costly, but it can also be very dangerous. By developing a connected drone that uses AI and cognitive services from Microsoft Azure, utility companies can reduce blackouts and inspect power lines more safely.
[embedded content]
Microsoft FarmBeats -Uses drones, AI and IOT Edge to increase farm productivity
Microsoft FarmBeats aims to enable farmers to increase farm productivity and reduce costs by enabling data-driven farming.

A new partnership between Microsoft and leading drone maker DJI builds on the work both companies are doing with data and agriculture that could make it easier and more affordable for farmers to quickly get the information they need to make crucial decisions about soil moisture and temperature, pesticides and fertilizer. Hours and days spent walking or driving the fields to try to detect problems can be eliminated. Since 2011, farmer Sean Stratman has grown kale, cauliflower, broccoli and squash in Carnation, Washington. Then, a few years ago, he added a new crop to his bounty: knowledge, using drones and the intelligent edge to get near-real-time information about issues like soil moisture and pests. It’s the kind of information that is not only helping him, but could benefit farmers around the world. Source:

[embedded content]
Links: More reading on FarmBeats
Project Premonition – Using drones to fight infectious diseases
Emerging infectious diseases such as Zika, Ebola, Chikungunya and MERS are dangerous and unpredictable. Public health organizations need data as early as possible to predict disease spread and plan responses. Yet early data is very difficult to obtain, because it must be proactively collected from potential disease sources in the environment. Researchers estimate between 60 and 75% of emerging infectious diseases originate from animals, which are very difficult to monitor.
Project Premonition aims to detect pathogens before they cause outbreaks — by turning mosquitoes into devices that collect data from animals in the environment.
It does this by
Full Article available here More Info here
Teaching Drones to Aid Search and Rescue efforts via Cognitive Services
InDro Robotics, a drone operating outfit based in Salt Spring Island British Columbia, recently connected with Microsoft to explore how they could better enable their drones for search and rescue efforts.

Leveraging Custom Vision Cognitive Service and other Azure services, including IoT Hub, InDro Robotics developers can now successfully equip their drones to:
Identify objects in large bodies of water, such as life vests, boats, etc. as well as determine the severity of the findings
Recognize emergency situations and notify control stations immediately, before assigning to a rescue squad
Establish communication between boats, rescue squads and the control stations. The infrastructure supports permanent storage and per-device authentication
Full article available here
More info
If you are interested in other use cases or info on drones I keep a scratch pad on drone tech in my FAQs collection on drones.
If you are doing something awesome with Drones, AI and Azure please reach out. I would love to chat !

I recently ran a hands-on workshop about how to build Azure Pipelines for ‘build’ and ‘release’.Pipelines are great as the allow you to automate your builds and deployments so you spend less time with the nuts and bolts, and more time being creative.
The materials put together by the Azure DevOps team are fantastic and cover a very broad range of topics.
You can get them here https://www.azuredevopslabs.com.

Demo Scripts (In-Progress)
Here is an overview of what I covered on the day and some basic notes I use for when I demo the day (to save me looking up the complete docs).
Tip: After you have followed the step by step instructions – see if you can complete the task again just following my demo script notes.
Exercise 1a: Enabling Continuous Integration with Azure Pipelines
Source: https://www.azuredevopslabs.com/labs/azuredevops/continuousintegration/
Exercise 1b: Configuring Builds as Code with YAML in Azure Pipelines
Source: https://www.azuredevopslabs.com/labs/azuredevops/yaml/
Task 1: Setting up Azure resources

Disable the CI trigger for the default build definition. Edit
Triggers
Enabled
Save

Task 2: Adding a YAML build definition
Repos | Files | New File | ‘azure-pipelines.yml’

Azure DevOps will automatically create a definition when you add this file to root of repo.

Add the yaml below and commit.

steps:
– script: echo hello world

Go to Pipelines
Build
Start the build
View the last build step.

Task 3: Crafting sophisticated YAML definitions
You can even export existing build definitions as YAML if you would prefer to manage them in code.

Builds
PartsUnlimitedE2E
Edit
View YAML
Copy to clipboard

Open our ‘azure-pipelines.yml’ and paste in contents. Commit changes

Note: In the comment blog: The SymbolPath reference is coincidental (it’s a literal needed for the build), but the BuildPlatform and BuildConfguration variables will play a role later.

Pipelines | Build | Open the new build to follow its progress. It will be successful but report there were no tests – there should have been. we will work out the problem.
Build | Logs tab | Test Assemblies task Note that there is a warning that the test assembly pattern didn’t find any matches. Upon closer inspection, it appears that it was expecting a build variable for BuildConfiguration to be available, but since it wasn’t, the platform simply used the text as-is. This was something we probably should have expected given the warnings in the YAML.
Edit build | Variables | Add |

“BuildPlatform”
“any cpu”

“BuildConfiguration”
“release”

Check the ‘Settable at queue time’ option for each

Triggers tab
Note that you can override the YAML settings and configure CI like web-based builds

Save and Queue
Check the tests. All good.
Exercise #2 Embracing Continuous Delivery with Azure Pipelines
Source: https://www.azuredevopslabs.com/labs/azuredevops/continuousdeployment/
Task 1 Setting up Azure Resources
Create a SQL Database (if you haven’t already made it)

database name: partsunlimited
source: blank database
server name: -partsunlimited

2.Create a web app (if you haven’t already made it)

app name: -partsunlimited-qa
resource group & subscription: same as previous
app service plan: accept the defaults
OS: Windows
App Insights: Off

Task 2: Creating a continuous release to the QA state
open a new browser tab for Azure DevOps https://dev.azure.com/YOURACCOUNT/Parts%20Unlimited.

Navigate to Pipelines
Releases

Delete the existing PartsUnlimitedE2E release pipeline
Create a new release pipeline

template: Azure App Service Deployment
default stage: QA
pipeline name: PUL-CICD
artifact: Build | PartsUnlimitedE2E
QA environment task | select QA web app

Turn on CI trigger
Add a build branch trigger > “The build pipeline’s default branch”
Save
Task 3: Configuring the Azure app services for CD
Open the SQL Database – get the db connection strings
Copy the ADO.NET string to your clipboard.
Update username and password in the connection string with SQL credentials
Open the QA app service | Application Settings | Connection Strings

DefaultConnectionString:

Click Save
Repeat for Prod web app
Task 4: Invoking a CD release to QA
Open Azure Devops Repos tab in a new browser tab
Edit PartsUnlimited-aspnet45/src/PartsUnlimitedWebsite/Views/Shared/_Layout.cshtml.

//add v2.0 text after the image
v2.0

Commit changes
Open the build that is kicked off > follow until completion
Open the release > follow it until completion
Navigate to the QA Site > .azurewebsites.net
Check that it now says ‘v2.0’ after the image
Task5: Creating a gated release to the production stage
We are including both automated quality gates as well as a manual approver gate. We will make it our policy that the QA deployment cannot be considered a success until all critical bugs have been resolved.
Open the Release pipeline. Clone the QA stage.
Apply post-deployment considitions on QA gate
Enable the Gates option
Change ‘Delay before evaluation’ to 0
Add ‘Query Work Items’ Deployment gates

Query > Shared Queries
Critical Bugs

Evuation options > Time between re-evaluation of gates to 5.

Rename ‘Copy of QA’ to Prod
Add Pre-deployment approvals > add yourself as an Approver
Click the Prod job > change the app service name to be the Prod web app
Save the pipeline
Edit PartsUnlimited-aspnet45/src/PartsUnlimitedWebsite/Views/Shared/_Layout.cshtml. Change v2.0 to v3.0
Follow the release through to QA. It will fail. Click the View post-deployment gates button.

In a new tab open ‘Boards
Queries
Shared Queries
Critical Bugs’ to locate the bug

Open the bug and mark it as Done. Click Save. (Usually we’d actually fix the bug ;-))
Return to release tab. After approx 5 mins Azure DevOps will check the query again. Once it does, the bugs will be cleared and the release will be approved. You can then click Approve to approve deployment to production.
Confirm the release and watch it, and then check the prod website
Task 6: Working with deployment slots
The most common scenario for using a deployment slot is to have a staging stage for your application to run against productions services, but without replacing the current production application. If the staging deployment passes review, it can immediately be “swapped” in as the production slot with the click of a button. As an additional benefit, the swap can be quickly reversed in the event an issue is uncovered with the new build.
Open the prod app service > Deployment Slots > Add Slot > ‘staging’ with ‘Config Source’ as the current deployment. Note: the ‘production’ slot is considered a ‘default’ and is not shown as a separate slot
Edit the Azure DevOps Prod stage pipeline > Select ‘Deploy Azure App Service’ task >
Select Deploy to slot > choose ‘staging’. Click Save
Commit a change to ‘v4.0’. Follow pipeilne through and approve release.
Refresh browser tab for Prod website – > Still v3.0
Open a new tab to the staging slot…. ‘https://-staging.azurewebsites.net
Return to the App Service in Azure Portal. Deployment Slots > Swap > OK (with defaults)
Refresh prod browser window – > v4.0

Note: Note that if your apps rely on slot-level configuration settings (such as connection strings or app settings marked “slot”), then the worker processes will be restarted. If you’re working under those circumstances and would like to warm up the app before the swap completes, you can select the Swap with preview swap type.

Exercise #3 GitHub integration with Azure Pipelines
Source: https://www.azuredevopslabs.com/labs/vstsextend/github-azurepipelines/

2019-03-06CODING ·c# GetHashCode VS2017 VS2019 .Net

Remembering the most appropriate way to calculate a hashcode was always difficult. But not anymoretl;dr
Let Visual Studio generate your overrides for Equals() and GetHashCode() so you don’t need to remember the best practices.
Don’t roll your own GetHashCode() algorithm or even rely on StackOverflow, use the .net framework to work it out for you..

HashCode.Combine(Long, Lat, Altitude);

Background
When trying to check the equality of reference objects in c# we simply cannot apply the ‘==’ operator, as this will only compare memory locations and not data.
To get around this every object implements both the Equals() and GetHashCode() methods. According to MSDN The purpose of GetHashCode() is:

The GetHashCode method provides this hash code for algorithms that need quick checks of object equality.

The main points to take into consideration when calculating the hash code are:

A hash function must have the following properties:

If two objects compare as equal, the GetHashCode() method for each object must return the same value. However, if two objects do not compare as equal, the GetHashCode() methods for the two objects do not have to return different values.

The GetHashCode() method for an object must consistently return the same hash code as long as there is no modification to the object state that determines the return value of the object’s System.Object.Equals method. Note that this is true only for the current execution of an application, and that a different hash code can be returned if the application is run again.

For the best performance, a hash function should generate an even distribution for all input, including input that is heavily clustered. An implication is that small modifications to object state should result in large modifications to the resulting hash code for best hash table performance.

Hash functions should be inexpensive to compute.

The GetHashCode() method should not throw exceptions. MSDN

Of these the most important to note are points 3 and 4: It should generate an even distribution and should be inexpensive.
In the good ol’ days
After searching around you would usually find an implementation (which I did recently) along the lines of the following:

public override int GetHashCode()
{
unchecked
{
int hash = 17;

hash = hash * 23 + Lat.GetHashCode();
hash = hash * 23 + Long.GetHashCode();
hash = hash * 23 + Altitude.GetHashCode();
return hash;
}
}

I’m not going to claim I know how the maths works out, but I’m told it just does and that it satisifies the requirements mentioned above.
I’ve never been happy with this, as I am unable to prove the even distribution etc requirements, and am I missing brackets to ensure order of operation???
These days
Well, today I stumbled across this little Gem inside VS2017 (also VS2019).
Starting with:

public class Location
{
public int Long { get; set; }
public int Lat { get; set; }
public int Altitude { get; set; }
}

Place the cursor on the Class definition and open the Quick Actions menu ‘ctrl + .’, then select “Generate Equals and GetHashCode…”

Select which properties you want included in your equality check and voila. you are good to go. As an optional extra you can even choose to implement IEquatable too.

public class Location : IEquatable
{
public int Long { get; set; }
public int Lat { get; set; }
public int Altitude { get; set; }

public override bool Equals(object obj)
{
return Equals(obj as Location);
}

public bool Equals(Location other)
{
return other != null &&
Long == other.Long &&
Lat == other.Lat &&
Altitude == other.Altitude;
}

public override int GetHashCode()
{
return HashCode.Combine(Long, Lat, Altitude);
}
}

The final point of note is the calculation of the HashCode. No longer do we need to remember how to calculate, or worry about the effiency or the distribution because Microsoft have given us a handy helper

HashCode.Combine(Long, Lat, Altitude);

And thats it, one less thing for me to think about.