Microsoft PyTorch Fundamentals #1430

GeorgeS2019 · 2024-12-31T05:33:31Z

GeorgeS2019
Dec 31, 2024

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 · 2024-12-31T05:35:39Z

GeorgeS2019
Dec 31, 2024
Author

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

2 replies

GeorgeS2019 Dec 31, 2024
Author

@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 Jan 7, 2025

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

GeorgeS2019 · 2024-12-31T05:45:20Z

GeorgeS2019
Dec 31, 2024
Author

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.

3 replies

GeorgeS2019 Feb 4, 2025
Author

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 Feb 4, 2025
Author

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 Feb 4, 2025
Author

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 · 2025-02-03T05:50:12Z

whuanle
Feb 3, 2025

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

0 replies

whuanle · 2025-02-06T00:52:46Z

whuanle
Feb 6, 2025

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

0 replies

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Microsoft PyTorch Fundamentals #1430

{{title}}

{{editor}}'s edit

{{editor}}'s edit

Replies: 4 comments 5 replies

{{title}}

{{editor}}'s edit

{{editor}}'s edit

{{title}}

{{title}}

{{title}}

{{editor}}'s edit

{{editor}}'s edit

{{title}}

{{editor}}'s edit

{{editor}}'s edit

{{title}}

{{title}}

{{title}}

{{title}}

Select a reply

Microsoft PyTorch Fundamentals #1430

PyTorch Fundamentals

References

Replies: 4 comments · 5 replies

GeorgeS2019 Dec 31, 2024 Author

GeorgeS2019 Dec 31, 2024 Author

GeorgeS2019 Dec 31, 2024 Author

GeorgeS2019 Feb 4, 2025 Author

Python Code

C# Code using TorchSharp and other libraries

Using TorchSharp for NumPy-like operations

GeorgeS2019 Feb 4, 2025 Author

GeorgeS2019 Feb 4, 2025 Author

Replies: 4 comments 5 replies

GeorgeS2019
Dec 31, 2024
Author

GeorgeS2019 Dec 31, 2024
Author

GeorgeS2019
Dec 31, 2024
Author

GeorgeS2019 Feb 4, 2025
Author

GeorgeS2019 Feb 4, 2025
Author

GeorgeS2019 Feb 4, 2025
Author