So we are moving platform from MSDN To Microsoft Tech Community we have created a new blog aimed at Academics, Educators and Researcher Software Engineers!

• Join us at the new Microsoft Educator Developer Blog!

Here's what it looks like, over at the Tech Community:

Check out the Education Community Section at
https://techcommunity.microsoft.com/t5/Education-Sector/ct-p/EducationSector

Student Developer Blog at
https://techcommunity.microsoft.com/t5/Student-Developer-Blog/bg-p/StudentDeveloperBlog

This blog site will become inactive in the next few weeks so please ensure you bookmark http://aka.ms/faculty for the new URL and latest content.]]> https://docs.microsoft.com/archive/blogs/uk_faculty_connection/blobfuse-is-an-open-source-project-developed-to-provide-a-virtual-filesystem-backed-by-the-azure-blob-storage Wed, 20 Feb 2019 09:50:54 GMT https://blogs.msdn.microsoft.com/uk_faculty_connection/?p=71165

Blobfuse uses the libfuse open source library to communicate with the Linux FUSE kernel module, and implements the filesystem operations using the Azure Storage Blob REST APIs.

Features

• Mount a Blob storage container on Linux
• Basic file system operations such as mkdir, opendir, readdir, rmdir, open, read, create, write, close, unlink, truncate, stat, rename
• Local cache to improve subsequent access times
• Parallel download and upload features for fast access to large blobs
• Allows multiple nodes to mount the same container for read-only scenarios.

Installation

You can install blobfuse from the Linux Software Repository for Microsoft products. The process is explained in the blobfuse installation page. Alternatively, you can clone this repository, install the dependencies (fuse, libcurl, gcrypt and GnuTLS) and build from source code. See details in the wiki and the GitHub Repo.

Blobfuse and Data Science Virtual Machine

Blobfuse is already installed on the Ubuntu DSVM. To use it, create a configuration file /opt/blobfuse.cfg as described https://docs.microsoft.com/en-us/azure/storage/blobs/storage-how-to-mount-container-linux 
or https://github.com/Azure/azure-storage-fuse/tree/43e82df5d85a4c082dc67af8131bcf05f4d9270a

Usage

Mounting

Once you have installed blobfuse, configure your account credentials either in the template provided in blobfuse folder (connection.cfg), or in the environment variables. For brevity, let's use the environment variables:

export AZURE_STORAGE_ACCOUNT=myaccountname
export AZURE_STORAGE_ACCESS_KEY=myaccountkey

Then mount your blob storage on the VM:

Use of a high performance disk, or ramdisk for the local cache is recommended. In Azure VMs, this is the ephemeral disk which is mounted on /mnt in Ubuntu, and /mnt/resource in RHEL. Please make sure that your user has write access to this location. If not, create and chown to your user.

sudo mkdir /images
sudo mkdir /mnt/blobfusecache

chown -R <your-user-account> /images
chown -R <your-user-account> /mnt/blobfusecache/

Create your mountpoint (mkdir /path/to/mount) and mount a Blob container (must already exist) with blobfuse:

blobfuse /images --tmp-path=/mnt/blobfusecache -o big_writes -o max_read=131072 -o max_write=131072 -o attr_timeout=240 -o fsname=blobfuse -o entry_timeout=240 -o negative_timeout=120 --config-file=/opt/blobfuse.cfg

NOTE Use absolute paths for directory paths in the command. Relative, and shortcut paths (~/) do not work. Blobfuse does not support multiple writers to a single blob, so you will need to guarantee that the file names generated during the extraction part are unique.

For more information, see the wiki 

Interested in Data Engineering

Check out the Data Engineering learning resources at Microsoft learn

]]> https://docs.microsoft.com/archive/blogs/uk_faculty_connection/deploy-okpy-to-azure-paas Wed, 13 Feb 2019 18:54:34 GMT https://blogs.msdn.microsoft.com/uk_faculty_connection/?p=71135

Automate Grading & Personalize Feedback.

OK autogrades programming assignments, facilitates submission, composition feedback, and analytics for your class.

View a Demo of OkPy

The ok.py server collects submissions and displays analysis of student progress based on logging sent from client scripts the ok.py software was developed for CS 61A at UC Berkeley and is now used in numerous institutions around the world for autograding and assessment of Students.

Deploying Okpy on Azure

You can deploy Ok.py to Azure tenant using the deploy to Azure Script on this page.

In a production environment you may wish to customize these templates to share resources between environments and to adjust resource sizing. For example you may wish to use a single mySQL server with multiple databases, rather than one server per environment.

The provided templates deploy everything within the Resource Group outlined below. Items outside the resource group are an indication as to how Ok.py can integrate with additional Azure services:

Setup

Prior to deploying the template the terms and conditions for SendGrid must be accepted.

Using PowerShell:

Get-AzureRmMarketplaceTerms -Publisher "sendgrid" -Product "sendgrid_azure" -Name "free" | Set-AzureRmMarketplaceTerms -Accept

If you do not have access to PowerShell this can be run in the cloud shell via the Azure Portal.

Next, you'll need to create a Service Principal following the instructions here. The Service Principal is a credential to your Azure subscription that will enable the OKpy deployment to create Azure resources on your behalf.

Finally, grant read permissions to your Azure Container Registry instance to the Service Principal. This will enable the OKpy deployment to access Docker images for okpy and autopy in your registry and deploy them to the infrastructure set up by the template:

SP_APP_ID=<insert the app id of your okpy service principal here>
ACR_NAME=<insert name of your container registry here>
RESOURCE_GROUP=<insert the resource group of your container registry here>

az role assignment create \
  --assignee "${SP_APP_ID}" \
  --role Reader \
  --scope "$(az acr show --name "${ACR_NAME}" --resource-group "${ACR_RESOURCE_GROUP}" --query "id" --output tsv)"

Deployment

To deploy Ok.py to Azure use the deploy button below. If you are not familiar with the configuration of Azure resources please check our integration guide.

You can also run the deployment locally:

mkdir -p azure/paas/secrets
docker build -t ok-setup azure/paas
docker run -v $PWD/azure/paas/secrets:/app/secrets ok-setup

Note that the deployment can take upwards of 30 minutes to complete. After the deployment is done, remember to update your Active Directory application to include https://<app-name>.<location>.cloudapp.azure.com/login/authorized/ as a redirect URL.

If your interested in learning more about OKpy on Azure see https://github.com/okpy/ok/tree/master/azure

Microsoft Azure Dev tools for teaching offers a unified learning tools for skilling students in the cloud, it provides students with a vast set of resources.

Azure for Education offers comprehensive developer tools and training ranging from beginner to professional to support students and educators becoming skilled in Azure technologies, in addition to providing resources to get students career-ready such as LinkedIn University, Azure certification training through Microsoft Learn, and training in trending technologies such as AI and Data Science.

The Azure for Education portfolio focuses on three core offers:

• Azure for Students Starter - Provides students 13+ with free cloud and resources to get started building a web page or web app – ideal for K12 students.
• Azure for Students - Provides students 18+ with free cloud access and resources to build in-demand skills – ideal for university/college students.
• Azure Dev Tools for Teaching - Institutional access to enterprise grade developer tools and self-paced learning with path for students to add cloud access and resources.

Azure for Student now includes access to GPU resources, We suggest you choose the NC6 series based on the available credit allowance Azure for Student provides.

NC6 Virtual Machine
6 Cores
56.00 GiB RAM
1X K80 GPU

In the VM create flow, choose VM size NC6. If you don't see the opion of NC6? Check your filters.

If the option is greyed out? Try a different region,  West US 2 has a large capacity of GPUs

Azure Notebooks http://notebooks.azure.com  is a free, cloud-hosted Jupyter Notebooks solution that you can use for interactive coding in your browser.

PyTorch is preinstalled on the Azure Notebooks container, so you can start experimenting with PyTorch without having to install the framework or run your own notebook server locally. In addition, we provide a maintained library of the official, up-to-date PyTorch tutorials on Azure Notebooks which include begineer, intermediate and advanced level tutorials.

Learning or getting started with PyTorch is as easy as creating your Azure account and cloning the tutorial notebooks into your own library.

Using Visual Studio Code

Visual Studio Code (VS Code) is a popular and lightweight source code editor. Azure Machine Learning Extension is a cross-platform extension that provides deep learning and AI experimentation features for data scientists and developers using the IDE.

The tool is tightly integrated to Azure Machine Learning service, so you can submit PyTorch jobs to Azure compute, track experiment runs, and deploy your trained models all from within VS Code.

The extension also provides a rich set of syntax highlighting, automatic code completion via IntelliSense, and built-in documentation search for PyTorch APIs.

Data Science VM and Pytorch

Supported DSVM Editions - Linux
PyTorch is installed in Python 3.5.
Sample Jupyter notebooks are included, and samples can also be found in /dsvm/samples/pytorch.

At a terminal: activate the correct environment, then run Python.
In Jupyter: Connect to JupyterHub, then open the PyTorch directory for samples.

Tutorials

The Tutorials folder contains notebooks for the tutorials described in the Azure Machine Learning documentation]]> https://docs.microsoft.com/archive/blogs/uk_faculty_connection/using-the-data-science-vm-within-your-classes Tue, 12 Feb 2019 11:37:44 GMT https://blogs.msdn.microsoft.com/uk_faculty_connection/?p=71025

The Microsoft Data Science Virtual Machine or Deep Learning Virtual Machine are customized VM image on Microsoft’s Azure cloud built specifically for doing data science. It has many popular data science and other tools pre-installed and pre-configured to jump-start building intelligent applications for advanced analytics. It is available on Windows Server and Linux.

We offer Windows edition of DSVM on Server 2016 and Server 2012.
We offer Linux editions of the DSVM on Ubuntu 16.04 LTS and CentOS 7.4.

In most scenarios Institutions deploy a specific number of virtual machines and provide students SSH login to the infrastructure to undertake data science activities. Typically I advise 20 student per 1 VM NC6.

On an Azure virtual machine (VM), including the Data Science Virtual Machine (DSVM), you create local user accounts while provisioning the VM. Users then authenticate to the VM by using these credentials. If you have multiple VMs that you need to access, this approach can quickly get cumbersome as you manage credentials. Common user accounts and management through a standards-based identity provider enable you to use a single set of credentials to access multiple resources on Azure, including multiple DSVMs. As most universities now have some form of Active Directory support either with o365, you can use Azure Active Directory (Azure AD) or on-premises Active Directory to authenticate users on a standalone DSVM or a cluster of DSVMs in an Azure virtual machine scale set. You do this by joining the DSVM instances to an Active Directory domain. see  https://docs.microsoft.com/en-us/azure/machine-learning/data-science-virtual-machine/dsvm-common-identity

Building custom classroom/Lab VM images

You can also do some really neat things like develop and deploy extensions for the Data Science VMs see https://github.com/Azure/DataScienceVM/tree/master/Extensions

By using the Azure Resource manager (ARM) templates it provide a capability to define extensions for resources like Virtual Machines. VM Extensions are scripts that are run during the deployment of a VM to install additional pieces of software or reconfigure the VM to your needs or to comply with specific IT policies your company may have.

These extensions currently include

DSVM for Linux (Ubuntu) with Intel's BigDL deep learning framework extension
Azure IoT Edge on Data Science Virtual Machine
Fast.AI extension for Azure Data Science Virtual Machine

Setting up DSVM

There a lot more details and examples on DSVM setup in education at http://aka.ms/faculty - https://blogs.msdn.microsoft.com/uk_faculty_connection/?s=Data+Science and you can read more at https://azure.microsoft.com/en-us/services/virtual-machines/data-science-virtual-machines/

Here a quick over of the DSVM and DLVM Images which are available as templates for more details see https://docs.microsoft.com/en-us/azure/machine-learning/data-science-virtual-machine/overview

Some Top Tips for disk space

Ubuntu Linux (Has two disks it comes with in the VM image):

OS Disk=50GB.
2^nd Disk=100 GB disk (mounted on /data).

FREE Space about 20 GB free on main disk. There should still be about 64GB empty space on the 2^nd disk.

Windows 2016 DSVM:
One OS disk only which is 127GB.
There should have about 40GB free.

Re storage on the VM there are a few options on the Linux DSVM itself and via mounted storage. Most VMs types also have a temporary (non persistent across reboots) local SSD. In fact, this is a good place for scratch disk and is often much faster than the OS disk which are typically on an external blob (in same data center).

For working with large datasets you do need very large extra disks such as a 1TB blob storage.  For large datasets (>15GB) one might need to run a few extra steps to make it work on a Linux DSVM. see https://docs.microsoft.com/en-us/azure/virtual-machines/linux/add-disk#connect-to-the-linux-vm-to-mount-the-new-disk

On a NC6 (v1) you can only attach a HDD. On NC6 v2 and v3 you can attach a SSD.

Another option, if you just need large space, is standard Azure Files or Blobs may be good enough. Here is the tip on our github repo for mounting storage to the DSVM: https://github.com/Azure/DataScienceVM/blob/master/Tips/MountStorageonLinuxDSVM.md

Lastly, you also have a very large local non-persistent SSD. You can copy large datasets here and use it from local SSD. Only thing to note is that it may not survive reboots (so you have to redownload the file back to local SSD upon reboots or back it up on a blob or somewhere). In fact this is the fastest disk you have on the VM since it is local and an SSD.

Adding a public DNS Name to your Virtual Machine

So once you have the machines setup you can assign static DNS by following these instructions https://docs.microsoft.com/en-us/azure/virtual-machines/windows/portal-create-fqdn

Regarding seeing What the DNS Names of the servers are see https://docs.microsoft.com/en-us/azure/dns/dns-getstarted-cli

You can run the following command via the Azure CLI or cloud shell this gives a nice output the key thing is you need to know the resourcegroup name and Machine name

Az VM Show -g ResourceGroup -n MachineName -d -otable

Example

PS Azure:\> az vm show -g datajam -n lsds11 -d -otable

Name    ResourceGroup    PowerState      PublicIps    Fqdns                              Location    Zones

------  ---------------  --------------  -----------  ---------------------------------  ----------  -------

lsds11  datajam          VM deallocated               lsds11.uksouth.cloudapp.azure.com  uksouth

Giving Access to DSVM via a Jupyter Notebook

You can also simply allow your student to use Azure Notebooks http://notebooks.azure.com to build their Jupyter Notebook Experiments and then run the experiments on the Data Science VMs which have built. If you have an o365 account provided by your school or University, Azure Notebooks will discover the DSVMs that you have access to and list them into a menu under the run button. Choose the DSVM that you would like to connect to and enter the user name and password of the Linux account on the DSVM.

see https://blogs.msdn.microsoft.com/uk_faculty_connection/2018/12/10/microsoft-azure-notebooks-and-additional-compute-capacity-via-connecting-to-data-science-vms/

Again if your using Google Collab service you also easily access DSVM resources see https://github.com/Azure/DataScienceVM/blob/master/Tips/ConnectGoogleColabToDSVM.md]]> https://docs.microsoft.com/archive/blogs/uk_faculty_connection/cloud-ai-ml-apis-how-easy-is-it-to-deploy-these-on-the-edge Tue, 12 Feb 2019 11:11:35 GMT https://blogs.msdn.microsoft.com/uk_faculty_connection/?p=70995

Custom Vision Identification

The process is very easy as we use the Custom Vision (http://customvision.ai ) service to train an image classifier and then export the finished model in a number of different forms – CoreML, TensorFlow, ONNX, or dockerfile for IoT Edge/Azure Functions/Azure ML.

So the process is:

1. Use CustomVision.ai to build a model
2. Export the modal appropriately e.g. TensorFlow
3. Use boiler plate IoT Edge module code and swap in new modal files.
4. Custom test data source as appropriate and execute against models

For an end to end example see https://www.hackster.io/glovebox/image-recognition-with-azure-iot-edge-and-cognitive-services-a2b939

What can this run on?

The evolution of this is to exploit the Myriad processors from Intel by running a model – such as those provided by Intel’s OpenVino – on the Myriad processor under the control of a Pi. This has enabled some significant CNN models to be executed.

Using Containers

We are containerising our cognitive services (https://docs.microsoft.com/en-us/azure/cognitive-services/cognitive-services-container-support ), currently available are CV – OCR, Face, LUIS, Text Analytics – key phrase extraction, Text Analytics – Language Detection, Text Analytics – Sentiment analysis.

Voice Recognition

Voice recognition with key phrase activation is an interesting topic. There are of course OS features for Linux and Windows which provider this at low edge of devices – for example Raspberry Pi. Windows IoT Core has speech recognition for a number of languages and there are a number of examples of simple Voice Assistants, such an example is - https://wotudonet.wordpress.com/2016/08/04/project-patrick-build-your-own-personal-assistant/

There are also specialist chips which provide local voice processing, specifically activation word recognition, such as the XMOS chip used in the Respeaker.Io expansion board. https://www.xmos.com/

Respeaker even have a workshop for the end to end architecture of a smart speaker: https://respeaker.io/make_a_smart_speaker/

Embedded Learning Library

ELL provides models for resource constrained platforms and single-board computers. https://github.com/Microsoft/ELL

The Embedded Learning Library (ELL) allows you to design and deploy intelligent machine-learned models onto resource constrained platforms and small single-board computers, like Raspberry Pi, Arduino, and micro:bit. The deployed models run locally, without requiring a network connection and without relying on servers in the cloud. ELL is an early preview of the embedded AI and machine learning technologies developed at Microsoft Research.

Go to our website for tutorials, instructions, and a gallery of pretrained ELL models for use in your projects.

• 15^th December: Quantum Perceptrons (Frances)
  • Learn (in comic form!) how to implement a quantum perceptron, from creating a dataset through to classification of that data
  • Designed to supplement the Introduction to Quantum Machine Learning workshop run at the Machine Learning, AI & Data Science (MLADS) conference 2018
• 18^th December: Gro-ho-ho-ver's Algorithm: How Quantum Computing Saved Christmas (Anita) (non-festive version can be found here)
  • Learn how Grover's algorithm works in this step-by-step breakdown, plus how you can implement it using Q#
  • Designed to supplement the official Microsoft sample for Grover's algorithm

To learn how to use managed identities to access different Azure resources, try these tutorials.

Learn how to use a managed identity with a Windows VM:

• Access Azure Data Lake Store
• Access Azure Resource Manager
• Access Azure SQL
• Access Azure Storage by using an access key
• Access Azure Storage by using shared access signatures
• Access a non-Azure AD resource with Azure Key Vault

Learn how to use a managed identity with a Linux VM:

• Access Azure Data Lake Store
• Access Azure Resource Manager
• Access Azure Storage by using an access key
• Access Azure Storage by using shared access signatures
• Access a non-Azure AD resource with Azure Key Vault

Learn how to use a managed identity with other Azure services:

• Azure App Service
• Azure Functions
• Azure Logic Apps
• Azure Service Bus
• Azure Event Hubs
• Azure API Management
• Azure Container Instances

Using MSI for providing student access to Azure ML Workspace from a dedicated Data Science Virtual Machines

Typically courses provide a fixed pool of resources for students to utilise.

Pooled Resources

Many academics are providing Azure Data Science VM (DSVM) for the class.

Using Managed Services Identity

When you create the VM with a MSI and give it permission to the resource group where you have the Azure ML Workspace. In this scenario any local user on the DSVM (students in the lab) can access the Azure ML Workspace without having a dedicated Azure subscription credentials.

The Students simply need to authenticate to the Virtual Machine (using local auth/AD/Shibboleth). 

Below is the sample code to do add Managed Service Identity to create or attach to a Azure ML Workspace with the change from usual highlighted.

Ref: https://docs.microsoft.com/en-us/azure/active-directory/managed-identities-azure-resources/overview

Deploy cheaper low priority (preemptable) instances of Ubuntu Data Science Virtual Machine ‘DSVM’ using the Microsoft Azure portal

Deploy to Azure via Github

-We have a set of deploy to Azure Scripts available to deploy the low priority VM simply click the link below

There are additional scripts here on the DSVM GitHub repo for deploying Linux or Windows versions This template uses a Scale set to deploy a single VM low priority.

For example: NC6 (1 K80 GPU) low-priority (preemptible) instance costs $0.18/hour compared to $0.90/hour for a dedicated instance (depending on region).

Please note this template is setup to delete the disks upon eviction. So you want to save any data on the VM externally if you need to, on a blob or Azure files. You can update the template to set eviction policy to “deallocate” to keep the disks (storage costs apply). 

Low Priority Pricing

See low priority instance pricing for the latest price for the specific region. Right now, low priority instances are only available behind a VM Scale set pool. 

Adding Custom Features

The template can be found here on the DSVM GitHub repo if you want to customize it.

Low-priority VMs’ Anatomy

Microsoft grants access to their spare capacity in each region. The amount of spare capacity varies by region and VM size according to multiple factors, including day of week, time of day, and demand for different VM sizes.

With low-priority VMs, Microsoft effectively lets you take advantage of unused capacity for a great price. The datacentre team can reclaim these VMs at any given moment due to higher priority allocations so the capacity isn't fixed.

Using Batch Pools & VM Scale sets

Low-priority VMs can be easily purchased via Azure Batch, a service that lets you run jobs and tasks across multiple compute pools, “Batch pools”.

However a Batch pool is not needed to create a single Virtual Machine such as  DSVM on a Low Priority instance. All you need is a VM Scaleset. The  DSVM Low priority template at the start of the blog creates a VM Scale set does this automatically.

Creating a VM using Low Priority with the Portal

You can create VMSS with low priority instance on the Azure Portal using Azure Virtual Machine Scale set

Select New Marketplace Virtual Machine Scale set and select the deploy as low priority. – YES

Using a BatchPool

Each Batch pool can contain both on-demand and low-priority nodes which can be independently scaled.

Pricing

Low-priority Linux VMs come with 80% discount while the Windows VMs come with 60% discount. The discount is calculated in comparison to their On-Demand hourly price. The vast majority of VM sizes and types are supported to run as Low-priority VMs.

So we have seen many academics keen to use Low-priority VMs to run and scale their course or research infrastructure cost-effectively.

Here are some examples of common use cases that are suitable for Low-priority VMs.

• Web Services
• Testing
• CI/CD Pipelines
• Containers Platforms (Kubernetes, Mesos, Docker Swarm, etc..)
• Batch jobs such as Media processing, Transcoding, and Rendering.
• Batch jobs such as Machine Learning Data Science.

We look forward to helping you to get started and consuming Low-priority VMs on Microsoft Azure and achieve business agility, cost savings, and scale.]]>