New Pluralsight Courses Released!

My new Pluralsight courses Cleaning and Preparing Data in Microsoft Azure and Architecting Xamarin.Forms Applications for Code Reuse were just released! Here are the synopsis:

Cleaning and Preparing Data in Microsoft Azure

Abstract

This course targets software developers and data scientists looking to understand the initial steps in a machine learning solution. The content will showcase methods and tools available using Microsoft Azure.

Description

No data science project of merit has ever started with great data ready to plug into an algorithm. In this course, Cleaning and Preparing Data in Microsoft Azure, you’ll learn foundational knowledge of the steps required to utilize data in a machine learning project. First, you’ll discover different types of data and languages. Next, you’ll learn about managing large data sets and handling bad data. Finally, you’ll explore how to utilize Azure Notebooks. When you’re finished with this course, you’ll have the skills and knowledge of preparing data needed for use in Microsoft Azure. Software required: Microsoft Azure.

Architecting Xamarin.Forms Applications for Code Reuse

Abstract

A well-architected application is flexible to changing business requirements. This course will teach you how to architect Xamarin.Forms applications in a way that promotes reusable patterns.

Description

As business requirements change, so do solution assumptions. In this course, Architecting Xamarin.Forms Applications for Code Reuse, you’ll learn different architectural patterns in Xamarin.Forms. First, you’ll explore project structure and organization. Next, you’ll discover patterns and standards to promote code sharing. Finally, you’ll learn how to utilize dependency injection in Xamarin.Forms. When you’re finished with this course, you’ll have the skills and knowledge of architecting Xamarin.Forms projects needed to optimally promote code reuse.

New Pluralsight Course Released!

My new Pluralsight course Sourcing Data in Microsoft Azure was just released! Here is the synopsis:

Abstract

This course targets software developers looking to source data from inside and outside of the cloud. The content will also showcase methods and tools available using Microsoft Azure.

Description

The cloud has nearly infinite compute power for processing. In this course, Sourcing Data in Microsoft Azure, you’ll learn foundational knowledge of data types, data policy, and finding data. First, you’ll learn how to register data sources with Azure Data Catalog. Next, you’ll discover how to extract, transform, and load data with Azure Data Factory. Finally, you’ll explore how to set up data processing with Azure HD Insight. When you’re finished with this course, you’ll have the skills and knowledge of the tools and processes needed to source data in Microsoft Azure. Software required: Microsoft Azure portal.

New Pluralsight Course Released!

My new Pluralsight course Deploying and Managing Models in Microsoft Azure was just released! Here is the synopsis:

Abstract

In this course, you’ll learn about how data science practitioners can utilize tools for managing the models they create. You’ll also see those tools showcased in Microsoft Azure.

Description

One of the most overlooked processes in data science is managing the life cycle of models. In this course, Deploying and Managing Models in Microsoft Azure, you’ll gain foundational knowledge of Azure Machine Learning. First, you’ll discover how to create and utilize Azure Machine Learning. Next, you’ll find out how to integrate with Azure DevOps. Finally, you’ll explore how to utilize them together to automate the deployment and management of models. When you’re finished with this course, you’ll have the skills and knowledge of model life cycle management needed to manage a machine learning project. Software required: Microsoft Azure.

New Pluralsight Courses

I’ve been busy and not able to update that I have new courses available on Pluralsight:

Developing Microsoft Azure Intelligent Edge Solutions

This course targets software developers that are looking to build edge solutions that can process data and make intelligent decisions. This course will showcase how to develop those solutions using Microsoft Azure.

Over time, what was once simply Internet of Things solutions has evolved into Edge solutions. In this course, Developing an Intelligent Edge in Microsoft Azure, you will learn foundational knowledge of edge computing, how it interacts with data and messaging systems, and how to utilize both with Microsoft Azure. First, you will learn the concepts of edge and internet of things computing. Next, you will discover how to process streaming data on hot, warm, and cold paths. Finally, you will explore how real-time and batch processing can be utilized in an edge solution. When you are finished with this course, you will have the skills and knowledge of edge and internet of things in Azure needed to architect your next edge solution. Software required: Microsoft Azure, .NET.

Building Your First Data Science Project in Microsoft Azure

This course targets software developers looking to build data science solutions that can utilize the power of the cloud. The content will also showcase how to create those solutions using Microsoft Azure.

The past five years have shown a boom in the data science field with advancements in hardware and cloud computing. In this course, Building Your First Data Science Project in Microsoft Azure, you will learn about data science and how to get started utilizing it in Microsoft Azure. First, you will learn the data science and the tools surrounding it. Next, you will discover how to create a development environment in Microsoft Azure. Finally, you will explore how to maintain and utilize that development environment. When you are finished with this course, you will have the skills and knowledge of data science to build your first data science project in Microsoft Azure. Software required: Microsoft Azure.

numpy/core/_multiarray_umath.cpython-35m-arm-linux-gnueabihf.so: undefined symbol: cblas_sgemm – Raspberry Pi

While working on a Raspberry Pi image that had been used prior by an electrical engineer to setup all of the dependencies for the hardware, there was an error when trying to upgrade to use Tensorflow. Tensorflow was needed to run a model trained with Cognitive Services: Custom Vision Service. The error was when the script imported Numpy. That caused the following error:

numpy/core/_multiarray_umath.cpython-35m-arm-linux-gnueabihf.so: undefined symbol: cblas_sgemm

To remedy this, all of the installations of Numpy had to be uninstalled. The following commands were run:

apt-get remove python-numpy
apt-get remove python3-numpy
pip3 uninstall numpy

After all three of those commands complete, Numpy was reinstalled using the package provided for raspian:

apt-get install python3-numpy

Hacking Izon Cameras and using Azure IoT Edge

After Izon announced that they were closing down their services (leaving the cameras I already owned useless), I decided to turn them into something useful using Azure. First let me list some resources:

Use the Will it hack link to get access to the mobileye website and verify that the Izon device is still streaming and still working. If it is working, you are already done with edits to the device unless you would like to change the passwords (which you should).

Our goals are as follows:

Process the video feed from the Izon camera (we will cheat this early on and only use the image feed)
- Check for motion
- Check for faces
- Check if faces are white listed
- Check for my dog
Process the audio feed
- Check for any noise
- Check for non human noises
- Check for dog barks
- Check for my and my wife’s voice

These are all stretch goals that will be referred back to as the project moves forward.

Create the Azure IoT Edge module

For the first module, we will use the C Module base image. We are looking for two things from this module:

Download the picture feed and pass it to the Edge Hub
Download the audio feed and pass it to the Edge Hub

If you don’t know where to get started with the C module of the Azure IoT Edge platform, there is helpful information on the Azure Documentation page. Once the C module is created and ready for editing, we are going to connect to the image feed from the devices. To make this simple, both feeds will be retrieved using HTTP. For the video feed, its simple enough to grab images from the Izon camera existing camera feed.

Now one thing we need, is to be able to connect to each camera within the local network shared with the Edge. Since we would like to be able to add and remove cameras, we will use the device twin to update and manage the list of IP address. The code for updating the list is as follows:

	#include <stdio.h>
	#include <stdlib.h>

	#include "iothub_module_client_ll.h"
	#include "iothub_client_options.h"
	#include "iothub_message.h"
	#include "azure_c_shared_utility/threadapi.h"
	#include "azure_c_shared_utility/crt_abstractions.h"
	#include "azure_c_shared_utility/platform.h"
	#include "azure_c_shared_utility/shared_util_options.h"
	#include "iothubtransportmqtt.h"
	#include "iothub.h"
	#include "time.h"
	#include "parson.h"

	typedef struct IP_ADDRESS_NODE
	{
	const char * address;
	struct IP_ADDRESS_NODE * next;
	} ip_address_node;

	ip_address_node * add_address(const char * address,ip_address_node * previous)
	{
	ip_address_node * new_node = (ip_address_node *)malloc(sizeof(ip_address_node));
	new_node->address = address;
	new_node->next = NULL;
	if (previous == NULL)
	{
	return new_node;
	}
	previous->next = new_node;
	return previous;
	}

	void delete_address(ip_address_node * current)
	{
	if (current == NULL)
	{
	return;
	}
	delete_address(current->next);
	//free(current->address);
	free(current);
	}

	ip_address_node * root_node = NULL;

	ip_address_node * add_address_to_root(const char * address)
	{
	if (root_node = NULL)
	{
	root_node = add_address(address,root_node);
	}
	ip_address_node * current = root_node;
	while(current->next != NULL)
	{
	current = current->next;
	}
	add_address(address,current);
	}

	static void moduleTwinCallback(DEVICE_TWIN_UPDATE_STATE update_state, const unsigned char* payLoad, size_t size, void* userContextCallback)
	{
	printf("\r\nTwin callback called with (state=%s, size=%zu):\r\n%s\r\n",
	ENUM_TO_STRING(DEVICE_TWIN_UPDATE_STATE, update_state), size, payLoad);
	JSON_Value *root_value = json_parse_string(payLoad);
	JSON_Object *root_object = json_value_get_object(root_value);
	JSON_Array * ipaddresses = json_object_dotget_array(root_object, "desired.CameraAddresses");
	if (ipaddresses != NULL) {
	delete_address(root_node);
	for (int i = 0; i < json_array_get_count(ipaddresses); i++) {
	add_address_to_root(json_array_get_string(ipaddresses,i));
	}
	return;
	}
	ipaddresses = json_object_get_array(root_object, "CameraAddresses");
	if (ipaddresses != NULL) {
	delete_address(root_node);
	for (int i = 0; i < json_array_get_count(ipaddresses); i++) {
	add_address_to_root(json_array_get_string(ipaddresses,i));
	}
	return;
	}
	}

view raw

main.c

hosted with ❤ by GitHub

With that code in place, the list of IP addresses can be updated from the Azure UI and the Azure Service SDKs.

Downloading from the Image feed

The Izon cameras make downloading the image feed trivial. There is an existing endpoint where you can grab the latest image directly from the camera’s web server. The latest image is always at /cgi-bin/img-d1.cgi. (NOTE: if you are checking this image from a browser, be sure to have some cache busting!). To download this image into our module, we will use the Curl library for it’s easy HTTP implementation. To add Curl to our Edge module, we will add the following lines to the Dockerfile.amd64.debug:

	FROM ubuntu:xenial AS base
	RUN apt-get update && \
	apt-get install -y –no-install-recommends software-properties-common gdb && \
	add-apt-repository -y ppa:aziotsdklinux/ppa-azureiot && \
	apt-get update && \
	apt-get install -y azure-iot-sdk-c-dev && \
	rm -rf /var/lib/apt/lists/*

	FROM base AS build-env
	RUN apt-get update && \
	apt-get install -y –no-install-recommends cmake gcc g++ make libcurl4-openssl-dev && \
	rm -rf /var/lib/apt/lists/*
	WORKDIR /app
	COPY . ./
	RUN cmake -DCMAKE_BUILD_TYPE=Debug .
	RUN make

	FROM base
	WORKDIR /app
	COPY –from=build-env /app ./
	CMD ["./main"]

view raw

Dockerfile.amd64.debug

hosted with ❤ by GitHub

	FROM ubuntu:xenial AS base
	RUN apt-get update && \
	apt-get install -y –no-install-recommends software-properties-common gdb && \
	add-apt-repository -y ppa:aziotsdklinux/ppa-azureiot && \
	apt-get update && \
	apt-get install -y azure-iot-sdk-c-dev && \
	rm -rf /var/lib/apt/lists/*

	FROM base AS build-env
	RUN apt-get update && \
	apt-get install -y –no-install-recommends cmake gcc g++ make && \
	rm -rf /var/lib/apt/lists/*
	WORKDIR /app
	COPY . ./
	RUN cmake -DCMAKE_BUILD_TYPE=Debug .
	RUN make

	FROM base
	WORKDIR /app
	COPY –from=build-env /app ./
	CMD ["./main"]

view raw

Dockerfile.amd64.original

hosted with ❤ by GitHub

With curl now added to the image, it can be utilized in code by adding it to the method invoked in our main loop. The code will download the file for each entry in the IP address list. Once the image is downloaded, it will send it as a message to the Edge Hub and add the IP address of the camera to the message header. Here is that code:

	struct MemoryStruct {
	char *memory;
	size_t size;
	};

	static size_t
	WriteMemoryCallback(void contents, size_t size, size_t nmemb, void userp)
	{
	size_t realsize = size * nmemb;
	struct MemoryStruct mem = (struct MemoryStruct )userp;

	char *ptr = realloc(mem->memory, mem->size + realsize + 1);
	if(ptr == NULL) {
	/* out of memory! */
	printf("not enough memory (realloc returned NULL)\n");
	return 0;
	}

	mem->memory = ptr;
	memcpy(&(mem->memory[mem->size]), contents, realsize);
	mem->size += realsize;
	mem->memory[mem->size] = 0;

	return realsize;
	}

	struct MemoryStruct download_file(const char * address)
	{
	struct MemoryStruct chunk;

	chunk.memory = malloc(1); /* will be grown as needed by the realloc above */
	chunk.size = 0; /* no data at this point */

	/* init the curl session */
	CURL * curl_handle = curl_easy_init();

	/* specify URL to get */
	curl_easy_setopt(curl_handle, CURLOPT_URL, address);

	/* send all data to this function */
	curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);

	/* we pass our 'chunk' struct to the callback function */
	curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, (void *)&chunk);

	/* some servers don't like requests that are made without a user-agent
	field, so we provide one */
	curl_easy_setopt(curl_handle, CURLOPT_USERAGENT, "libcurl-agent/1.0");

	/* get it! */
	CURLcode res = curl_easy_perform(curl_handle);

	/* check for errors */
	if(res != CURLE_OK) {
	fprintf(stderr, "curl_easy_perform() failed: %s\n",
	curl_easy_strerror(res));
	}

	/* cleanup curl stuff */
	curl_easy_cleanup(curl_handle);

	return chunk;
	}

	void download_image(IOTHUB_MODULE_CLIENT_LL_HANDLE iotHubModuleClientHandle)
	{
	ip_address_node * address_node = root_node;

	do
	{
	struct MemoryStruct image = download_file(address_node->address);

	if (image.size > 1)
	{
	IOTHUB_MESSAGE_HANDLE message_handle = IoTHubMessage_CreateFromByteArray((char*)image.memory, image.size);
	MAP_HANDLE propMap = IoTHubMessage_Properties(message_handle);
	Map_AddOrUpdate(propMap, "IpAddress", address_node->address);
	IOTHUB_CLIENT_RESULT clientResult = IoTHubModuleClient_LL_SendEventToOutputAsync(iotHubModuleClientHandle, message_handle, "IncomingImage", NULL,NULL);

	if (clientResult != IOTHUB_CLIENT_OK)
	{
	IoTHubMessage_Destroy(message_handle);
	printf("IoTHubModuleClient_LL_SendEventToOutputAsync failed on sending to output IncomingImage, err=%d\n", clientResult);
	}
	}
	free(image.memory);
	address_node = address_node->next;
	} while(address_node != NULL);
	}

view raw

main.c

hosted with ❤ by GitHub

Downloading from the Audio feed

Now that the image feed is being published to the Edge Hub, its time to connect the audio feed. The audio feed is trickier since the Izon camera doesn’t have an easy to use endpoint (that I know of) for downloading the audio samples like we can with the image feed. In the next entry in this series, an Audio feed will be derived from an RSTP stream.