Microsoft PyTorch Fundamentals [Aug 2025 Update]

[GeorgeS2019]

Aug 2025

thefrederiksen/CSnakesCourse#1

We now have the opportunities to figure out how to port Pytorch project to .NET using either or combination of TorchSharp and CSNAKES. The dotnet is also implementing new Tensor features that make Dotnet more approachable to machine learning and generative AI for .NET community.

---

Old discussion

https://learn.microsoft.com/en-us/training/paths/pytorch-fundamentals/

PyTorch Fundamentals

Introduction to PyTorch

Introduction to Natural Language Processing with PyTorch

Introduction to audio classification with PyTorch

we need to explore if the existing TorchSharp could deliver everything needed for this Microsoft Pytorch Fundamental course through TorchSharp. If not, then we need to add PRs to addressing the missing codes.

References

• Learn PyTorch Fundamentals With Microsoft Learn

[GeorgeS2019]

@whuanle
Please explore the requirements if your current work could contribute to this.

[GeorgeS2019]

@kaiidams

could you please check if the latest Torchsharp has everything needed to provide the course on: Introduction to audio classification with PyTorch

Reference:
#598

[whuanle]

I am still sorting out the article, and will release the ebook tutorial after some time.
@GeorgeS2019 GeorgeS2019

[GeorgeS2019]

Explore and analyze data with Python

Introduction
2 min
Explore data with NumPy and Pandas
3 min
Exercise - Explore data with NumPy and Pandas
12 min
Visualize data
3 min
Exercise - Visualize data with Matplotlib
10 min
Examine real world data
3 min
Exercise - Examine real world data
12 min
Knowledge check
3 min
Summary

For people new to Torchsharp, many of these python libraries needed for python for data science already exist in .NET.

[GeorgeS2019]

Explore data with NumPy and Pandas

12 min

Python Code

import numpy as np

data = [50, 50, 47, 97, 49, 3, 53, 42, 26, 74, 82, 62, 37, 15, 70, 27, 36, 35, 48, 52, 63, 64]
print(data)

grades = np.array(data)
print(grades)

print(type(data), 'x 2:', data * 2)
print('---')
print(type(grades), 'x 2:', grades * 2)

grades.shape
grades[0]
grades.mean()

study_hours = [10.0, 11.5, 9.0, 16.0, 9.25, 1.0, 11.5, 9.0, 8.5, 14.5, 15.5, 13.75, 9.0, 8.0, 15.5, 8.0, 9.0, 6.0, 10.0, 12.0, 12.5, 12.0]
student_data = np.array([study_hours, grades])
student_data

student_data.shape
student_data[0][0]
avg_study = student_data[0].mean()
avg_grade = student_data[1].mean()
print('Average study hours: {:.2f}\\nAverage grade: {:.2f}'.format(avg_study, avg_grade))

import pandas as pd

df_students = pd.DataFrame({
    'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic', 'Jimmie', 'Rhonda', 'Giovanni', 'Francesca', 'Rajab', 'Naiyana', 'Kian', 'Jenny', 'Jakeem', 'Helena', 'Ismat', 'Anila', 'Skye', 'Daniel', 'Aisha'],
    'StudyHours': student_data[0],
    'Grade': student_data[1]
})
df_students

df_students.loc[5]
df_students.loc[0:5]
df_students.iloc[0:5]
df_students.iloc[0, [1, 2]]
df_students.loc[0, 'Grade']
df_students.loc[df_students['Name'] == 'Aisha']
df_students[df_students['Name'] == 'Aisha']
df_students.query('Name=="Aisha"')
df_students[df_students.Name == 'Aisha']

df_students = pd.read_csv('grades.csv', delimiter=',', header='infer')
df_students.head()

df_students.isnull()
df_students.isnull().sum()
df_students[df_students.isnull().any(axis=1)]
df_students.StudyHours = df_students.StudyHours.fillna(df_students.StudyHours.mean())
df_students = df_students.dropna(axis=0, how='any')
df_students

mean_study = df_students['StudyHours'].mean()
mean_grade = df_students.Grade.mean()
print('Average weekly study hours: {:.2f}\\nAverage grade: {:.2f}'.format(mean_study, mean_grade))

df_students[df_students.StudyHours > mean_study]
df_students[df_students.StudyHours > mean_study].Grade.mean()

passes = pd.Series(df_students['Grade'] >= 60)
df_students = pd.concat([df_students, passes.rename("Pass")], axis=1)
print(df_students.groupby(df_students.Pass).Name.count())
print(df_students.groupby(df_students.Pass)[['StudyHours', 'Grade']].mean())

df_students = df_students.sort_values('Grade', ascending=False)
df_students

C# Code using TorchSharp and other libraries

Using TorchSharp for NumPy-like operations

using System;
using System.Linq;
using TorchSharp;
using TorchSharp.Tensor;
using Microsoft.Data.Analysis;

class Program
{
    static void Main(string[] args)
    {
        // Using TorchSharp for NumPy-like operations
        var data = new float[] { 50, 50, 47, 97, 49, 3, 53, 42, 26, 74, 82, 62, 37, 15, 70, 27, 36, 35, 48, 52, 63, 64 };
        Console.WriteLine(string.Join(", ", data));

        var grades = torch.tensor(data);
        Console.WriteLine(grades);

        Console.WriteLine($"{data.GetType()} x 2: {string.Join(", ", data.Select(x => x * 2))}");
        Console.WriteLine("---");
        Console.WriteLine($"{grades.GetType()} x 2: {grades.mul(2)}");

        Console.WriteLine($"Shape: {grades.shape}");
        Console.WriteLine($"First element: {grades[0]}");
        Console.WriteLine($"Mean: {grades.mean()}");

        var study_hours = new float[] { 10.0f, 11.5f, 9.0f, 16.0f, 9.25f, 1.0f, 11.5f, 9.0f, 8.5f, 14.5f, 15.5f, 13.75f, 9.0f, 8.0f, 15.5f, 8.0f, 9.0f, 6.0f, 10.0f, 12.0f, 12.5f, 12.0f };
        var student_data = torch.stack(new[] { torch.tensor(study_hours), grades });
        Console.WriteLine(student_data);

        Console.WriteLine($"Shape: {student_data.shape}");
        Console.WriteLine($"First element of the first element: {student_data[0][0]}");

        var avg_study = student_data[0].mean();
        var avg_grade = student_data[1].mean();
        Console.WriteLine($"Average study hours: {avg_study:F2}\nAverage grade: {avg_grade:F2}");

        // Using DataFrame for Pandas-like operations
        var names = new string[] { "Dan", "Joann", "Pedro", "Rosie", "Ethan", "Vicky", "Frederic", "Jimmie", "Rhonda", "Giovanni", "Francesca", "Rajab", "Naiyana", "Kian", "Jenny", "Jakeem", "Helena", "Ismat", "Anila", "Skye", "Daniel", "Aisha" };
        var df_students = new DataFrame(new StringDataFrameColumn("Name", names),
                                        new PrimitiveDataFrameColumn<float>("StudyHours", study_hours),
                                        new PrimitiveDataFrameColumn<float>("Grade", data));

        Console.WriteLine(df_students);

        Console.WriteLine(df_students.Rows[5]);
        Console.WriteLine(df_students.Head(6));
        Console.WriteLine(df_students.Head(5));
        Console.WriteLine(df_students[0, new int[] { 1, 2 }]);
        Console.WriteLine(df_students["Grade"][0]);
        Console.WriteLine(df_students[df_students["Name"].ElementwiseEquals("Aisha")]);
        Console.WriteLine(df_students[df_students["Name"].ElementwiseEquals("Aisha")]);
        Console.WriteLine(df_students.Filter("Name == \"Aisha\""));
        Console.WriteLine(df_students[df_students["Name"].ElementwiseEquals("Aisha")]);

        // Assuming 'grades.csv' is available in the working directory
        var df_students_csv = DataFrame.LoadCsv("grades.csv");
        Console.WriteLine(df_students_csv.Head());

        Console.WriteLine(df_students_csv.IsNull());
        Console.WriteLine(df_students_csv.IsNull().Sum());
        Console.WriteLine(df_students_csv.Filter(df_students_csv.IsNull().Any(axis: 1)));
        df_students_csv["StudyHours"] = df_students_csv["StudyHours"].FillNulls(df_students_csv["StudyHours"].Mean());
        df_students_csv = df_students_csv.DropNulls(axis: 0, how: "any");
        Console.WriteLine(df_students_csv);

        var mean_study = df_students_csv["StudyHours"].Mean();
        var mean_grade = df_students_csv["Grade"].Mean();
        Console.WriteLine($"Average weekly study hours: {mean_study:F2}\nAverage grade: {mean_grade:F2}");

        Console.WriteLine(df_students_csv[df_students_csv["StudyHours"] > mean_study]);
        Console.WriteLine(df_students_csv[df_students_csv["StudyHours"] > mean_study]["Grade"].Mean());

        var passes = new PrimitiveDataFrameColumn<bool>("Pass", df_students_csv["Grade"] >= 60);
        df_students_csv.Columns.Add(passes);
        Console.WriteLine(df_students_csv.GroupBy("Pass").Count());
        Console.WriteLine(df_students_csv.GroupBy("Pass").Mean());

        df_students_csv = df_students_csv.Sort("Grade", ascending: false);
        Console.WriteLine(df_students_csv);
    }
}

[GeorgeS2019]

Exploring data with Python - visualize data

using System;
using System.Linq;
using TorchSharp;
using TorchSharp.Tensor;
using Microsoft.Data.Analysis;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;
using XPlot.Plotly;

class Program
{
    static async Task Main(string[] args)
    {
        // Load data from a text file
        var url = "https://raw.githubusercontent.com/MicrosoftDocs/mslearn-introduction-to-machine-learning/main/Data/ml-basics/grades.csv";
        var httpClient = new HttpClient();
        var csvData = await httpClient.GetStringAsync(url);
        File.WriteAllText("grades.csv", csvData);

        var df_students = DataFrame.LoadCsv("grades.csv");
        df_students = df_students.DropNulls(axis: 0, how: "any");

        // Calculate who passed, assuming '60' is the grade needed to pass
        var passes = new PrimitiveDataFrameColumn<bool>("Pass", df_students["Grade"] >= 60);
        df_students.Columns.Add(passes);

        Console.WriteLine(df_students);

        // Visualize data using XPlot.Plotly
        var names = df_students["Name"].Cast<string>().ToArray();
        var grades = df_students["Grade"].Cast<float>().ToArray();

        var barChart = new Bar
        {
            x = names,
            y = grades,
            marker = new Marker { color = "orange" }
        };

        var chart = Chart.Plot(barChart);
        chart.WithTitle("Student Grades");
        chart.WithXTitle("Student");
        chart.WithYTitle("Grade");
        chart.WithGrid(color: "#95a5a6", linestyle: "--", linewidth: 2, axis: "y", alpha: 0.7);
        chart.WithXTickAngle(90);
        chart.Show();

        // Create a pie chart of pass counts
        var passCounts = df_students["Pass"].ValueCounts();
        var pieChart = new Pie
        {
            labels = passCounts.Keys.ToArray(),
            values = passCounts.Values.ToArray()
        };

        var pie = Chart.Plot(pieChart);
        pie.WithTitle("Passing Grades");
        pie.Show();

        // Create a histogram
        var varData = df_students["Grade"].Cast<float>().ToArray();
        var histogram = new Histogram
        {
            x = varData
        };

        var histChart = Chart.Plot(histogram);
        histChart.WithTitle("Data Distribution");
        histChart.WithXTitle("Value");
        histChart.WithYTitle("Frequency");
        histChart.Show();

        // Create a box plot
        var boxPlot = new Box
        {
            y = varData
        };

        var boxChart = Chart.Plot(boxPlot);
        boxChart.WithTitle("Data Distribution");
        boxChart.Show();
    }
}

[GeorgeS2019]

Examine real world data

using System;
using System.Linq;
using TorchSharp;
using TorchSharp.Tensor;
using Microsoft.Data.Analysis;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;
using XPlot.Plotly;

class Program
{
    static async Task Main(string[] args)
    {
        // Load data from a text file
        var url = "https://raw.githubusercontent.com/MicrosoftDocs/mslearn-introduction-to-machine-learning/main/Data/ml-basics/grades.csv";
        var httpClient = new HttpClient();
        var csvData = await httpClient.GetStringAsync(url);
        File.WriteAllText("grades.csv", csvData);

        var df_students = DataFrame.LoadCsv("grades.csv");
        df_students = df_students.DropNulls(axis: 0, how: "any");

        // Calculate who passed, assuming '60' is the grade needed to pass
        var passes = new PrimitiveDataFrameColumn<bool>("Pass", df_students["Grade"] >= 60);
        df_students.Columns.Add(passes);

        Console.WriteLine(df_students);

        // Visualize data using XPlot.Plotly
        var names = df_students["Name"].Cast<string>().ToArray();
        var grades = df_students["Grade"].Cast<float>().ToArray();

        var barChart = new Bar
        {
            x = names,
            y = grades,
            marker = new Marker { color = "orange" }
        };

        var chart = Chart.Plot(barChart);
        chart.WithTitle("Student Grades");
        chart.WithXTitle("Student");
        chart.WithYTitle("Grade");
        chart.WithGrid(color: "#95a5a6", linestyle: "--", linewidth: 2, axis: "y", alpha: 0.7);
        chart.WithXTickAngle(90);
        chart.Show();

        // Create a pie chart of pass counts
        var passCounts = df_students["Pass"].ValueCounts();
        var pieChart = new Pie
        {
            labels = passCounts.Keys.ToArray(),
            values = passCounts.Values.ToArray()
        };

        var pie = Chart.Plot(pieChart);
        pie.WithTitle("Passing Grades");
        pie.Show();

        // Create a histogram
        var varData = df_students["Grade"].Cast<float>().ToArray();
        var histogram = new Histogram
        {
            x = varData
        };

        var histChart = Chart.Plot(histogram);
        histChart.WithTitle("Data Distribution");
        histChart.WithXTitle("Value");
        histChart.WithYTitle("Frequency");
        histChart.Show();

        // Create a box plot
        var boxPlot = new Box
        {
            y = varData
        };

        var boxChart = Chart.Plot(boxPlot);
        boxChart.WithTitle("Data Distribution");
        boxChart.Show();

        // Show distribution function
        void ShowDistribution(Tensor<float> varData)
        {
            var minVal = varData.min();
            var maxVal = varData.max();
            var meanVal = varData.mean();
            var medVal = varData.median();
            var modVal = varData.mode()[0];

            Console.WriteLine($"Minimum: {minVal:F2}\nMean: {meanVal:F2}\nMedian: {medVal:F2}\nMode: {modVal:F2}\nMaximum: {maxVal:F2}\n");

            var fig = new Figure();
            var ax1 = fig.AddSubplot(2, 1, 1);
            ax1.Histogram(varData);
            ax1.SetYLabel("Frequency");
            ax1.Axvline(minVal, color: "gray", linestyle: "dashed", linewidth: 2);
            ax1.Axvline(meanVal, color: "cyan", linestyle: "dashed", linewidth: 2);
            ax1.Axvline(medVal, color: "red", linestyle: "dashed", linewidth: 2);
            ax1.Axvline(modVal, color: "yellow", linestyle: "dashed", linewidth: 2);
            ax1.Axvline(maxVal, color: "gray", linestyle: "dashed", linewidth: 2);

            var ax2 = fig.AddSubplot(2, 1, 2);
            ax2.Boxplot(varData, vert: false);
            ax2.SetXLabel("Value");

            fig.Suptitle("Data Distribution");
            fig.Show();
        }

        ShowDistribution(df_students["Grade"].Cast<float>().ToTensor());

        // Show density function
        void ShowDensity(Tensor<float> varData)
        {
            var fig = new Figure();
            var density = varData.Density();
            fig.Plot(density);
            fig.SetTitle("Data Density");
            fig.Axvline(varData.mean(), color: "cyan", linestyle: "dashed", linewidth: 2);
            fig.Axvline(varData.median(), color: "red", linestyle: "dashed", linewidth: 2);
            fig.Axvline(varData.mode()[0], color: "yellow", linestyle: "dashed", linewidth: 2);
            fig.Show();
        }

        ShowDensity(df_students["StudyHours"].Cast<float>().ToTensor());

        // Calculate range, variance, and standard deviation
        foreach (var colName in new[] { "Grade", "StudyHours" })
        {
            var col = df_students[colName].Cast<float>().ToTensor();
            var rng = col.max() - col.min();
            var var = col.var();
            var std = col.std();
            Console.WriteLine($"\n{colName}:\n - Range: {rng:F2}\n - Variance: {var:F2}\n - Std.Dev: {std:F2}");
        }

        // Gaussian KDE
        var gradeCol = df_students["Grade"].Cast<float>().ToTensor();
        var density = gradeCol.Density();
        var s = gradeCol.std();
        var m = gradeCol.mean();

        var x1 = new[] { m - s, m + s };
        var y1 = density(x1);
        var x2 = new[] { m - 2 * s, m + 2 * s };
        var y2 = density(x2);
        var x3 = new[] { m - 3 * s, m + 3 * s };
        var y3 = density(x3);

        var figDensity = new Figure();
        figDensity.Plot(density);
        figDensity.Plot(x1, y1, color: "magenta");
        figDensity.Annotate("1 std (68.26%)", x1[1], y1[1]);
        figDensity.Plot(x2, y2, color: "green");
        figDensity.Annotate("2 std (95.45%)", x2[1], y2[1]);
        figDensity.Plot(x3, y3, color: "orange");
        figDensity.Annotate("3 std (99.73%)", x3[1], y3[1]);
        figDensity.Axvline(m, color: "cyan", linestyle: "dashed", linewidth: 1);
        figDensity.AxisOff();
        figDensity.Show();

        // Describe data
        Console.WriteLine(df_students.Describe());

        // Boxplot
        var dfSample = df_students.Filter(df_students["StudyHours"] > 1);
        dfSample.Boxplot("StudyHours", by: "Pass", figsize: (8, 5));

        // Bar plot
        dfSample.Plot("Name", new[] { "Grade", "StudyHours" }, kind: "bar", figsize: (8, 5));

        // Normalize data
        var scaler = new MinMaxScaler();
        var dfNormalized = dfSample[["Name", "Grade", "StudyHours"]].Copy();
        dfNormalized[["Grade", "StudyHours"]] = scaler.FitTransform(dfNormalized[["Grade", "StudyHours"]]);
        Console.WriteLine(dfNormalized["Grade"].Corr(dfNormalized["StudyHours"]));

        // Scatter plot
        dfSample.PlotScatter("StudyHours", "Grade", title: "Study Time vs Grade");

        // Linear regression
        var dfRegression = dfSample[["Grade", "StudyHours"]].Copy();
        var (m, b, r, p, se) = dfRegression.LinearRegression("StudyHours", "Grade");
        Console.WriteLine($"slope: {m:F4}\ny-intercept: {b:F4}");
        Console.WriteLine($"so...\n f(x) = {m:F4}x + {b:F4}");

        // Define regression function
        float F(float x) => m * x + b;

        var studyTime = 14;
        var prediction = F(studyTime);
        Console.WriteLine($"Prediction for {studyTime} hours of study: {prediction:F2}");
    }
}

[whuanle]

I have verified and implemented some functions, and I expect to finish the related tutorial and code class library within February.

[whuanle]

https://torch.whuanle.cn/
https://github.com/whuanle/Maomi.Torch