Python 机器学习求解 PDE 学习项目——PINN 求解一维 Poisson 方程

本文使用 TensorFlow 1.15 环境搭建深度神经网络(PINN)求解一维 Poisson 方程:

− Δ u = f in  Ω , u = 0 on  Γ : = ∂ Ω . \begin{align} -\Delta u &= f \quad & \text{in } \Omega,\\ u & =0 \quad & \text{on } \Gamma:=\partial \Omega. \end{align} Δuu=f=0in Ω,on Γ:=Ω.
其中 Ω = [ X a , X b ] \Omega = [X_a,X_b] Ω=[Xa,Xb] 是一段区间,一维情况 Δ u = u x x \Delta u = u_{xx} Δu=uxx.

在这里插入图片描述

完整代码及其注释如下:

import tensorflow as tf
#print(tf.__version__)
import numpy as np  
import math
# def is_log2_close_to_int(n, eps=1e-9):  
#     log_n = math.log2(n)  
#     return math.isclose(math.fmod(log_n, 1), 0, abs_tol=eps)  
  


# 定义Exact类,用于计算精确解  
class Exact:  
    def __init__(self, xa, xb):  
        # 初始化类,接受两个参数xa和xb,代表区间的两个端点  
        self.xa = xa  # 区间左端点  
        self.xb = xb  # 区间右端点  
  
    def u_exact(self, X):  
        # 计算并返回精确解u(X)  
        # 这里使用正弦函数作为精确解,其频率与区间长度(xb-xa)有关  
        u = np.sin(2*np.pi*X / (self.xb - self.xa))  
        return u  
  
  
# 定义Dataset类,用于生成数据  
class Dataset:  
    def __init__(self, x_range, N_res, N_b, xa, xb):  
        # 初始化类,接受多个参数  
        self.x_range = x_range  # 区间范围,例如[0, 1]  
        self.N_res = N_res      # 内部节点数,用于构建内部网格  
        self.N_b = N_b          # 边界条件点数(通常这里N_b为2,因为有两个边界)  
        self.xa = xa            # 区间左端点  
        self.xb = xb            # 区间右端点  
  
    def bc(self, X_b):  
        # 计算并返回边界条件上的精确解  
        # 创建一个Exact对象,用于计算精确解  
        U_bc = Exact(self.xa, self.xb)  
        u_bc = U_bc.u_exact(X_b)  # 计算边界条件X_b上的精确解  
        return u_bc  
  
    def build_data(self):  
        # 构建并返回数据集,包括内部网格点、边界网格点和区间端点  
        x0 = self.x_range[0]  # 区间左端点  
        x1 = self.x_range[1]  # 区间右端点  
  
        # 区间端点(最小值和最大值)  
        Xmin = np.array([[x0]])  
        Xmax = np.array([[x1]])  
  
        # 构建内部网格点  
        # 可以选择使用均匀网格或随机网格  
        ## For the equation, you can choose using the uniform mesh
        """
        N = self.N_res
        X_res_input = np.linspace(x0, x1, N).reshape((-1, 1))
        """
        # 这里展示了如何使用随机网格  
        X_res_input = x0 + (x1-x0)*np.random.rand(self.N_res,1)  # 生成N_res个在[x0, x1]区间内的随机点  
  
        # 边界网格点(在这个例子中,我们手动指定了边界点)  
        X_b0_input = np.array([[x0]])  # 左边界点  
        X_b1_input = np.array([[x1]])  # 右边界点  
          
        # 返回构建的数据集  
        return X_res_input, X_b0_input, X_b1_input, Xmin, Xmax
    
def calculate_errors(sess, x_res_train, u_pred, x_t, u_e):  
    """  
    计算并打印L2范数和最大模范数的误差。  
    """  
    u_pred_vals = sess.run(u_pred, feed_dict={x_res_train: x_t})  
    error_l2 = np.linalg.norm(u_pred_vals - u_e, ord=2) / np.linalg.norm(u_e, ord=2)  
    error_max = np.max(np.abs(u_pred_vals - u_e)) / np.max(np.abs(u_e))  
    print(f"L2 Error: {error_l2:.8f}")  
    print(f"Max Error: {error_max:.8f}")  

神经网络及其训练过程所需要的函数定义:

import tensorflow as tf  
import numpy as np  
import time  
import matplotlib.pyplot as plt  
  
class Train:  
    def __init__(self, train_dict):  
        """  
        初始化Train类。  
  
        Args:  
            train_dict (dict): 用于训练的feed_dict,包含训练数据和其他必要的TensorFlow变量。  
        """  
        self.train_dict = train_dict  
        self.step = 0  # 初始化训练步数计数器  
  
    def callback(self, loss_):  
        """  
        回调函数,用于在LBFGS优化器每次迭代后打印损失。  
  
        Args:  
            loss_ (float): 当前迭代的损失值。  
        """  
        self.step += 1  
        if math.isclose(math.fmod(math.log2(self.step), 1), 0, abs_tol=1e-9): 
            print('Loss: %.3e' % (loss_))  
  
    def nntrain(self, sess, u_pred, loss, test_dict, u_e, x_t, train_adam, train_lbfgs):  
        """  
        执行神经网络训练。  
  
        Args:  
            sess (tf.Session): TensorFlow会话。  
            u_pred (tf.Tensor): 预测值的Tensor。  
            loss (tf.Tensor): 损失函数的Tensor。  
            test_dict (dict): 用于测试的feed_dict。  
            u_e (np.array): 精确解的数值数组。  
            x_t (np.array): 测试点或网格点的x坐标数组。  
            train_adam (tf.Operation): Adam优化器的TensorFlow操作。  
            train_lbfgs (LBFGSOptimizer 或类似): 用于精细调整的LBFGS优化器。  
  
        Returns:  
            None  
        """  
        n = 0  # 初始化迭代计数器  
        nmax = 10000  # 最大迭代次数  
        loss_c = 1.0e-4  # 收敛条件:当损失小于此值时停止训练  
        loss_ = 1.0  # 初始化损失值  
  
        while n < nmax and loss_ > loss_c:  
            n += 1  
            # 使用Adam优化器进行训练  
            u_, loss_, _ = sess.run([u_pred, loss, train_adam], feed_dict=self.train_dict)  
  
            # 每2^n步打印一次损失并绘制结果  
            if math.isclose(math.fmod(math.log2(n), 1), 0, abs_tol=1e-9): 
                print('Steps: %d, loss: %.3e' % (n, loss_))  
  
                # 在测试集上评估模型  
                u_test = sess.run(u_pred, feed_dict=test_dict)  
  
                # 绘制精确解和预测解的对比图  
                plt.cla()  # 清除之前的图表  
                plt.plot(x_t, u_e, 'bo', markersize=0.4, label='Exact solution')  
                plt.plot(x_t, u_test, 'rv', markersize=0.4, label='PINN solution')  
                plt.legend()  
                plt.show()  
                plt.pause(0.1)  # 暂停一段时间以便观察图表  
  
        # 使用LBFGS优化器进行精细调整  
        train_lbfgs.minimize(sess, feed_dict=self.train_dict, fetches=[loss], loss_callback=self.callback)

 import tensorflow as tf  
import numpy as np  
  
class DNN:  
    """  
    深度神经网络类,用于构建和训练神经网络。  
    """  
    def __init__(self, layer_size, Xmin, Xmax):  
        """  
        初始化DNN类。  
          
        Args:  
            layer_size (list): 网络各层的神经元数量。  
            Xmin (numpy.ndarray): 输入数据的最小值。  
            Xmax (numpy.ndarray): 输入数据的最大值。  
        """  
        self.size = layer_size  
        self.Xmin = Xmin  
        self.Xmax = Xmax  
      
    def hyper_initial(self):  
        """  
        初始化网络的权重和偏置。  
          
        Returns:  
            tuple: 包含权重和偏置的列表。  
        """  
        L = len(self.size)  
        Weights = []  
        Biases = []  
        for l in range(1, L):  
            in_dim = self.size[l-1]  
            out_dim = self.size[l]  
            std = np.sqrt(2/(in_dim + out_dim))  
            weight = tf.Variable(tf.random_normal(shape=[in_dim, out_dim], stddev=std))  
            bias = tf.Variable(tf.zeros(shape=[1, out_dim]))  
            Weights.append(weight)  
            Biases.append(bias)  
  
        return Weights, Biases  
  
    def fnn(self, X, W, b):  
        """  
        前馈神经网络的前向传播。  
          
        Args:  
            X (tf.Tensor): 输入数据。  
            W (list): 权重列表。  
            b (list): 偏置列表。  
          
        Returns:  
            tf.Tensor: 网络的输出。  
        """  
        A = 2.0*(X - self.Xmin)/(self.Xmax - self.Xmin) - 1.0  # 归一化和缩放输入  
        L = len(W)  
        for i in range(L-1):  
            A = tf.tanh(tf.add(tf.matmul(A, W[i]), b[i]))  # 应用激活函数和线性变换  
        u = tf.add(tf.matmul(A, W[-1]), b[-1])  # 输出层  
          
        return u  
      
    def pdenn(self, x, W, b):  
        """  
        计算物理驱动的神经网络残差(无边界条件)。  
          
        Args:  
            x (tf.Tensor): 输入数据。  
            W (list): 权重列表。  
            b (list): 偏置列表。  
          
        Returns:  
            tf.Tensor: 残差f。  
        """  
        u = self.fnn(x, W, b)  
          
        u_x = tf.gradients(u, x)[0]  
        u_xx = tf.gradients(u_x, x)[0]  
          
        rhf = np.pi**2 * tf.sin(np.pi*x)  # 右侧手边项  
  
        f = -u_xx - rhf  # 计算残差  
  
        return f  
      
    def fnn_BC(self, X, W, b):  
        """  
        应用边界条件的前馈神经网络。  
          
        Args:  
            X (tf.Tensor): 输入数据。  
            W (list): 权重列表。  
            b (list): 偏置列表。  
          
        Returns:  
            tf.Tensor: 应用边界条件后的输出。  
        """  
        Xmax = self.Xmax
        Xmin = self.Xmin
        u = self.fnn(X, W, b)
        
        ua = self.fnn(tf.cast(Xmin, tf.float32), W, b)
        ub = self.fnn(tf.cast(Xmax, tf.float32), W, b)
        
        K = tf.subtract(ub, ua)/(Xmax[0,0] - Xmin[0,0])
        c = tf.subtract(ua, Xmin*K)
        u = tf.subtract(u, tf.add(tf.matmul(X, K), c))
        
        return u
          
    def pdenn_BC(self, x, W, b):  
        """  
        计算物理驱动的神经网络残差(带边界条件)。  
          
        Args:  
            x (tf.Tensor): 输入数据。  
            W (list): 权重列表。  
            b (list): 偏置列表。  
          
        Returns:  
            tf.Tensor: 残差f。  
        """  
        u = self.fnn_BC(x, W, b)
        
        u_x = tf.gradients(u, x)[0]
        u_xx = tf.gradients(u_x, x)[0]
        
        rhf = np.pi**2 * tf.sin(np.pi*x)

        f = -u_xx - rhf

        return f
          
    def fnn_BC2(self, X, W, b):  
        """  
        另一种应用边界条件的方法(示例)。  
          
        Args:  
            X (tf.Tensor): 输入数据。  
            W (list): 权重列表。  
            b (list): 偏置列表。  
          
        Returns:  
            tf.Tensor: 应用边界条件后的输出。  
        """  
        Xmax = self.Xmax
        Xmin = self.Xmin
        u = self.fnn(X, W, b)
        
        u = (X-Xmax)*(X-Xmin) * u
        
        return u
          
    def pdenn_BC2(self, x, W, b):  
        """  
        使用另一种边界条件计算物理驱动的神经网络残差。  
          
        Args:  
            x (tf.Tensor): 输入数据。  
            W (list): 权重列表。  
            b (list): 偏置列表。  
          
        Returns:  
            tf.Tensor: 残差f。  
        """  
        u = self.fnn_BC2(x, W, b)
        
        u_x = tf.gradients(u, x)[0]
        u_xx = tf.gradients(u_x, x)[0]
        
        rhf = np.pi**2 * tf.sin(np.pi*x)

        f = -u_xx - rhf

        return f

画图:

# 导入必要的库  
import tensorflow as tf  # TensorFlow库,用于构建和训练神经网络  
import numpy as np  # NumPy库,用于处理数值数据  
import matplotlib.pyplot as plt  # Matplotlib库,用于绘图  
import os  # os库,用于与操作系统交互,如文件路径操作  
  
# 设置保存结果的路径  
savepath='./Output'  
if not os.path.exists(savepath):  
    os.makedirs(savepath)  # 如果路径不存在,则创建该路径  
 
  
# 定义一个类SavePlot,用于保存预测结果并绘制图形  
class SavePlot:  
    def __init__(self, sess, x_range, N, xa, xb):  
        # 初始化函数,设置类的属性  
        self.x_range = x_range  # 预测时x的范围  
        self.N = N  # 预测时x的样本数  
        self.sess = sess  # TensorFlow会话,用于执行TensorFlow操作  
        self.xa = xa  # 精确解计算时可能需要的参数a  
        self.xb = xb  # 精确解计算时可能需要的参数b  
  
    def saveplt(self, u_pred, x_res_train):  
        # 在给定范围内生成均匀的x点  
        x_t = np.linspace(self.x_range[0], self.x_range[1], self.N).reshape((-1, 1))  
        # 构建feed_dict,用于在TensorFlow会话中执行u_pred  
        test_dict = {x_res_train: x_t}  
        # 使用TensorFlow会话执行u_pred,得到预测结果  
        u_test = self.sess.run(u_pred, feed_dict=test_dict)  
  
        # 将预测结果保存到文件  
        np.savetxt('./Output/u_pred', u_test, fmt='%e')  
  
        # 计算并保存精确解  
        Exact_sln = Exact(self.xa, self.xb)  
        u_e = Exact_sln.u_exact(x_t)  
        np.savetxt('./Output/u_e', u_e, fmt='%e')  
          
        # 计算并打印预测误差  
        err_ = np.linalg.norm(u_test - u_e)/np.linalg.norm(u_e)  
        print(err_)  
  
        # 绘制精确解和预测解的对比图  
        plt.plot(x_t, u_e, 'bo', markersize=0.4, label='Exact solution')  
        plt.plot(x_t, u_test, 'rv', markersize=0.4, label='PINN solution')  
        plt.legend()  # 显示图例  
        plt.show()  # 显示图形  
  
# 注意:代码中注释掉的plt.close()和.close()通常不是必要的,除非在循环中多次调用plt.plot或打开文件需要关闭。  
# plt.close()用于关闭当前图形窗口,但在这里调用plt.show()后通常不需要。  
 

下面是主函数:

# 导入必要的库  
import os  
import tensorflow as tf  
import numpy as np  
import time  
import matplotlib.pyplot as plt  
import scipy.io  
  
 
  
# 设置随机数种子以确保结果的可重复性  
np.random.seed(1234)  
tf.set_random_seed(1234)  # 注意:在TensorFlow 2.x中,应使用tf.random.set_seed  
  
def main():  
    # 定义问题域和分辨率等参数  
    x_range = [-1.0, 1.0]  # 定义x的范围  
    N_res = 50  # 残差点数量  
    N_bx = 2  # 边界点数量  
    xa, xb = x_range  # 边界值  
  
    # 创建数据集对象  
    data = Dataset(x_range, N_res, N_bx, xa, xb)  
      
    # 构建数据  
    X_res, X_b0, X_b1, Xmin, Xmax = data.build_data()  
  
    # 定义神经网络结构  
    layers = [1] + 5*[40] + [1]  # 神经网络层数和每层的神经元数  
  
    # 创建占位符  
    x_res_train = tf.placeholder(shape=[None, 1], dtype=tf.float32)  
    x_b0_train = tf.placeholder(shape=[None, 1], dtype=tf.float32)  
    x_b1_train = tf.placeholder(shape=[None, 1], dtype=tf.float32)  
  
    # 创建PINN对象  
    pinn = DNN(layers, Xmin, Xmax)  
    W, b = pinn.hyper_initial()  # 初始化权重和偏置  
  
    # 定义网络输出和物理方程残差  
    u_pred = pinn.fnn_BC2(x_res_train, W, b)  # 使用特定边界条件的网络输出  
    f_pred = pinn.pdenn_BC2(x_res_train, W, b)  # 残差,即物理方程的不满足度  
  
    # 定义边界条件输出  
    u_b0_pred = pinn.fnn(x_b0_train, W, b)  
    u_b1_pred = pinn.fnn(x_b1_train, W, b)  
  
    # 定义损失函数(这里只考虑了残差的平方和)  
    loss = tf.reduce_mean(tf.square(f_pred))  
  
    # 定义优化器  
    train_adam = tf.train.AdamOptimizer(0.0008).minimize(loss)  
    train_lbfgs = tf.contrib.opt.ScipyOptimizerInterface(loss,
                                                         method = "L-BFGS-B",
                                                         options = {'maxiter': 80000,
                                                                    'ftol': 1.0*np.finfo(float).eps
                                                                   }
                                                        ) # 注意:tf.contrib在TensorFlow 2.x中已被移除  
  
    # TensorFlow 1.x 会话管理  
    sess = tf.Session()  
    sess.run(tf.global_variables_initializer())  
  
    # 准备训练和测试数据字典  
    train_dict = {x_res_train: X_res, x_b0_train: X_b0, 
                  x_b1_train: X_b1}
    
    
    x_t = np.linspace(xa, xb, 101).reshape((-1, 1))
    test_dict = {x_res_train: x_t}

    Exact_sln = Exact(xa, xb)  # 真实解的计算对象  
    u_e = Exact_sln.u_exact(x_t)  # 真实解  
  
    # 训练模型  
    Model = Train(train_dict)  
    start_time = time.perf_counter()
    Model.nntrain(sess, u_pred, loss, test_dict, u_e, x_t, train_adam, train_lbfgs)  
  
    # 打印训练时间  
    stop_time = time.perf_counter()
    print('Duration time is %.3f seconds'%(stop_time - start_time))

    # 在模型训练结束后,计算并打印误差  
    calculate_errors(sess, x_res_train, u_pred, x_t, u_e)  

    #Save the data
    N_test = 101
    datasave = SavePlot(sess, x_range, N_test, xa, xb)
    datasave.saveplt(u_pred, x_res_train)
  

if __name__ == '__main__':  
    main()

我是在 Jupyter 文件上运行的,在其他集成开发环境中也可以类似运行。

运行结果:

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

效果不错!

下期预告:

  • Python 机器学习求解 PDE 学习项目——PINN 求解二维 Poisson 方程

本专栏目标从简单的一维 Poisson 方程,到对流扩散方程,Burges 方程,到二维,三维以及非线性方程,发展方程,积分方程等等,所有文章包含全部可运行代码。请持续关注!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/870373.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

Spring Cloud微服务项目公共类抽取

在微服务架构中&#xff0c;代码的重用性和维护性是非常重要的。Spring Cloud 提供了丰富的工具和框架来帮助我们构建和管理微服务应用&#xff0c;但随着项目规模的扩大&#xff0c;我们会遇到大量的重复代码和相似的逻辑。在这种情况下&#xff0c;抽取公共类成为提高代码质量…

txt格式单词导入有道词典生词本 (java代码方式)

txt格式单词导入有道词典生词本 (java代码方式) 首先要求txt文档里单词的格式&#xff0c;大概需要像这种&#xff1a; 每行是一个单词&#xff0c;格式为&#xff1a;英文单词空格词性单词意思。 注意 导出单词本的名字就是你 txt 文件的名字 我这里是 公共英语三级 单词本 …

vite5-macos仿macOS网页osx管理系统|vue3+arcoDesign桌面os

基于vite5.xvue3arco-design原创自研网页版os管理框架ViteWebOS。 使用最新前端技术vite5vue3pinia2arcoDesignsortablejsecharts搭建网页pc版桌面os式后台管理系统解决方案。支持自定义桌面栅格布局引擎、可拖拽桌面图标、多屏分页管理、自定义桌面壁纸主题、毛玻璃虚化背景等…

react中路由跳转以及路由传参

一、路由跳转 1.安装插件 npm install react-router-dom 2.路由配置 路由配置&#xff1a;react中简单的配置路由-CSDN博客 3.实现代码 // src/page/index/index.js// 引入 import { Link, useNavigate } from "react-router-dom";function IndexPage() {const …

论文快过(图像配准|Coarse_LoFTR_TRT)|适用于移动端的LoFTR算法的改进分析 1060显卡上45fps

项目地址&#xff1a;https://github.com/Kolkir/Coarse_LoFTR_TRT 创建时间&#xff1a;2022年 相关训练数据&#xff1a;BlendedMVS LoFTR [19]是一种有效的深度学习方法&#xff0c;可以在图像对上寻找合适的局部特征匹配。本文报道了该方法在低计算性能和有限内存条件下的…

MongoDB教程(十五):MongoDB原子操作

&#x1f49d;&#x1f49d;&#x1f49d;首先&#xff0c;欢迎各位来到我的博客&#xff0c;很高兴能够在这里和您见面&#xff01;希望您在这里不仅可以有所收获&#xff0c;同时也能感受到一份轻松欢乐的氛围&#xff0c;祝你生活愉快&#xff01; 文章目录 引言一、MongoD…

深入浅出WebRTC—Pacer

平滑发包&#xff08;Pacer&#xff09;是 WebRTC 实现高质量实时通信不可或缺的一部分。在视频通信中&#xff0c;单帧视频可能包含大量的数据&#xff0c;如果未经控制地立即发送&#xff0c;可能瞬间对网络造成巨大压力。Pacer 能够根据网络条件动态调整发送速率&#xff0c…

论文阅读:面向自动驾驶场景的多目标点云检测算法

论文地址:面向自动驾驶场景的多目标点云检测算法 概要 点云在自动驾驶系统中的三维目标检测是关键技术之一。目前主流的基于体素的无锚框检测算法通常采用复杂的二阶段修正模块,虽然在算法性能上有所提升,但往往伴随着较大的延迟。单阶段无锚框点云检测算法简化了检测流程,…

“微软蓝屏”全球宕机,敲响基础软件自主可控警钟

上周五&#xff0c;“微软蓝屏”“感谢微软 喜提假期”等词条冲上热搜&#xff0c;全球百万打工人受此影响&#xff0c;共同见证这一历史性事件。据微软方面发布消息称&#xff0c;旗下Microsoft 365系列服务出现访问中断。随后在全球范围内&#xff0c;包括企业、政府、个人在…

基于DPU与SmartNic的云原生SDN解决方案

1. 方案背景与挑战 随着云计算&#xff0c;大数据和人工智能等技术的蓬勃发展&#xff0c;数据中心面临着前所未有的数据洪流和计算压力&#xff0c;这对SDN提出了更高的性能和效率要求。自云原生概念被提出以来&#xff0c;Kubernetes为云原生应用的落地提供了一个轻量级&am…

node+mysql实现(账户密码,阿里云短信验证,QQ邮箱注册登录,短信验证密码重置,邮箱密码重置)之注册,登录密码重置总篇

node+mysql实现账户登录 注意效果图项目插件代码参数说明短信验证模块邮箱验证模块注册方式登录方式密码重置前端页面部分登录页面账户登录页面(login.html)短信验证登录页面(smsLogin.html)邮箱登录页面(emailLogin.html)注册部分页面短信验证注册页面(register.html)邮…

产品经理NPDP好考吗?

NPDP是新产品开发专业人员的资格认证&#xff0c;对于希望在产品管理领域取得认可的专业人士来说&#xff0c;NPDP认证是一项重要的资格。 那么&#xff0c;产品经理考取NPDP资格认证究竟难不难呢&#xff1f; 首先&#xff0c;NPDP考试的难易程度取决于考生的背景和准备情况…

C++11并发编程

目录 一、线程的创建 1、介绍thread类 2、创建线程 二、线程的2种工作方式 其一&#xff1a;关联主线程 其二&#xff1a;拆离主线程 两种工作方式的使用-代码示例 detach join 三、线程安全问题 1、什么是线程安全 2、怎么使程序线程安全 保护对共享数据的操作-加…

Redis (常用数据结构和命令)

目录 简介 概述 特点 数据结构 常用命令 通用命令 keys del exists expire 与 ttl String 命令 SET 和GET: MSET和MGET INCR和INCRBY和DECY SETNX SETEX Redis 命令 Key 的层级结构 key层级关系 &#xff1a; Hash命令 HSET和HGET HMSET和HMGET HGETALL H…

深入浅出WebRTC—ULPFEC

FEC 通过在发送端添加额外的冗余信息&#xff0c;使接收端即使在部分数据包丢失的情况下也能恢复原始数据&#xff0c;从而减轻网络丢包的影响。在 WebRTC 中&#xff0c;FEC 主要有两种实现方式&#xff1a;ULPFEC 和 FlexFEC&#xff0c;FlexFEC 是 ULPFEC 的扩展和升级&…

数据结构——堆(C语言版)

树 树的概念&#xff1a; 树&#xff08;Tree&#xff09;是一种抽象数据结构&#xff0c;它由节点&#xff08;node&#xff09;的集合组成&#xff0c;这些节点通过边相连&#xff0c;把 节点集合按照逻辑顺序抽象成图像&#xff0c;看起来就像一个倒挂着的树&#xff0c;也…

OpenCV图像滤波(1)双边滤波函数bilateralFilter的使用

操作系统&#xff1a;ubuntu22.04 OpenCV版本&#xff1a;OpenCV4.9 IDE:Visual Studio Code 编程语言&#xff1a;C11 功能描述 bilateralFilter是图像处理和计算机视觉领域中的一种高级图像滤波技术&#xff0c;特别设计用于在去除噪声的同时保留图像的边缘和细节。相比于传…

网络编程总复习

TCP的创建&#xff1a; 服务器端 &#xff1a; 客户端&#xff1a;

ESP8266用AT指令实现连接MQTT

1准备工作 硬件&#xff08;ESP8266&#xff09;连接电脑 硬件已经烧入了MQTT透传固件 2实现连接 2-1&#xff08;进入AT模式&#xff09; 打开串口助手发送如下指令 AT 2-2&#xff08;复位&#xff09; ATRST 2-3&#xff08;开启DHCP&#xff0c;自动获取IP&#x…

The Llama 3 Herd of Models.Llama 3 模型论文全文

现代人工智能(AI)系统是由基础模型驱动的。本文提出了一套新的基础模型,称为Llama 3。它是一组语言模型,支持多语言、编码、推理和工具使用。我们最大的模型是一个密集的Transformer,具有405B个参数和多达128K个tokens的上下文窗口。本文对Llama 3进行了广泛的实证评价。我们…