嵌入式驱动学习第三周——linux内核链表

已于 2024-03-14 21:57:02 修改
阅读量726 收藏 29
点赞数 19
分类专栏： 嵌入式驱动学习 文章标签： 学习 linux 链表 c++ vscode c语言 驱动开发
于 2024-03-13 17:01:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43419761/article/details/136663703
版权

前言

   在 Linux 内核中使用最多的数据结构就是链表了，其中就包含了许多高级思想。 比如面向对象、类似C++模板的实现、堆和栈的实现。

   嵌入式驱动学习专栏将详细记录博主学习驱动的详细过程，未来预计四个月将高强度更新本专栏，喜欢的可以关注本博主并订阅本专栏，一起讨论一起学习。现在关注就是老粉啦！

目录

1. 链表简介

   链表作为常用的数据结构，是使用指针将一系列数据连成一条链，是一种线性表，通常链表数据结构至少应包括两个域，数据域和指针域。数据域用于存储数据，指针域用于建立与下一个节点的联系。相信其特性也不需要过多介绍了，大部分人应该都知道的，这部分就简单过一遍

1.1 单链表

   单链表，其仅有一个指针域指向后继节点，对单链表只能从头到顺序访问

在这里插入图片描述

1.2 双链表

   双链表多了一个指针域，又后继和前驱，既能从头到尾，又能从尾到头访问

在这里插入图片描述

1.3 循环链表

   循环链表是在单链表与双链表的基础上，让最后一个节点的指针域指向最开始的节点，双链表的话第一个节点的前驱也要指向最后一个节点。好处是可以从任意一个节点开始访问完全部的节点。

在这里插入图片描述

2. 内核链表

   在Linux内核中使用了大量的链表结构来组织数据，包括设备列表以及各种功能模块中的数据组织。这些链表大多采用在include/linux/list.h实现的一个相当精彩的链表数据结构。事实上，内核链表就是采用双循环链表机制，支持FIFO（先进先出）和LIFO（后进先出）操作。

   通过使用循环链表，内核开发者可以在保持代码量最小的情况下实现多种数据结构和算法，提高了内核的性能和可维护性。此外，循环双链表还具有高效地插入和删除节点的优点，在内核开发中很重要，因为内核需要频繁地对数据结构进行修改和操作。

   内核链表有别于传统链表就在节点本身不包含数据域，只包含指针域。故而可以很灵活的拓展数据结构。

2.1 list_head

   这个结构自身意义不大，但是在内核链表中，起着衔接的作用，可以说是内核链表的核心

struct list_head {
   struct list_head *next, *prev;
};

2.2 链表初始化

   初始化分为宏初始化和借口初始化

   宏初始化主要有LIST_HEAD_HEAD_INIT和LIST_HEAD。

LIST_HEAD_HEAD_INIT 宏，对于任意给定的结构指针，将【前驱】和【后继】指针都指向自己，作为链表头指针
LIST_HEAD 本质就是赋予了 name有list_head属性，是基于LIST_HEAD_HEAD_INIT 宏的视线

#define LIST_HEAD_INIT(name) { &(name), &(name) }
#define LIST_HEAD(name) \
   struct list_head name = LIST_HEAD_INIT(name)

   接口初始化比较直白，INIT_LIST_HEAD和宏实现意图相同，直接将链表头指针的前驱和后继都指向自己，定义如下：

static inline void INIT_LIST_HEAD(struct list_head *list)
{
   list->next = list;
   list->prev = list;
}

   要使用list_head的话，就需要创建一个宿主结构，让其包含list_head。

typedef struct my_list {
	int val;
	struct list_head list;
} My_List;

   然后我们根据这个结构体创建一个节点：

My_List first_node = {
	.val = 10,
	.list = LIST_HEAD_INIT(first_node.list);	// 将first_node.list的前驱和后继均指向自己

   即如下所示：

在这里插入图片描述

   此处list_node高能的地方又来了，我们知道container_of宏可以根据成员查找到结构体，那么通过结合container_of宏就可以通过list_node成员访问到结构体，然后再根据结构体访问其中的数值。

   container_of文章地址：嵌入式驱动学习第三周——container_of()宏

2.3 增删改查

2.3.1 添加节点

   添加节点使用的是list_add函数，其是头部插入，即总是在链表的头部插入，链表是向左生长的。其底层调用的是__list_add函数。

/* 
 * @description: 添加内核链表节点，头插法
 * @param-new  : 要添加的新节点
 * @param-head : 要加入链表的头节点
 * @return     : 无
 */
static inline void list_add(struct list_head *new, struct list_head *head)
{
   __list_add(new, head, head->next);
}

static inline void __list_add(struct list_head *new,
         struct list_head *prev,
         struct list_head *next)
{
   next->prev = new;
   new->next = next;
   new->prev = prev;
   prev->next = new;
}

   举例说明，首先可以创建一个头节点

LIST_HEAD(listHead);

在这里插入图片描述

   然后用2.2中的方法创建第一个节点

struct my_data_list first_data =
{ 
    .val = 1,
    .list = LIST_HEAD_INIT(first_data.list),
};

   创建完毕后用list_add函数将其加入到头结点中

list_add(&frist_data.list, &listHead);

在这里插入图片描述

   然后创建第二个节点并添加进去，注意看第二个节点添加的位置，是在定义的头结点之后，即头部插入

struct my_data_list second_data =
{ 
    .val = 2,
    /* 也可以调用接口 初始化*/
    .list = LIST_HEAD_INIT(second_data.list),
};
 
list_add(&second_data.list, &listHead);

在这里插入图片描述

   另一种是使用尾插法，即在节点尾部添加节点，函数为list_add_tail函数，其也是调用的__list_add函数，但是调用的时候二三两个参数位置反了一下：

/* 
 * @description: 添加内核链表节点，尾插法
 * @param-new  : 要添加的新节点
 * @param-head : 要加入链表的头节点
 * @return     : 无
 */
static inline void list_add_tail(struct list_head *new, struct list_head *head)
{
   __list_add(new, head->next, head);
}

   前面操作一样，来看插入第二个节点时的操作，注意看第二个节点插入的位置，是在第一个节点之后。

struct my_data_list second_data =
{ 
    .val = 2,
    /* 也可以调用接口 初始化*/
    .list = LIST_HEAD_INIT(second_data.list),
};
 
list_add_tail(&second_data.list, &listHead);

在这里插入图片描述

2.3.2 删除节点

   删除节点采用list_del函数或list_del_init函数

/* 
 * @description: 删除指定节点，并将节点指向特定位置
 * @param-entry: 要删除的节点
 * @return     : 无
 */
static inline void list_del(struct list_head *entry)

/* 
 * @description: 删除指定节点，删除后将节点置为空链状态，即前驱和后继均指向自己
 * @param-entry: 要删除的节点
 * @return     : 无
 */
static inline void list_del_init(struct list_head *entry)

2.3.3 遍历操作

   遍历也是一个相当重要也是相当常用的操作，首先需要介绍一下list_entry宏，list_entry宏本质是container_of宏：

#define list_entry(ptr, type, member) \
   container_of(ptr, type, member)

   其使用方法和container_of是一致的：

list_entry(&my_list_data.list, typeof(&my_list_data), list)

   既然是双向链表，那肯定就可以正向遍历，也可以反向遍历。

   list_for_each 它实际上是一个for循环，利用传入的pos作为循环变量，从表头head开始，逐项向后（next方向）移动pos，直至又回到head

/* 
 * @description: 正向遍历双向链表
 * @param-pos  : 一个list_node指针，作为遍历指针
 * @param-head : 要遍历链表的头结点
 * @return     : 无
 */
#define list_for_each(pos, head) \
 for (pos = (head)->next; pos != (head); pos = pos->next)

   其使用方法如下：

struct my_data_list* p;
struct list_head *pos; //pos指向每一个大结构体中的小结构体
list_for_each(pos, &(Head->list)) //循环遍历
{
    //以上循环只提供小结构体指针的遍历，但是遍历找的是大结构体的数据域，根据每个pos得到大结构体地址
    p = list_entry(pos, Node, list);
    printk(p->data);  //打印 
}

   list_for_each_entry 是遍历每一个list，然后获取宿主的结构地址：

/* 
 * @description : 正向遍历双向链表并获取宿主的结构地址
 * @param-pos   : 一个自己定义结构的指针，循环体内可以直接调用自己的成员变量
 * @param-head  : 要遍历链表的头结点
 * @param-member: 自己结构体中list_head的名称
 * @return      : 无
 */
#define list_for_each_entry(pos, head, member)    \
 for (pos = list_entry((head)->next, typeof(*pos), member); \
      &pos->member != (head);  \
      pos = list_entry(pos->member.next, typeof(*pos), member))

   使用案例：

struct my_data_list* p;
list_for_each_entry(p, &(Head->list), list) //循环遍历，最后一个参数是list是因为我结构体中list_head成员名字叫list
{
    printk(pos->val);  //打印
}

   list_for_each_prev是反向遍历，用法同list_for_each

/* 
 * @description: 反向遍历双向链表
 * @param-pos  : 一个list_node指针，作为遍历指针
 * @param-head : 要遍历链表的头结点
 * @return     : 无
 */
#define list_for_each_prev(pos, head) \
 for (pos = (head)->prev; pos != (head); pos = pos->prev)

   list_for_each_entry_reverse是反向遍历，用法同list_for_each_entry

/* 
 * @description : 正向遍历双向链表并获取宿主的结构地址
 * @param-pos   : 一个自己定义结构的指针，循环体内可以直接调用自己的成员变量
 * @param-head  : 要遍历链表的头结点
 * @param-member: 自己结构体中list_head的名称
 * @return      : 无
 */
#define list_for_each_entry_reverse(pos, head, member)   \
   for (pos = list_entry((head)->prev, typeof(*pos), member); \
        &pos->member != (head);  \
        pos = list_entry(pos->member.prev, typeof(*pos), member))

2.4 搬移

   内核提供了将原本属于一个链表的节点移动到另一个链表的操作，并根据插入到新链表的位置分为两类：头部搬移和尾部搬移。搬移的本质就是删除加插入。

/* 
 * @description: 从一个链表删除并添加到另一个链表中，头插法添加
 * @param-list : 要移动的节点
 * @param-head : 要添加进的链表的头结点
 * @return     : 无
 */
static inline void list_move(struct list_head *list, struct list_head *head)

/* 
 * @description: 从一个链表删除并添加到另一个链表中，尾插法添加
 * @param-list : 要移动的节点
 * @param-head : 要添加进的链表的头结点
 * @return     : 无
 */
static inline void list_move_tail(struct list_head *list, struct list_head *head)

2.5 其他

   还有其他操作比如合并，替换等，详情可见参考资料[1]。

3. 实际案例

3.1 定义自己的结构体

   定义一个工程师类，然后定义一个公司类，把工程师放进去，然后最外层定义一个node，数据域就是公司，指针域就是list_head变量。

// 一个公司类
typedef struct company_Struct {
    char name[100];
    int company_val;
    int employee_count;     // 员工人数
} Company;

typedef struct my_node {
    // 数据域
    Company company;

    // 指针域
    struct list_head list;
}Node, *pNode;

3.2 初始化链表

   之后初始化一个链表，即构建一个头节点。

// 链表初始化，构建一个头节点
pNode List_Init(void) {
    pNode Head = (pNode)kmalloc(sizeof(Node), GFP_ATOMIC);
    if (Head == NULL) {
        printk("malloc failed!");
        return NULL;
    }

    INIT_LIST_HEAD(&Head->list);

    return Head;
}

3.3 增删改查函数定义

   之后写一些增加节点，删除节点，遍历节点的函数。

   增加节点，首先先创建一个节点，然后再添加进去。

// 增加节点函数
int Node_Insert(pNode head, Company elem)
{
    pNode newNode = (pNode)kmalloc(sizeof(Node), GFP_ATOMIC);
    if (newNode == NULL) {
        printk("malloc failed!");
        return -1;
    }

    newNode->company = elem;

    list_add(&(newNode->list), &(head->list));

    return 0;
}

   删除节点，在调用list_del函数后，要用free释放节点

void Node_Delete(pNode delNode) {
    list_del(&(delNode->list));
    printk("成功删除\r\n");
    kfree(delNode);
    printk("成功释放\r\n");
}

   遍历函数

// 遍历节点
void List_Traversal(pNode head) {
    pNode p;
    struct list_head *pos;
    list_for_each(pos, &(head->list)) {
        p = list_entry(pos, Node, list);
        printk("%s\t%d\t%d\r\n", p->company.name, p->company.company_val, p->company.employee_count);
    }
}

3.4 调用

   创建三家公司com1叫aaaa，com2叫bbbb，com3叫cccc。然后都添加进链表，最后删除公司2。

Company com1 = {"aaaa", 100, 10};
Company com2 = {"bbbb", 200, 8};
Company com3 = {"cccc", 300, 40};

pNode head = List_Init();        // 初始化一个列表
Node_Insert(head, com1);
Node_Insert(head, com2);
Node_Insert(head, com3);

printk("+++++++所有的节点+++++++");
List_Traversal(head);

Node_Delete(list_entry(head->list.next->next, Node, list));
printk("+++++++删除部分节点+++++++");
List_Traversal(head);

3.5 完整代码

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/of_device.h>
#include <linux/list.h>
#include <linux/slab.h>

#define chrdevTest_CNT      1
#define chrdevTest_NAME     "chrdevTest"

// 一个公司类
typedef struct company_Struct {
    char name[100];
    int company_val;
    int employee_count;     // 员工人数
} Company;

typedef struct my_node {
    // 数据域
    Company company;

    // 指针域
    struct list_head list;
}Node, *pNode;

// 设备结构体
struct chrdevTest_dev {
    dev_t devid;
    struct cdev cdev;
    struct class *class;
    struct device *device;
    int major;
    int minor;
    struct device_node *nd;
};

struct chrdevTest_dev chrdevTest;   // 字符设备

// 链表初始化，构建一个头节点
pNode List_Init(void) {
    pNode Head = (pNode)kmalloc(sizeof(Node), GFP_ATOMIC);
    if (Head == NULL) {
        printk("malloc failed!");
        return NULL;
    }

    INIT_LIST_HEAD(&Head->list);

    return Head;
}

// 增加节点函数
int Node_Insert(pNode head, Company elem)
{
    pNode newNode = (pNode)kmalloc(sizeof(Node), GFP_ATOMIC);
    if (newNode == NULL) {
        printk("malloc failed!");
        return -1;
    }

    newNode->company = elem;

    list_add(&(newNode->list), &(head->list));

    return 0;
}

void Node_Delete(pNode delNode) {
    list_del(&(delNode->list));
    printk("成功删除\r\n");
    kfree(delNode);
    printk("成功释放\r\n");
}

// 遍历节点
void List_Traversal(pNode head) {
    pNode p;
    struct list_head *pos;
    list_for_each(pos, &(head->list)) {
        p = list_entry(pos, Node, list);
        printk("%s\t%d\t%d\r\n", p->company.name, p->company.company_val, p->company.employee_count);
    }
}

static int chrdevTest_open(struct inode *inode, struct file *filp) {
    filp->private_data = &chrdevTest;
    return 0;
}

static ssize_t chrdevTest_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt) {
    return 0;
}

static ssize_t chrdevTest_write(struct file *filp, const char __user* buf, size_t cnt, loff_t* offt) {
    return 0;
}

static ssize_t chrdevTest_release(struct inode* inode, struct file* filp) {
    return 0;
}

static struct file_operations chrdevTest_fops = {
    .owner = THIS_MODULE,
    .open = chrdevTest_open,
    .read = chrdevTest_read,
    .write = chrdevTest_write,
    .release = chrdevTest_release,
};

// 入口函数
static int __init containerTest_init(void)
{
    Company com1 = {"aaaa", 100, 10};
    Company com2 = {"bbbb", 200, 8};
    Company com3 = {"cccc", 300, 40};

    pNode head = List_Init();        // 初始化一个列表
    Node_Insert(head, com1);
    Node_Insert(head, com2);
    Node_Insert(head, com3);

    printk("+++++++所有的节点+++++++\r\n");
    List_Traversal(head);

    Node_Delete(list_entry(head->list.next->next, Node, list));
    printk("+++++++删除部分节点+++++++\r\n");
    List_Traversal(head);

    if (chrdevTest.major) {
        chrdevTest.devid = MKDEV(chrdevTest.major, 0);
        register_chrdev_region(chrdevTest.devid, chrdevTest_CNT, chrdevTest_NAME);
    } else {
        alloc_chrdev_region(&chrdevTest.devid, 0, chrdevTest_CNT, chrdevTest_NAME);     // 申请设备号
        chrdevTest.major = MAJOR(chrdevTest.devid);     // 获取主设备号
        chrdevTest.minor = MINOR(chrdevTest.devid);     // 获取次设备号
    }
    printk("chrdevTest major=%d, minor=%d\r\n", chrdevTest.major, chrdevTest.minor);

    // cdev
    chrdevTest.cdev.owner = THIS_MODULE;
    cdev_init(&chrdevTest.cdev, &chrdevTest_fops);

    // 添加cdev
    cdev_add(&chrdevTest.cdev, chrdevTest.devid, chrdevTest_CNT);

    // 创建类
    chrdevTest.class = class_create(THIS_MODULE, chrdevTest_NAME);
    if (IS_ERR(chrdevTest.class)) {
        return PTR_ERR(chrdevTest.class);
    }

    // 创建设备
    chrdevTest.device = device_create(chrdevTest.class, NULL, chrdevTest.devid, NULL, chrdevTest_NAME);
    if (IS_ERR(chrdevTest.device)) {
        return PTR_ERR(chrdevTest.device);
    }

    return 0;
}

// 出口函数
static void __exit containerTest_exit(void)
{
    printk("this is exit function\r\n");

    cdev_del(&chrdevTest.cdev);
    unregister_chrdev_region(chrdevTest.devid, chrdevTest_CNT);

    device_destroy(chrdevTest.class, chrdevTest.devid);
    class_destroy(chrdevTest.class);
}


module_init(containerTest_init);
module_exit(containerTest_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("wp");

   最后交叉编译，下载到板子上，查看信息可得：

在这里插入图片描述

参考资料

[1] 一文搞懂 Linux 内核链表（深度分析）
[2] 【内核链表】数据结构——深入理解内核链表的概念和操作&笔记

亭墨
关注
  • 19
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
嵌入式驱动学习第一周——内核的中断机制
qq_43419761的博客
03-01 1001
当你在刷手机的时候，此时突然npy打电话来了，于是你退出刷手机状态，接听npy电话，此过程即为中断。简单来说，中断会让CPU停止正在执行的程序，转而让CPU执行中断处理函数，执行完再返回原程序。另外，整个操作系统就是一个中断驱动的死循环，即裸机开发中常写的。其他所有的事情都是由操作系统提前注册的中断机制和其对应的中断处理函数完成。
嵌入式驱动学习第一周——linux设备管理模型
qq_43419761的博客
03-03 948
现在来聊点原理性的东西——linux设备管理模型嵌入式驱动学习专栏将详细记录博主学习驱动的详细过程，未来预计四个月将高强度更新本专栏，喜欢的可以关注本博主并订阅本专栏，一起讨论一起学习。现在关注就是老粉啦！
嵌入式驱动学习第三周——container_of()宏
qq_43419761的博客
03-11 956
在代码管理多个数据结构时，几乎总是需要将一个结构嵌入到另一个结构中，并随时检索它们，而不关心内存偏移或边界的问题。是一个宏函数，可以通过结构体成员的地址找到结构体的地址。ptr——结构体成员地址type——结构体类型member——结构体成员在结构体里的名字// 一个员工类int age;// 年龄char* name;// 姓名}Engineer;// 一个公司类// c艹工程师// java工程师// 员工人数} company;
Linux内核设备驱动之内核中链表的使用笔记整理
09-15
在Linux内核中，链表是一种非常重要的数据结构，广泛用于设备驱动和各种功能模块的数据组织。本文主要探讨了如何在Linux内核设备驱动中使用链表，包括其基本结构、初始化、操作和遍历。 首先，链表的基本结构由`...
Linux内核链表移植和测试代码
10-15
通过理解和实践`list.c`和`list.h`中的代码，我们可以深入理解Linux内核链表的工作原理，并学习如何在自己的项目中安全有效地使用这些数据结构。这对于系统级编程和内核开发来说是至关重要的技能。在实际应用中，...
Linux 内核通用链表学习小结
01-11
在linux内核中封装了一个通用的双向链表库，这个通用的链表库有很好的扩展性和封装性，它给我们提供了一个固定的指针域结构体，我们在使用的时候，只需要在我们定义的数据域结构体中包含这个指针域结构体就可以了，...
算法学习资料：详解Linux内核之双向循环链表
09-20
Linux 内核之双向循环链表详解 本文详解了 Linux 内核中双向循环链表的实现原理和使用方法，包括双循环链表的传统实现方式和 Linux 内核中的实现方式。双循环链表是一种常用的数据结构，广泛应用于操作系统、数据库...
编程学习之路：从零到一的成长指南
KsuferNotes
07-22 250
在当今数字化时代，编程技能已经成为许多人职业发展的重要组成部分。不论你是已经在IT业从业多年的老手，还是刚刚起步的编程新手，这篇博客将带你走过编程学习的每一个重要阶段，从而顺利完成从零到一的华丽转变。
kubernetes学习日志（七）
qq_47037022的博客
07-18 608
本文记录了service管理，ingress管理，Dashboard管理插件，集群鉴权策略，角色与全局角色，赋权与全局角色赋权。
学习测试10-3自动化 web自动化
最新发布
qq_44897733的博客
07-22 380
链接: https://pan.baidu.com/s/1QnGEAeP4ASMgdBYbAtSUTg?pwd=8sdd 提取码: 8sdd。性别、生日、出生地、居住地、情感状态、交友目的、血型。复制这段内容后打开百度网盘手机App，操作更方便哦。2、输入用户名，密码，（使用id属性）4、所有信息后的下拉框设置为保密。论坛系统课堂及其课后练习题库。3、基本资料栏位依次输入内容。三、单个注册与连续注册多个。4、实现连续注册10个账号。二、设置用户的真实姓名。
纯前端小游戏，4096小游戏，有音效，Html5，可学习使用
m0_62996549的博客
07-18 469
【代码】纯前端小游戏，4096小游戏，有音效，Html5，可学习使用。
昇思25天学习打卡营第16天|munger85
MungerVC
07-20 423
MobileNet网络是由Google团队于2017年提出的专注于移动端、嵌入式或IoT设备的轻量级CNN网络，相比于传统的卷积神经网络首先安装依赖下载数据。
2024论文精读：利用大语言模型（GPT）增强上下文学习去做关系抽取任务
YxinMiracle's Studio.
07-20 943
高引论文精度，如何利用大预言模型做关系抽取任务
从0开始的STM32HAL库学习6
hwq_1229_0525的博客
07-21 254
配置红色框图中的各种配置时钟源选择外部时钟 21.预分频器Prescaler，下面填0，不分频2.计数模式，计数模式选择为向上计数3.自动重装寄存器，自动重装计数器填为10，计数到10后清空并出发中断4.滤波器的频率分频：不使用影子寄存器。
javaScrip的学习（一）
weixin_65450681的博客
07-19 1261
这篇文章让我们简单来了解一下js，那么什么是js?JavaScript（简称JS）是一种高级编程语言，主要用于为网页添加交互功能。它可以嵌入到HTML页面中，通过对DOM（文档对象模型）的操作来实现动态效果和用户交互。JavaScript由Netscape公司的Brendan Eich于1995年创造，最初是为了增强HTML页面的功能性。随着时间的推移，JavaScript逐渐演变成一种通用的编程语言，可以在浏览器以外的环境中运行，例如服务器端的Node.js。
huawei USG6001v1学习--防火墙相关知识（1）
m0_65350813的博客
07-19 411
防火墙主要是借助硬件和软件的作用于内部和外部网络的环境间产生一种保护的屏障，从而实现对计算机不安全网络因素的阻断。
《书生大模型实战营第3期》入门岛 学习笔记与作业：Python 基础知识
shiter编写程序的艺术
07-21 689
python开发简介：【集成开发环境 IDE】python开发简介：【Conda，Pip】虚环境搭建、配置python开发简介：【jupyter notebook】实战配置python开发简介： 编码规范与工程基础实践使用 jupyter hub /lab搭建机器学习工作台使用跨平台的visual studio code 进行python 开发（综合内容老版本）python 开发环境搭建（综合内容老版本）其实Python 的环境配置在所有编程技术栈中是相对简单的，由于conda，pip 的存在。
昇思25天学习打卡营第30天 | 文本解码原理--以MindNLP为例
嫦娥妹妹等等我的博客
07-22 674
学习MindNLP进行文本解码的经验为我揭示了自然语言处理中文本生成技术的复杂性与美妙之处。通过使用MindNLP库，我能够深入理解并实践如何基于预训练的GPT2模型生成文本，特别是学习如何控制生成过程，从贪婪搜索到Beam搜索，再到采样技术，每种方法都有其独特的优势和适用场景。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值