【PyTorch】在PyTorch中使用线性层和交叉熵损失函数进行数据分类

在PyTorch中使用线性层和交叉熵损失函数进行数据分类

前言：

在机器学习的众多任务中，分类问题无疑是最基础也是最重要的一环。本文将介绍如何在PyTorch框架下，使用线性层和交叉熵损失函数来解决分类问题。我们将以简单的Iris数据集作为起点，探讨线性模型在处理线性可分数据上的有效性。随后，我们将尝试将同样的线性模型应用于复杂的CIFAR-10图像数据集，并分析其性能表现。

背景：

  • Iris数据集：一个经典的线性可分数据集，包含三个类别的鸢尾花，每个类别有50个样本，每个样本有4个特征。
    请添加图片描述

  • CIFAR-10数据集：一个由10个类别组成的图像数据集，每个类别有6000张32x32彩色图像，总共有60000张图像。
    请添加图片描述

Iris数据集分类

数据读取与预处理：

read_data函数负责从CSV文件中读取数据，随机打乱，划分训练集和测试集，并进行标准化处理。

def read_data(file_path, only_test = False, normalize = True):
    np_data = pd.read_csv(file_path).values
    np.random.shuffle(np_data)
    
    classes = np.unique(np_data[:,-1])
    class_dict = {}
    for index, class_name in enumerate(classes):
        class_dict[index] = class_name
        class_dict[class_name] = index
        
    train_src = np_data[:int(len(np_data)*0.8)]
    test_src = np_data[int(len(np_data)*0.8):]
    train_data = train_src[:,:-1]
    train_labels = train_src[:, -1].reshape(-1,1)
    test_data = test_src[:, :-1]
    test_labels = test_src[:, -1].reshape(-1,1)
    if (normalize):
        mean = np.mean(train_data)
        std = np.std(train_data)
        train_data = (train_data - mean) / std
        mean = np.mean(test_data)
        std = np.std(test_data)
        test_data = (test_data - mean) / std
    if (only_test):
        return test_data, test_labels, class_dict
    return train_data, train_labels, test_data, test_labels, class_dict

模型构建：

Linear_classify类定义了一个简单的线性模型，其中包含一个线性层。

class Linear_classify(th.nn.Module):
    def __init__(self, *args, **kwargs) -> None:
        super(Linear_classify, self).__init__()
        self.linear = th.nn.Linear(args[0], args[1])
        
    def forward(self, x):
        y_pred = self.linear(x)
        return y_pred

训练过程： 在main函数中，我们初始化模型、损失函数和优化器。然后，通过多次迭代来训练模型，并记录损失值的变化。

file_path = "J:\\MachineLearning\\数据集\\Iris\\iris.data"
train_data, train_labels, test_data, test_labels, label_dict = read_data(file_path)
print(train_data.shape)
print(train_labels.shape)
print(label_dict)

int_labels = np.vectorize(lambda x: int(label_dict[x]))(train_labels).flatten()
print(int_labels[:10])

tensor_labels = th.from_numpy(int_labels).type(th.long) 
num_classes = int(len(label_dict)/2)
train_data = th.from_numpy(train_data.astype("float32"))

print (train_data.shape)
print (train_data[:2])
linear_classifier = Linear_classify(int(train_data.shape[1]), int(len(label_dict)/2))
loss_function = th.nn.CrossEntropyLoss()
optimizer = th.optim.SGD(linear_classifier.parameters(), lr = 0.001)
epochs = 10000
best_loss = 100
turn_to_bad_loss_count = 0
loss_history = []
for epoch in range(epochs):
    y_pred = linear_classifier(train_data)
    #print(y_pred)
    #print(y_pred.shape)
    loss = loss_function(y_pred, tensor_labels)
    if (float(loss.item()) > best_loss):
        turn_to_bad_loss_count += 1
    else:
        best_loss = float(loss.item())
    if (turn_to_bad_loss_count > 1000):
        break
    if (epoch % 10 == 0):
        print("epoch {} loss is {}".format(epoch, loss))
        loss_history.append(float(loss.item()))
    loss.backward()
    optimizer.step()
plt.plot(loss_history)
plt.show()

评估与测试

使用测试集数据评估模型的准确率，并通过可视化损失值的变化来分析模型的学习过程。

accuracy = []
for _ in range(10):
    test_data, test_labels, label_dict = read_data(file_path, only_test = True)
    test_result = linear_classifier(th.from_numpy(test_data.astype("float32")))
    print(test_result[:10])
    
    result_index = test_result.argmax(dim=1)
    iris_name_result = np.vectorize(lambda x: str(label_dict[x]))(result_index).reshape(-1,1)
    accuracy.append(len(iris_name_result[iris_name_result == test_labels]) / len(test_labels))
    
print("Accuracy is {}".format(np.mean(accuracy)))

结果

收敛很好很快

请添加图片描述

准确率较高

Accuracy is 0.9466666666666667

CIFAR-10数据集分类

关键改动

使用unpickle和read_data函数处理数据集，这部分是和前面不一样的
def unpickle(file):
    import pickle
    with open(file, 'rb') as fo:
        dict = pickle.load(fo, encoding='bytes')
    return dict

def read_data(file_path, gray = False, percent = 0, normalize = True):
    data_src = unpickle(file_path)
    np_data = np.array(data_src["data".encode()]).astype("float32")
    np_labels = np.array(data_src["labels".encode()]).astype("float32").reshape(-1,1)
    single_data_length = 32*32 
    image_ret = None
    if (gray):
        np_data = (np_data[:, :single_data_length] + np_data[:, single_data_length:(2*single_data_length)] + np_data[:, 2*single_data_length : 3*single_data_length])/3
        image_ret = np_data.reshape(len(np_data),32,32)
    else:
        image_ret = np_data.reshape(len(np_data),32,32,3)
    
    if(normalize):
        mean = np.mean(np_data)
        std = np.std(np_data)
        np_data = (np_data - mean) / std
    if (percent == 0):
        return np_data, np_labels, image_ret 
    else:
        return np_data[:int(len(np_data)*percent)], np_labels[:int(len(np_labels)*percent)], image_ret[:int(len(image_ret)*percent)]

运行结果

损失可以收敛，但收敛的幅度有限

可见只是从2.x 下降到了1.x
请添加图片描述

准确率比瞎猜准了3倍，非常的nice

请添加图片描述

train Accuracy is 0.6048

test Accuracy is 0.282

注意点：

  • 数据标准化：为了提高模型的收敛速度和准确率，对数据进行标准化处理是非常重要的，在本例中，不使用标准化会出现梯度爆炸，亲测。
  • 类别标签处理：在使用交叉熵损失函数时，需要确保类别标签是整数形式。

优化点：

  • 学习率调整：适当调整学习率可以帮助模型更快地收敛。
  • 早停法：当连续多次迭代损失值不再下降时，提前终止训练可以防止过拟合。
  • 损失函数选择：对于不同的问题，选择合适的损失函数对模型性能有显著影响，在多分类问题中，使用交叉熵损失函数是常见的选择，在pytorch中，交叉熵模块包含了softmax激活函数，这是其可以进行多分类的关键。

Softmax函数的推导过程如下：

首先，我们有一个未归一化的输入向量 z z z，其形状为 ( n , ) (n,) (n,)，其中 n n n 是类别的数量。我们希望将这个向量转化为一个概率分布，其中所有元素的总和为1。

我们可以通过以下步骤来计算 softmax 函数：

  1. 对 z z z 中的每个元素应用指数函数，得到一个新的向量 e z e^z ez。

  2. 计算 e z e^z ez 中的最大值，记作 z ^ \hat{z} z^。

  3. 对 e z e^z ez 中的每个元素减去 z ^ \hat{z} z^，得到一个新的向量 v v v。

  4. 对 v v v 中的每个元素应用指数函数，得到一个新的向量 e v e^v ev。

  5. 计算 e v e^v ev 中的最大值，记作 v ^ \hat{v} v^。

  6. 对 e v e^v ev 中的每个元素除以 v ^ \hat{v} v^，得到最终的概率分布。

以上步骤可以用以下的公式表示：

z = ( z 1 , z 2 , … , z n ) T e z = ( e z 1 , e z 2 , … , e z n ) T z ^ = m a x ( e z ) v = e z − z ^ e v = ( e v 1 , e v 2 , … , e v n ) T v ^ = m a x ( e v ) p = e v v ^ \begin{align*} z &= (z_1, z_2, \ldots, z_n)^T \\ e^z &= (e^{z_1}, e^{z_2}, \ldots, e^{z_n})^T \\ \hat{z} &= max(e^z) \\ v &= e^z - \hat{z} \\ e^v &= (e^{v_1}, e^{v_2}, \ldots, e^{v_n})^T \\ \hat{v} &= max(e^v) \\ p &= \frac{e^v}{\hat{v}} \end{align*} zezz^vevv^p​=(z1​,z2​,…,zn​)T=(ez1​,ez2​,…,ezn​)T=max(ez)=ez−z^=(ev1​,ev2​,…,evn​)T=max(ev)=v^ev​​

其中， p p p 是最终的概率分布。

结论：
通过实验，我们发现线性模型在Iris数据集上表现良好，但在CIFAR-10数据集上效果不佳。这说明线性模型在处理复杂的非线性问题时存在局限性。为了解决这一问题，我们将在后续的博客中介绍如何使用卷积神经网络来提高图像分类的准确率。

后记：
感谢您的阅读，希望本文能够帮助您了解如何在PyTorch中使用线性层和交叉熵损失函数进行数据分类。敬请期待我们的下一篇博客——“在PyTorch中使用卷积神经网络进行图像分类”。

完整代码

分类Iris数据集

import torch as th
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import torchvision

def read_data(file_path, only_test = False, normalize = True):
    np_data = pd.read_csv(file_path).values
    np.random.shuffle(np_data)
    
    classes = np.unique(np_data[:,-1])
    class_dict = {}
    for index, class_name in enumerate(classes):
        class_dict[index] = class_name
        class_dict[class_name] = index
        
    train_src = np_data[:int(len(np_data)*0.8)]
    test_src = np_data[int(len(np_data)*0.8):]
    train_data = train_src[:,:-1]
    train_labels = train_src[:, -1].reshape(-1,1)
    test_data = test_src[:, :-1]
    test_labels = test_src[:, -1].reshape(-1,1)
    if (normalize):
        mean = np.mean(train_data)
        std = np.std(train_data)
        train_data = (train_data - mean) / std
        mean = np.mean(test_data)
        std = np.std(test_data)
        test_data = (test_data - mean) / std
    if (only_test):
        return test_data, test_labels, class_dict
    return train_data, train_labels, test_data, test_labels, class_dict


class Linear_classify(th.nn.Module):
    def __init__(self, *args, **kwargs) -> None:
        super(Linear_classify, self).__init__()
        self.linear = th.nn.Linear(args[0], args[1])
        
    def forward(self, x):
        y_pred = self.linear(x)
        return y_pred



def main():
    file_path = "J:\\MachineLearning\\数据集\\Iris\\iris.data"
    train_data, train_labels, test_data, test_labels, label_dict = read_data(file_path)
    print(train_data.shape)
    print(train_labels.shape)
    print(label_dict)
    
    int_labels = np.vectorize(lambda x: int(label_dict[x]))(train_labels).flatten()
    print(int_labels[:10])
    
    tensor_labels = th.from_numpy(int_labels).type(th.long) 
    num_classes = int(len(label_dict)/2)
    train_data = th.from_numpy(train_data.astype("float32"))

    print (train_data.shape)
    print (train_data[:2])
    linear_classifier = Linear_classify(int(train_data.shape[1]), int(len(label_dict)/2))
    loss_function = th.nn.CrossEntropyLoss()
    optimizer = th.optim.SGD(linear_classifier.parameters(), lr = 0.001)
    epochs = 10000
    best_loss = 100
    turn_to_bad_loss_count = 0
    loss_history = []
    for epoch in range(epochs):
        y_pred = linear_classifier(train_data)
        #print(y_pred)
        #print(y_pred.shape)
        loss = loss_function(y_pred, tensor_labels)
        if (float(loss.item()) > best_loss):
            turn_to_bad_loss_count += 1
        else:
            best_loss = float(loss.item())
        if (turn_to_bad_loss_count > 1000):
            break
        if (epoch % 10 == 0):
            print("epoch {} loss is {}".format(epoch, loss))
            loss_history.append(float(loss.item()))
        loss.backward()
        optimizer.step()
    plt.plot(loss_history)
    plt.show()
    plt.show()
    
    accuracy = []
    for _ in range(10):
        test_data, test_labels, label_dict = read_data(file_path, only_test = True)
        test_result = linear_classifier(th.from_numpy(test_data.astype("float32")))
        print(test_result[:10])
        
        result_index = test_result.argmax(dim=1)
        iris_name_result = np.vectorize(lambda x: str(label_dict[x]))(result_index).reshape(-1,1)
        accuracy.append(len(iris_name_result[iris_name_result == test_labels]) / len(test_labels))
        
    print("Accuracy is {}".format(np.mean(accuracy)))
    
if (__name__ == "__main__"):
    main()

分类CIFAR-10数据集

import torch as th
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt


def unpickle(file):
    import pickle
    with open(file, 'rb') as fo:
        dict = pickle.load(fo, encoding='bytes')
    return dict



def read_data(file_path, gray = False, percent = 0, normalize = True):
    data_src = unpickle(file_path)
    np_data = np.array(data_src["data".encode()]).astype("float32")
    np_labels = np.array(data_src["labels".encode()]).astype("float32").reshape(-1,1)
    single_data_length = 32*32 
    image_ret = None
    if (gray):
        np_data = (np_data[:, :single_data_length] + np_data[:, single_data_length:(2*single_data_length)] + np_data[:, 2*single_data_length : 3*single_data_length])/3
        image_ret = np_data.reshape(len(np_data),32,32)
    else:
        image_ret = np_data.reshape(len(np_data),32,32,3)
    
    if(normalize):
        mean = np.mean(np_data)
        std = np.std(np_data)
        np_data = (np_data - mean) / std
    if (percent == 0):
        return np_data, np_labels, image_ret 
    else:
        return np_data[:int(len(np_data)*percent)], np_labels[:int(len(np_labels)*percent)], image_ret[:int(len(image_ret)*percent)]
    
        
        
    


class Linear_classify(th.nn.Module):
    def __init__(self, *args, **kwargs) -> None:
        super(Linear_classify, self).__init__()
        self.linear = th.nn.Linear(args[0], args[1])
        
        
    def forward(self, x):
        x = self.linear(x)
        return x



def main():
    file_path = "J:\\MachineLearning\\数据集\\cifar-10-batches-py\\data_batch_1"
    train_data, train_labels, image_data = read_data(file_path, percent=0.5)
    print(train_data.shape)
    print(train_labels.shape)
    print(image_data.shape)
    '''
    fig, axs = plt.subplots(3, 3)
    
    for i, ax in enumerate(axs.flat):
        image = image_data[i]
        ax.imshow(image_data[i],cmap="rgb")
        ax.axis('off') # 关闭坐标轴
    
    plt.show()
    '''
    
    int_labels = train_labels.flatten()
    print(int_labels[:10])
    
    tensor_labels = th.from_numpy(int_labels).type(th.long) 
    num_classes = int(len(np.unique(int_labels)))
    train_data = th.from_numpy(train_data)

    print (train_data.shape)
    print (train_data[:2])
    linear_classifier = Linear_classify(int(train_data.shape[1]), num_classes)
    loss_function = th.nn.CrossEntropyLoss()
    optimizer = th.optim.SGD(linear_classifier.parameters(), lr = 0.01)
    epochs = 7000
    best_loss = 100
    turn_to_bad_loss_count = 0
    loss_history = []
    for epoch in range(epochs):
        y_pred = linear_classifier(train_data)
        #print(y_pred)
        #print(y_pred.shape)
        loss = loss_function(y_pred, tensor_labels)
        if (float(loss.item()) > best_loss):
            turn_to_bad_loss_count += 1
        else:
            best_loss = float(loss.item())
        if (turn_to_bad_loss_count > 100):
            break
        if (epoch % 10 == 0):
            print("epoch {} loss is {}".format(epoch, loss))
            loss_history.append(float(loss.item()))
        loss.backward()
        optimizer.step()
    plt.plot(loss_history)
    plt.show()
    plt.show()
    
    test_result = linear_classifier(train_data)
    print(test_result[:10])
    result_index = test_result.argmax(dim=1).reshape(-1,1)
    accuracy = (len(result_index[result_index.detach().numpy() == train_labels]) / len(train_labels))
    print("train Accuracy is {}".format(accuracy))
    
    file_path = "J:\\MachineLearning\\数据集\\cifar-10-batches-py\\test_batch"
    test_data, test_labels, image_data = read_data(file_path)
    test_result = linear_classifier(th.from_numpy(test_data))
    print(test_result[:10])
    result_index = test_result.argmax(dim=1).reshape(-1,1)
    accuracy = (len(result_index[result_index.detach().numpy() == test_labels]) / len(test_labels))
        
    print("test Accuracy is {}".format(accuracy))
    
if (__name__ == "__main__"):
    main()

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

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

相关文章

Linux 批量添加 known_hosts

Linux 批量添加 known_hosts

前言 我们在做完linux ssh 免密登录后，通常会执行一些自动化任务（比如启动Spark集群），也就是需要ssh到每台节点执行相同命令。但是有一个问题就是如果 known_hosts 文件中不存在这个ip的话，在第一次连接时会弹出确认公…
阅读更多...
【小笔记】算法基础超参数调优思路

【小笔记】算法基础超参数调优思路

【学而不思则罔，思维不学则怠】 9.29 本文总结一下常见的一些超参数调优思路 Batch_size 2023.9.29 简单来说，较大的bz可以加快训练速度，特别是基于GPU进行模型训练时，应该在显存允许范围内，尽量使用较大的bz。两个…
阅读更多...
超实用+全覆盖！17个大分类，近500款主流实用精品AI工具导航，太贴心了！总有一款适合你。

超实用+全覆盖！17个大分类，近500款主流实用精品AI工具导航，太贴心了！总有一款适合你。

超实用全覆盖！17个大分类，近500款主流实用精品AI工具导航，太贴心了！总有一款适合你。 大家好！我是老码农。 今天给大家分享的这个工具导航：非常棒。 那棒在哪里呢？ 第1点：非常垂…
阅读更多...
SpringAOP-说说 Spring AOP 和 AspectJ AOP 区别

SpringAOP-说说 Spring AOP 和 AspectJ AOP 区别

Spring AOP Spring AOP 属于运行时增强，主要具有如下特点： 基于动态代理来实现，默认如果使用接口的，用 JDK 提供的动态代理实现，如果是方法则使用 CGLIB 实现Spring AOP 需要依赖 IOC 容器来管理，并且只能…
阅读更多...
IOS-相机权限申请-Swift

IOS-相机权限申请-Swift

配置描述 在Info.plist文件中，新建一个键值对Privacy - Camera Usage Description（或者NSCameraUsageDescription），值为申请描述说明，自定义的 申请 然后在需要申请的文件中导入AVFoundation import AVFoundation…
阅读更多...
nodejs学习计划--（一）初始nodejs

nodejs学习计划--（一）初始nodejs

1. 介绍nodejs Node.js是什么？ Node.js是一个开源的，跨平台的Javascript运行环境 通俗来讲：Node.js就是一款应用程序，是一款软件，它可以运行JavaScript Node.js的作用： 开发服务器应用开发工具类应用开发…
阅读更多...
美国 SEC 批准比特币现货 ETF 上市，SEC 告诉我们的风险包含哪些？

美国 SEC 批准比特币现货 ETF 上市，SEC 告诉我们的风险包含哪些？

撰文：Will 阿望 查看原文：美国 SEC 批准比特币现货 ETF 上市，SEC 告诉我们的风险包含哪些？ 历经十年的 BTC ETF 艰辛审批之路终于迎来了胜利的曙光，2024 年 1 月 11 日凌晨 4 时，美国证监会（S…
阅读更多...
浅谈Vue中监听属性—watch监听器的使用方法

浅谈Vue中监听属性—watch监听器的使用方法

目录 💡 监听属性的概念 💡 watch有什么作用 💡 watch的基本语法 💡 监听属性的优缺点 💡 使用watch的场景 💡 监听属性的概念 在计算机科学中，watch是一种调试技术，用于监视程…
阅读更多...
【SQL】SQL语法小结

【SQL】SQL语法小结

相关资料 参考链接1：SQL 语法（超级详细） 参考链接2：史上超强最常用SQL语句大全 SQL练习网站：CSDN、牛客、LeetCode、LintCode SQL相关视频： 推荐书籍： 文章目录 数据分析对SQL的要求SQL语法简介…
阅读更多...
onlyoffice源码编译

onlyoffice源码编译

环境准备 官网要求CPU dual core 2 GHz or better RAM at least 2 GB, but depends of the host OS. More is better HDD at least 40 GB of free space SWAP at least 4 GB, but depends of the host OS. More is better SoftwareOS 64-bit Ubuntu 16.04 The solution has be…
阅读更多...
ARM day1

ARM day1

一、概念 ARM可以工作的七种模式用户、系统、快中断、中断、管理、终止、未定义ARM核的寄存器个数 37个32位长的寄存器，当前处理器的模式决定着哪组寄存器可操作，且任何模式都可以存取： PC(program counter程序计数器) CPSR(current program…
阅读更多...
QT上位机开发（dock窗口在软件布局中的应用）

QT上位机开发（dock窗口在软件布局中的应用）

【 声明：版权所有，欢迎转载，请勿用于商业用途。 联系信箱：feixiaoxing 163.com】 在软件开发中，一般有主窗口和子窗口之分。主窗口也就是main window，是最重要的操作界面。子窗口就是各种属性配置、参数配置…
阅读更多...
USB8814动态信号采集卡——声音振动类信号处理的理想之选！

USB8814动态信号采集卡——声音振动类信号处理的理想之选！

背景介绍： 科技的发展在一定程度上依赖于对信号的处理，信号处理技术的先进性在很大程度上决定了科技发展的速度和方向。数字信号处理技术的崛起，彻底改变了传统的信息与信号处理方式，使得数据采集这一前期工作在数字系统中发挥着…
阅读更多...
使用PyTorch实现混合专家(MoE)模型

使用PyTorch实现混合专家(MoE)模型

Mixtral 8x7B 的推出在开放 AI 领域引发了广泛关注，特别是混合专家（Mixture-of-Experts：MoEs）这一概念被大家所认知。混合专家(MoE)概念是协作智能的象征，体现了“整体大于部分之和”的说法。MoE模型汇集了各种专家模型…
阅读更多...
网页设计（六）表格与表格页面布局

网页设计（六）表格与表格页面布局

一、设计《TF43: 前端的发展与未来》日程表 《TF43: 前端的发展与未来》日程表 文字素材： 前端是互联网技术的重要一环，自上世纪80年代万维网技术创立以来，Web成就了大量成功的商业公司，也诞生了诸多优秀的技术解决方案。因其标…
阅读更多...
SDRAM小项目——命令解析模块

SDRAM小项目——命令解析模块

简单介绍： 在FPGA中实现命令解析模块，命令解析模块的用来把pc端传入FPGA中的数据分解为所需要的数据和触发命令，虽然代码不多，但是却十分重要。 SDRAM的整体结构如下，可以看出，命令解析模块cmd_decode负责…
阅读更多...
网络分层及三次握手

网络分层及三次握手

5-网络 数据传输 服务器如何响应 网络分层和概念 2个地址：ip:逻辑地址；mac物理地址 通信过程中链路会发生转换，但是网络层寻址是不变的 ip地址不变，mac会变 每层的协议 每层协议指的就是约定和规范 应用层：cdn&dns…
阅读更多...
QT第五天

QT第五天

使用QT绘图和绘图事件&#xff0c;完成仪表盘绘图&#xff0c;如下图&#xff1a; 程序运行结果&#xff1a; 代码&#xff1a; widget.h #ifndef WIDGET_H #define WIDGET_H#include <QWidget> #include <QPainter> #include <QPen> #include <QBrush&…
阅读更多...
React初探：从环境搭建到Hooks应用全解析

React初探：从环境搭建到Hooks应用全解析

React初探&#xff1a;从环境搭建到Hooks应用全解析 一、React介绍 1、React是什么 React是由Facebook开发的一款用于构建用户界面的JavaScript库。它主要用于构建单页面应用中的UI组件&#xff0c;通过组件化的方式让开发者能够更轻松地构建可维护且高效的用户界面。 Reac…
阅读更多...
ubuntu qt 运行命令行

ubuntu qt 运行命令行

文章目录 1.C实现2.python实现 1.C实现 下面是封装好的C头文件&#xff0c;直接调用run_cmd_fun()即可。 #ifndef GET_CMD_H #define GET_CMD_H#endif // GET_CMD_H #include <iostream> #include<QString> using namespace std;//system("gnome-terminal -…
阅读更多...
最新文章

Copyright @ 2022~2023