首页 > 编程语言 >C#基于ScottPlot进行可视化

C#基于ScottPlot进行可视化

时间：2024-01-13 22:12:10浏览次数：28  
标签：C# double args current gradient 可视化 new array ScottPlot

C#基于ScottPlot进行可视化

前言

上一篇文章跟大家分享了用NumSharp实现简单的线性回归，但是没有进行可视化，可能对拟合的过程没有直观的感受，因此今天跟大家介绍一下使用C#基于Scottplot进行可视化，当然Python的代码，我也会同步进行可视化。

Python代码进行可视化

Python代码用matplotlib做了可视化，我就不具体介绍了。

修改之后的python代码如下：

#The optimal values of m and b can be actually calculated with way less effort than doing a linear regression. 
#this is just to demonstrate gradient descent

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation


# y = mx + b
# m is slope, b is y-intercept
def compute_error_for_line_given_points(b, m, points):
    totalError = 0
    for i in range(0, len(points)):
        x = points[i, 0]
        y = points[i, 1]
        totalError += (y - (m * x + b)) ** 2
    return totalError / float(len(points))

def step_gradient(b_current, m_current, points, learningRate):
    b_gradient = 0
    m_gradient = 0
    N = float(len(points))
    for i in range(0, len(points)):
        x = points[i, 0]
        y = points[i, 1]
        b_gradient += -(2/N) * (y - ((m_current * x) + b_current))
        m_gradient += -(2/N) * x * (y - ((m_current * x) + b_current))
    new_b = b_current - (learningRate * b_gradient)
    new_m = m_current - (learningRate * m_gradient)
    return [new_b, new_m]

def gradient_descent_runner(points, starting_b, starting_m, learning_rate, num_iterations):
    b = starting_b
    m = starting_m
    args_data = []
    for i in range(num_iterations):
        b, m = step_gradient(b, m, np.array(points), learning_rate)
        args_data.append((b,m))
    return args_data

if __name__ == '__main__':
     points = np.genfromtxt("data.csv", delimiter=",")
     learning_rate = 0.0001
     initial_b = 0 # initial y-intercept guess
     initial_m = 0 # initial slope guess
     num_iterations = 10
     print ("Starting gradient descent at b = {0}, m = {1}, error = {2}".format(initial_b, initial_m, compute_error_for_line_given_points(initial_b, initial_m, points)))
     print ("Running...")
     args_data = gradient_descent_runner(points, initial_b, initial_m, learning_rate, num_iterations)
     
     b = args_data[-1][0]
     m = args_data[-1][1]

     print ("After {0} iterations b = {1}, m = {2}, error = {3}".format(num_iterations, b, m, compute_error_for_line_given_points(b, m, points)))
    
     data = np.array(points).reshape(100,2)
     x1 = data[:,0]
     y1 = data[:,1]
     
     x2 = np.linspace(20, 80, 100)
     y2 = initial_m * x2 + initial_b

     data2 = np.array(args_data)
     b_every = data2[:,0]
     m_every = data2[:,1]

     # 创建图形和轴
     fig, ax = plt.subplots()
     line1, = ax.plot(x1, y1, 'ro')
     line2, = ax.plot(x2,y2)

     # 添加标签和标题
     plt.xlabel('x')
     plt.ylabel('y')
     plt.title('Graph of y = mx + b')

     # 添加网格
     plt.grid(True)

    # 定义更新函数
     def update(frame):
        line2.set_ydata(m_every[frame] * x2 + b_every[frame])
        ax.set_title(f'{frame} Graph of y = {m_every[frame]:.2f}x + {b_every[frame]:.2f}')
    
# 创建动画
animation = FuncAnimation(fig, update, frames=len(data2), interval=500)

# 显示动画
plt.show()

实现的效果如下所示：

python代码的可视化

image-20240113200232614

C#代码进行可视化

这是本文重点介绍的内容，本文的C#代码通过Scottplot进行可视化。

Scottplot简介

ScottPlot 是一个免费的开源绘图库，用于 .NET，可以轻松以交互方式显示大型数据集。

控制台程序可视化

首先我先介绍一下在控制台程序中进行可视化。

首先添加Scottplot包：

image-20240113201207374

将上篇文章中的C#代码修改如下：

using NumSharp;

namespace LinearRegressionDemo
{
    internal class Program
    {    
        static void Main(string[] args)
        {   
            //创建double类型的列表
            List<double> Array = new List<double>();
            List<double> ArgsList = new List<double>();

            // 指定CSV文件的路径
            string filePath = "你的data.csv路径";

            // 调用ReadCsv方法读取CSV文件数据
            Array = ReadCsv(filePath);

            var array = np.array(Array).reshape(100,2);

            double learning_rate = 0.0001;
            double initial_b = 0;
            double initial_m = 0;
            double num_iterations = 10;

            Console.WriteLine($"Starting gradient descent at b = {initial_b}, m = {initial_m}, error = {compute_error_for_line_given_points(initial_b, initial_m, array)}");
            Console.WriteLine("Running...");
            ArgsList = gradient_descent_runner(array, initial_b, initial_m, learning_rate, num_iterations);
            double b = ArgsList[ArgsList.Count - 2];
            double m = ArgsList[ArgsList.Count - 1];
            Console.WriteLine($"After {num_iterations} iterations b = {b}, m = {m}, error = {compute_error_for_line_given_points(b, m, array)}");
            Console.ReadLine();

            var x1 = array[$":", 0];
            var y1 = array[$":", 1];
            var y2 = m * x1 + b;

            ScottPlot.Plot myPlot = new(400, 300);
            myPlot.AddScatterPoints(x1.ToArray<double>(), y1.ToArray<double>(), markerSize: 5);
            myPlot.AddScatter(x1.ToArray<double>(), y2.ToArray<double>(), markerSize: 0);
            myPlot.Title($"y = {m:0.00}x + {b:0.00}");

            myPlot.SaveFig("图片.png");
       
        }

        static List<double> ReadCsv(string filePath)
        {
            List<double> array = new List<double>();
            try
            {
                // 使用File.ReadAllLines读取CSV文件的所有行
                string[] lines = File.ReadAllLines(filePath);             

                // 遍历每一行数据
                foreach (string line in lines)
                {
                    // 使用逗号分隔符拆分每一行的数据
                    string[] values = line.Split(',');

                    // 打印每一行的数据
                    foreach (string value in values)
                    {
                        array.Add(Convert.ToDouble(value));
                    }                  
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("发生错误: " + ex.Message);
            }
            return array;
        }

        public static double compute_error_for_line_given_points(double b,double m,NDArray array)
        {
            double totalError = 0;
            for(int i = 0;i < array.shape[0];i++)
            {
                double x = array[i, 0];
                double y = array[i, 1];
                totalError += Math.Pow((y - (m*x+b)),2);
            }
            return totalError / array.shape[0];
        }

        public static double[] step_gradient(double b_current,double m_current,NDArray array,double learningRate)
        {
            double[] args = new double[2];
            double b_gradient = 0;
            double m_gradient = 0;
            double N = array.shape[0];

            for (int i = 0; i < array.shape[0]; i++)
            {
                double x = array[i, 0];
                double y = array[i, 1];
                b_gradient += -(2 / N) * (y - ((m_current * x) + b_current));
                m_gradient += -(2 / N) * x * (y - ((m_current * x) + b_current));
            }

            double new_b = b_current - (learningRate * b_gradient);
            double new_m = m_current - (learningRate * m_gradient);
            args[0] = new_b;
            args[1] = new_m;

            return args;
        }

        public static List<double> gradient_descent_runner(NDArray array, double starting_b, double starting_m, double learningRate,double num_iterations)
        {
            double[] args = new double[2];
            List<double> argsList = new List<double>();
            args[0] = starting_b;
            args[1] = starting_m;

            for(int i = 0 ; i < num_iterations; i++) 
            {
                args = step_gradient(args[0], args[1], array, learningRate);
                argsList.AddRange(args);
            }

            return argsList;
        }


    }
}

然后得到的图片如下所示：

image-20240113202345301

在以上代码中需要注意的地方：

  var x1 = array[$":", 0];
  var y1 = array[$":", 1];

是在使用NumSharp中的切片，x1表示所有行的第一列，y1表示所有行的第二列。

当然我们不满足于只是保存图片，在控制台应用程序中，再添加一个 ScottPlot.WinForms包：

image-20240113202751162

右键控制台项目选择属性，将目标OS改为Windows：

image-20240113212334704

将上述代码中的

  myPlot.SaveFig("图片.png");

修改为：

 var viewer = new ScottPlot.FormsPlotViewer(myPlot);
 viewer.ShowDialog();

再次运行结果如下：

image-20240113203022718

winform进行可视化

我也想像Python代码中那样画动图，因此做了个winform程序进行演示。

首先创建一个winform，添加ScottPlot.WinForms包，然后从工具箱中添加FormsPlot这个控件：

image-20240113205227384

有两种方法实现，第一种方法用了定时器：

using NumSharp;
namespace WinFormDemo
{
    public partial class Form1 : Form
    {
        System.Windows.Forms.Timer updateTimer = new System.Windows.Forms.Timer();
        int num_iterations;
        int count = 0;
        NDArray? x1, y1, b_each, m_each;
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            StartLinearRegression();
        }

        public void StartLinearRegression()
        {
            //创建double类型的列表
            List<double> Array = new List<double>();
            List<double> ArgsList = new List<double>();

            // 指定CSV文件的路径
            string filePath = "你的data.csv路径";

            // 调用ReadCsv方法读取CSV文件数据
            Array = ReadCsv(filePath);

            var array = np.array(Array).reshape(100, 2);

            double learning_rate = 0.0001;
            double initial_b = 0;
            double initial_m = 0;
            num_iterations = 10;

            ArgsList = gradient_descent_runner(array, initial_b, initial_m, learning_rate, num_iterations);

            x1 = array[$":", 0];
            y1 = array[$":", 1];

            var argsArr = np.array(ArgsList).reshape(num_iterations, 2);
            b_each = argsArr[$":", 0];
            m_each = argsArr[$":", 1];

            double b = b_each[-1];
            double m = m_each[-1];
            var y2 = m * x1 + b;

            formsPlot1.Plot.AddScatterPoints(x1.ToArray<double>(), y1.ToArray<double>(), markerSize: 5);
            //formsPlot1.Plot.AddScatter(x1.ToArray<double>(), y2.ToArray<double>(), markerSize: 0);
            formsPlot1.Render();


        }

        static List<double> ReadCsv(string filePath)
        {
            List<double> array = new List<double>();
            try
            {
                // 使用File.ReadAllLines读取CSV文件的所有行
                string[] lines = File.ReadAllLines(filePath);

                // 遍历每一行数据
                foreach (string line in lines)
                {
                    // 使用逗号分隔符拆分每一行的数据
                    string[] values = line.Split(',');

                    // 打印每一行的数据
                    foreach (string value in values)
                    {
                        array.Add(Convert.ToDouble(value));
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("发生错误: " + ex.Message);
            }
            return array;
        }

        public static double compute_error_for_line_given_points(double b, double m, NDArray array)
        {
            double totalError = 0;
            for (int i = 0; i < array.shape[0]; i++)
            {
                double x = array[i, 0];
                double y = array[i, 1];
                totalError += Math.Pow((y - (m * x + b)), 2);
            }
            return totalError / array.shape[0];
        }

        public static double[] step_gradient(double b_current, double m_current, NDArray array, double learningRate)
        {
            double[] args = new double[2];
            double b_gradient = 0;
            double m_gradient = 0;
            double N = array.shape[0];

            for (int i = 0; i < array.shape[0]; i++)
            {
                double x = array[i, 0];
                double y = array[i, 1];
                b_gradient += -(2 / N) * (y - ((m_current * x) + b_current));
                m_gradient += -(2 / N) * x * (y - ((m_current * x) + b_current));
            }

            double new_b = b_current - (learningRate * b_gradient);
            double new_m = m_current - (learningRate * m_gradient);
            args[0] = new_b;
            args[1] = new_m;

            return args;
        }

        public static List<double> gradient_descent_runner(NDArray array, double starting_b, double starting_m, double learningRate, double num_iterations)
        {
            double[] args = new double[2];
            List<double> argsList = new List<double>();
            args[0] = starting_b;
            args[1] = starting_m;

            for (int i = 0; i < num_iterations; i++)
            {
                args = step_gradient(args[0], args[1], array, learningRate);
                argsList.AddRange(args);
            }

            return argsList;
        }

        private void button2_Click(object sender, EventArgs e)
        {
            // 初始化定时器
            updateTimer.Interval = 1000; // 设置定时器触发间隔（毫秒）
            updateTimer.Tick += UpdateTimer_Tick;
            updateTimer.Start();
        }

        private void UpdateTimer_Tick(object? sender, EventArgs e)
        {
            if (count >= num_iterations)
            {
                updateTimer.Stop();
            }
            else
            {
                UpdatePlot(count);
            }

            count++;
        }

        public void UpdatePlot(int count)
        {

            double b = b_each?[count];
            double m = m_each?[count];

            var y2 = m * x1 + b;

            formsPlot1.Plot.Clear();
            formsPlot1.Plot.AddScatterPoints(x1?.ToArray<double>(), y1?.ToArray<double>(), markerSize: 5);
            formsPlot1.Plot.AddScatter(x1?.ToArray<double>(), y2.ToArray<double>(), markerSize: 0);
            formsPlot1.Plot.Title($"第{count + 1}次迭代：y = {m:0.00}x + {b:0.00}");
            formsPlot1.Render();
        }

        private void button3_Click(object sender, EventArgs e)
        {
            updateTimer.Stop();
        }

        private void Form1_Load(object sender, EventArgs e)
        {

        }
    }
}

简单介绍一下思路，首先创建List<double> argsList用来保存每次迭代生成的参数b、m，然后用

           var argsArr = np.array(ArgsList).reshape(num_iterations, 2);

将argsList通过np.array()方法转化为NDArray，然后再调用reshape方法，转化成行数等于迭代次数，列数为2，即每一行对应一组参数值b、m。

            b_each = argsArr[$":", 0];
            m_each = argsArr[$":", 1];

argsArr[$":", 0]表示每一行中第一列的值，也就是每一个b，argsArr[$":", 1]表示每一行中第二列的值。

            double b = b_each[-1];
            double m = m_each[-1];

b_each[-1]用了NumSharp的功能表示b_each最后一个元素。

实现效果如下所示：

winform绘图效果1

image-20240113205549690

另一种方法可以通过异步实现：

using NumSharp;

namespace WinFormDemo
{
    public partial class Form2 : Form
    {      
        int num_iterations;
        NDArray? x1, y1, b_each, m_each;
        public Form2()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            StartLinearRegression();
        }

        public void StartLinearRegression()
        {
            //创建double类型的列表
            List<double> Array = new List<double>();
            List<double> ArgsList = new List<double>();

            // 指定CSV文件的路径
            string filePath = "你的data.csv路径";

            // 调用ReadCsv方法读取CSV文件数据
            Array = ReadCsv(filePath);

            var array = np.array(Array).reshape(100, 2);

            double learning_rate = 0.0001;
            double initial_b = 0;
            double initial_m = 0;
            num_iterations = 10;

            ArgsList = gradient_descent_runner(array, initial_b, initial_m, learning_rate, num_iterations);

            x1 = array[$":", 0];
            y1 = array[$":", 1];

            var argsArr = np.array(ArgsList).reshape(num_iterations, 2);
            b_each = argsArr[$":", 0];
            m_each = argsArr[$":", 1];

            double b = b_each[-1];
            double m = m_each[-1];
            var y2 = m * x1 + b;

            formsPlot1.Plot.AddScatterPoints(x1.ToArray<double>(), y1.ToArray<double>(), markerSize: 5);      
            formsPlot1.Render();
        }

        static List<double> ReadCsv(string filePath)
        {
            List<double> array = new List<double>();
            try
            {
                // 使用File.ReadAllLines读取CSV文件的所有行
                string[] lines = File.ReadAllLines(filePath);

                // 遍历每一行数据
                foreach (string line in lines)
                {
                    // 使用逗号分隔符拆分每一行的数据
                    string[] values = line.Split(',');

                    // 打印每一行的数据
                    foreach (string value in values)
                    {
                        array.Add(Convert.ToDouble(value));
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("发生错误: " + ex.Message);
            }
            return array;
        }

        public static double compute_error_for_line_given_points(double b, double m, NDArray array)
        {
            double totalError = 0;
            for (int i = 0; i < array.shape[0]; i++)
            {
                double x = array[i, 0];
                double y = array[i, 1];
                totalError += Math.Pow((y - (m * x + b)), 2);
            }
            return totalError / array.shape[0];
        }

        public static double[] step_gradient(double b_current, double m_current, NDArray array, double learningRate)
        {
            double[] args = new double[2];
            double b_gradient = 0;
            double m_gradient = 0;
            double N = array.shape[0];

            for (int i = 0; i < array.shape[0]; i++)
            {
                double x = array[i, 0];
                double y = array[i, 1];
                b_gradient += -(2 / N) * (y - ((m_current * x) + b_current));
                m_gradient += -(2 / N) * x * (y - ((m_current * x) + b_current));
            }

            double new_b = b_current - (learningRate * b_gradient);
            double new_m = m_current - (learningRate * m_gradient);
            args[0] = new_b;
            args[1] = new_m;

            return args;
        }

        public static List<double> gradient_descent_runner(NDArray array, double starting_b, double starting_m, double learningRate, double num_iterations)
        {
            double[] args = new double[2];
            List<double> argsList = new List<double>();
            args[0] = starting_b;
            args[1] = starting_m;

            for (int i = 0; i < num_iterations; i++)
            {
                args = step_gradient(args[0], args[1], array, learningRate);
                argsList.AddRange(args);
            }

            return argsList;
        }

        private void Form2_Load(object sender, EventArgs e)
        {

        }

        public async Task UpdateGraph()
        {
            for (int i = 0; i < num_iterations; i++)
            {
                double b = b_each?[i];
                double m = m_each?[i];
                var y2 = m * x1 + b;

                formsPlot1.Plot.Clear();
                formsPlot1.Plot.AddScatterPoints(x1?.ToArray<double>(), y1?.ToArray<double>(), markerSize: 5);
                formsPlot1.Plot.AddScatter(x1?.ToArray<double>(), y2.ToArray<double>(), markerSize: 0);
                formsPlot1.Plot.Title($"第{i + 1}次迭代：y = {m:0.00}x + {b:0.00}");
                formsPlot1.Render();
           
                await Task.Delay(1000);
            }


        }

        private async void button2_Click(object sender, EventArgs e)
        {
            await UpdateGraph();
        }
    }
}

点击更新按钮开始执行异步任务：

 private async void button2_Click(object sender, EventArgs e)
        {
            await UpdateGraph();
        }

 public async Task UpdateGraph()
        {
            for (int i = 0; i < num_iterations; i++)
            {
                double b = b_each?[i];
                double m = m_each?[i];
                var y2 = m * x1 + b;

                formsPlot1.Plot.Clear();
                formsPlot1.Plot.AddScatterPoints(x1?.ToArray<double>(), y1?.ToArray<double>(), markerSize: 5);
                formsPlot1.Plot.AddScatter(x1?.ToArray<double>(), y2.ToArray<double>(), markerSize: 0);
                formsPlot1.Plot.Title($"第{i + 1}次迭代：y = {m:0.00}x + {b:0.00}");
                formsPlot1.Render();
           
                await Task.Delay(1000);
            }

实现效果如下：

winform绘图效果2

image-20240113210320131

总结

本文以一个控制台应用与一个winform程序为例向大家介绍了C#如何基于ScottPlot进行数据可视化，并介绍了实现动态绘图的两种方式，一种是使用定时器，另一种是使用异步操作，希望对你有所帮助。

标签：C#,double,args,current,gradient,可视化,new,array,ScottPlot
From： https://www.cnblogs.com/mingupupu/p/17963079

相关文章

  • CF-613-D
    613-D题目大意给定一颗\(n\)个节点的树。\(q\)组询问，每组询问给定\(k\)个点，问至少要删除树中多少个点才能使这\(k\)个点两两不连通，无解则输出\(-1\)。这里\(\sum{k_i}\)的规模大致和\(n\)相当。Solution虚树模板题。暴力的做法是每组询问都对整棵树进行遍树形DP，复杂度为\(......
  • C++实现文件内查找字符串
    实现概要:读取放入buf后查找匹配的第一个字符然后使用seek()移动文件指针,peek()查看剩余的字符是否匹配如果剩余的字符匹配把该字符串在文件中的位置push进一个vector<int>中再继续查看剩余的文件内容//str2.cpp--capacity()andreserve()#include<iostream>......
  • CF1201C - Maximum Median
    思路二分答案。对于一个mid，查询中位数要是为mid的话至少要做多少次操作，最小操作次数就是排序后从中位数开始计算max(0,mid-v[i])的和ac代码#include<bits/stdc++.h>usingnamespacestd;usingi64=longlong;consti64inf=8e18;typedefpair<int,int>pii;cons......
  • NSSCTF Round#16 Basic WriteUp
    NSSCTFRound#16Basicwp目录NSSCTFRound#16Basicwp一.pwn1.nc_pwnre2.ret_text一.pwn1.nc_pwnrenc连接得到题目，给了一段汇编代码以及40个十六进制数字分析代码可知，将一个字符串与10h即16进行异或运算，二次异或运算得到字符串TlNTQ1RGe1dFTGMwTV9UMF9wV25fdzByMWQhfQ......
  • AT_arc125_c [ARC125C] LIS to Original Sequence 题解
    题目传送门前置知识贪心|构造解法对于任意一个未加入序列\(P\)的数\(x<A_{i}(1\lei\lek-1)\)，如果其放在了\(A_{i}\)的前面，会导致最长上升子序列长度加一，从而不符合题目要求。因此我们需要把\(x\)放在\(A_{i}\)后面，同理，为符合题目要求，我们仅选择放最小的那一个......
  • Azure Logic Apps
      在AzureSentinel中，AzureLogicApps可以用于增强和自动化安全操作和响应。它们可以作为安全编排自动化响应（SOAR）的一部分，帮助自动化和简化安全工作流程。以下是一些具体的应用实例： 数据富集和分析：例子：在接收到安全警报时，使用LogicApp来自动从其他源（如威胁情报数据......
  • [GXYCTF2019]BabySQli
    [GXYCTF2019]BabySQli打开是一个登录页面任意输入账号密码提示wronguser输入admin提示wrongpass，说明有admin的账号并且在页面源代码中发现一串经过编码后的字符串经过base32和base64解码后得到SQL语句使用万能密码进行尝试，得到donothackme！的结果根据源码提示，我......
  • AtCoder World Tour 2022 B The Greatest Two
    原题面：https://atcoder.jp/contests/wtf22-day2/tasks/wtf22_day2_b题面翻译：一个长度为\(n\)的排列\(p\)，每次可以把一个长\(k\)区间的最大与次大值交换，问操作任意次数后可以得到的排列数量对\(998244353\)取模。这题被我搬到了一场多校联考中。在搬到的题面中，我加入了......
  • Nocalhost 为 KubeSphere 提供更强大的云原生开发环境
    1应用商店安装NocalhostServer已集成在KubeSphere应用商店，直接访问：设置应用「名称」，确认应用「版本」和部署「位置」，点击「下一步」：在「应用设置」标签页，可手动编辑清单文件或直接点击「安装」。建议把service.type设置为ClusterIP，以确保安装不受Kubernetes网络环境......
  • Centos安装docker步骤
    安装docker1、Docker要求CentOS系统的内核版本高于3.10，查看本页面的前提条件来验证你的CentOS版本是否支持Docker。  通过uname-r命令查看你当前的内核版本：$uname-r2、使用root权限登录Centos。确保yum包更新到最新。   $sudoyumupdate移除旧......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99