DEV Community: Kinfey Lo

.NET Core in Artificial Intelligence Series-Introduction to .NET Interactive

Kinfey Lo — Thu, 26 Aug 2021 06:48:22 +0000

Before entering the artificial intelligence application of .NET Core, we first set up the environment to provide a convenience for future learning.

As a .NET programmer, or programmer of other programming languages, I believe that the dependence on IDE is essential, such as Visual Studio/Visual Studio Code, IntelliJ, Eclipse, etc. But for a person engaged in data science, compared with traditional programming, they prefer to use Notebook as the main tool for data science work. Through the overview of the study, you may know this important point of knowledge, but the specifics still have to be introduced to you as follows. Environment configuration, we also start from .NET Interactive.

Why use Jupyter Notebook?

Let’s take a look at what Jupyter Notebook is. Jupyter is a free, open source, interactive network tool called a computing notebook. Researchers can use it to combine software code, computing output, explanatory text, and multimedia resources in a single document. Jupyter Notebook has the following features:

Data analysis: Jupyter Notebook allows users to view the results of the code online without relying on other parts of the code. In the notebook, you can check each cell of the code at any time to draw the output. Therefore, unlike traditional IDEs, Jupyter Notebook facilitates online printouts, which is very useful for exploratory data analysis (EDA) processes.

Each cell has a cache: It is difficult for traditional development tools to retain the execution status of each line, but Jupyter Notebook can cache the results of each line-whether it is the local code for training the ML model or remotely The code downloaded by the service.

It has nothing to do with programming language: It supports multiple languages and multiple formats.

Data visualization: As a component, Jupyter Notebook supports visualization and includes rendering some data sets, such as graphs and charts, which are generated from code with the help of modules such as Matplotlib, Plotly or Bokeh. Jupyter allows users to visualize narratives while sharing code and data sets, enabling others to make interactive changes.

Real-time interaction with code: Jupyter Notebook uses the "ipywidgets" package, which provides a standard user interface for exploring the interactivity of code and data. Therefore, the code can be edited by the user or sent to re-run, making the Jupyter code non-static. It allows the user to control the input source of the code and provide feedback directly on the browser.

Record code examples: Jupyter allows users to easily explain their code line by line with feedback. Even better, with Jupyter, users can add interactivity and explanation, while the code is fully functional.

Introduce .NET Interactive

.NET Interactive is a more flexible way of code interaction, focusing on data browsing and sorting. You can think of it as a .NET plugin under Jupyter Notebook. If you have ever been try Xamarin, you will find that it is very similar to Xamarin Workbooks. You can write simple code through .NET Interactive, and you can also introduce related packages through Nuget, allowing you to perform better in data analysis, code exploration, and machine learning scenarios. You are familiar with .NET Core technology.

.NET Interactive is a plug-in developed by the .NET team, which can support the use of traditional Jupyter Notebook pages, or you can install the plug-in of .NET Interactive through Visual Studio Code to develop directly in the IDE.

Install .NET Interactive

The installation of .NET Interactive requires Python and the installation of JupyterNotebook, so you need to install Python on your machine (it is recommended to install the 3.8.x Python version), if you install Python successfully, you need to install it through the command line

pip3 install jupyter

After the installation is successful, don’t forget to install .NET Core on this machine. .NET Interactive supports the .NET Core 3.x+ version (it is recommended to install the .NET Core 5.x version on this machine). After the installation is successful, you can use the dotnet tool .NET Interactive is installed

dotnet tool install --global Microsoft.dotnet-interactive

Note: dotnet tool needs to configure the global PATH, otherwise it will affect the operation of dotnet-interactive (for the dotnet tool path documentation, please refer to https://docs.microsoft.com/en-us/dotnet/core/tools/dotnet-tool-install)

Bind .NET Interactive to Jupyter Notebook

dotnet-interactive jupyter install

Check whether .NET Interactive has been added to the support environment of Jupyter Notebook by running the following command:

jupyter kernelspec list

After completing the above related operations, you can directly call .NET Interactive through Jupyter Notebook to use C#/F# to complete data science work.

You can run it through the command line

jupyter notebook

Notice:

If you are running jupyter notebook for the first time, you may be prompted to enter a password, you can complete the password modification work through the following link

https://jupyter-notebook.readthedocs.io/en/stable/public_server.html

If you want to get more knowledge of Jupyter Notebook, you can visit the following link

https://jupyter-notebook.readthedocs.io/en/stable/

You can also run the Notebook application directly after installing .NET Interactive through Visual Studio Code.

Sample A

Create a folder anywhere on the command line of the machine, then enter the folder and input jupyter notebook directly

mkdir demoapp
cd demoapp
jupyter notebook

Open the browser and enter http://localhost:8888

Create a new notebook file by clicking New and selecting C#

input these codes cell by cell

using System;
using System.Text.Json;
using System.Text.Json.Serialization;

public class ReactorInfo
{
    public string Name { get; set; }
    public string Title { get; set; }
}

var info = new ReactorInfo{ Name = "Kinfey", Title ="Reactor Guest" };

string infoString = JsonSerializer.Serialize(info);

Console.WriteLine(infoString);

Note here that through the "+" in the menu bar to increase the line

Then press Run to run the code line by line, you can see the following results

Sample B

Create a .ipynb file in Visual Studio Code (.ipynb is the default file of Notebook), and then add the RazorInteractive library through nuget (RazorInteractive is a Razor template that allows you to write interactively under .NET Interactive)

#r "nuget: RazorInteractive, 1.0.5"

After the import is successful, add the following code in each line

#!razor

@{
    var colors = new [] { "red", "green", "blue" };
}

<ol>
@foreach(var color in colors)
{
    <li style="color: @color;">@color</li>
}
</ol>

var firstname = "John";
var lastname = "Doe";
var colors = new [] { "red", "green", "blue" };

#!razor

<p>Hello <b>@Model.firstname @Model.lastname</b>, what is you favorite a color?</p>

<ol>
@foreach(var color in Model.colors)
{
    <li style="color: @color;">@color</li>
}
</ol>

Each line is executed, you can see the following results

NET Interactive makes your .NET programming interesting, provides you with more convenient support in some experimental environments and some teaching, and combined with future learning, you can easily complete data interaction operations and make .NET programs It’s easier for employees to complete data science tasks. Everyone quickly try it.

.NET Core In Artificial Intelligence Series-Overview

Kinfey Lo — Wed, 18 Aug 2021 04:26:40 +0000

Hi .NET Developer, this is a series of how to complete artificial intelligence applications under .NET Core, and hope to provide a guide for .NET Developer to enter the field of artificial intelligence.

.NET Core is already a technology stack solution for full-scene applications, with support for every field. Since Microsoft's efforts in open source, the community capabilities of .NET Core have also been supplemented.

Artificial intelligence is a global hotspot. In artificial intelligence, the Python language is the first world. There are many technical barriers for many .NET programmers to enter this field. Of course, some people will mention why we need to use .NET for machine learning? For a team, there is technical continuity. If you want to invest in a new field, you must ensure the technical cost. If you want to recruit a Python team, it will cost a lot. What can be done with the original technology is the best solution, and it can continue the creativity of the original team. It is also very good for individuals to better apply the experience accumulated in the past in new fields.

What can .NET Core do in artificial intelligence at this stage? How is the ecology? The following are some related technologies in native .NET Core artificial intelligence scenarios

.NET Interactive

In traditional data science, data scientists like to use Jupyter Notebook as the main environmental tool. (Jupyter notebook is a web application that allows users to combine explanatory text, mathematical equations, code, and visual content into one easy-to-share document.) .NET Interactive is an extension of Jupyter Notebook that allows .NET Developers to work in Jupyter Use C#/F# to do data-related work on Notebook.

NumSharp

In Python, we need to use Numpy to do a large amount of data processing, complete matrix operations, and multi-dimensional data conversion. NumSharp is an open source .NET Core version of Numpy provided by a third party. (Github https://github.com/SciSharp/NumSharp)

.NET DataFrame

In data science, data analysis is a very important part, and Pandas is an important tool in the Python scenario. For .NET Core, data analysis is done through DataFrame, allowing you to understand and adjust data faster.

XPlot

Through XPlot, you can generate different charts from the data and find out the characteristics of the data.(Github https://fslab.org/XPlot/plotly.html)

.NET for Apache Spark

.NET Core natively supports Apache Spark for big data processing

ML.NET

ML.NET is Microsoft's machine learning framework, which provides an easy way to train, create, and run models in the .NET ecosystem. This is great news for .NET developers, because it allows you to reuse all the knowledge, skills, code, and libraries you already have as a .NET developer. However, this is not just a framework for .NET developers. In fact, ML.NET has proven itself to be a great end-to-end tool that enables any developer to create complex pipelines and bind to different data sources.

TensorFlow.NET

TensorFlow.NET (TF.NET) provides .NET Standard bindings for TensorFlow. It aims to implement a complete Tensorflow API in C#, allowing .NET developers to use the cross-platform .NET Standard framework to develop, train, and deploy machine learning models. TensorFlow.NET has built-in Keras high-level interface and is released as an independent package TensorFlow.Keras. (Github https://github.com/SciSharp/TensorFlow.NET)

TensorFlowSharp

TensorFlowSharp is a TensorFlow model runtime. Compared with TensorFlow.NET, it lacks many functions such as graph calculation and training. (Github https://github.com/migueldeicaza/TensorFlowSharp)

TorchSharp

TorchSharp is a .NET library that provides access to libraries that support PyTorch. (Github https://github.com/xamarin/TorchSharp)

Through the above-mentioned native libraries, you can complete related technologies through C#/F#. This series will start with the most basic knowledge, including environment construction, basic concepts, machine learning related algorithms, and deep learning, hoping to make .NETer more Good to learn the knowledge of artificial intelligence.

ps:The book update is also synchronized on Github (https://github.com/kinfey/DotMLBooks)