🐲背景：chatGPT最近火爆了各种论坛网站，趁着火热，没忍住的我总结了一些有趣的玩法，尝试一下吧！

🐲目录：

🤖轻度玩法

🤖中度玩法

🤖重度玩法

🤖yin度玩法

---

🎶轻度玩法

1. 润色英文稿

先问一问chatGPT润色英文稿都干嘛，看起来是默认英文回答的：

 我们让他用汉语回答：

 好了，接下来进入正题，选一段目标检测算法YOLOv3论文的Abstract部分看看他怎样润色：

 看起来还不错，粗略看过去把new改成了novel，还有一些extrmely和incredibly的同义替换。总体逻辑也没有错误。

 

2. 写实验报告 / 列大纲

整日被实验报告折磨的日子结束了，只需要输入一些提示，chatGPT就可以给出一个完整的大纲，然后继续追问就可以写完了！比如大家都写过的xxx系统😒。

 

 除了不会画流程图，其他口水报告写的很精彩😂。

3. 口水文作家

这个玩法很有意思，你只要告诉他你要写什么，然后加上“给我来一个令人眼前一亮的xxx”，chatGPT就会给你一些想要的段落。例如：

 哈哈哈，其实我的标题也是chatGPT生成的🐽。 

🎶中度玩法

1. 写代码

最有用的地方之一，chatGPT对于代码要求的理解能力很高，而且如果不正确的话，继续询问可以让他自己找到bug：

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>

#define PORT 8888

int main(int argc, char const *argv[])
{
    int server_fd, new_socket, valread;
    struct sockaddr_in address;
    int opt = 1;
    int addrlen = sizeof(address);
    char buffer[1024] = {0};
    char *hello = "Hello from server";

    // Creating socket file descriptor
    if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0)
    {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }

    // Forcefully attaching socket to the port 8888
    if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt)))
    {
        perror("setsockopt");
        exit(EXIT_FAILURE);
    }
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(PORT);

    // Bind the socket to localhost port 8888
    if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0)
    {
        perror("bind failed");
        exit(EXIT_FAILURE);
    }

    // Listen for incoming connections
    if (listen(server_fd, 3) < 0)
    {
        perror("listen");
        exit(EXIT_FAILURE);
    }

    // Accept an incoming connection
    if ((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t *)&addrlen)) < 0)
    {
        perror("accept");
        exit(EXIT_FAILURE);
    }

    // Receive a message from the client
    valread = read(new_socket, buffer, 1024);
    printf("%s\n", buffer);

    // Send a message to the client
    send(new_socket, hello, strlen(hello), 0);
    printf("Hello message sent\n");

    return 0;
}

 客户端代码：

#include <iostream>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>

int main(int argc, char const *argv[]) {
    int sock = 0, valread;
    struct sockaddr_in serv_addr;
    char const* hello = "Hello from client";
    char buffer[1024] = {0};

    // 创建客户端socket
    if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        std::cerr << "Socket creation error" << std::endl;
        return -1;
    }

    // 配置服务器地址
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(8080);

    // 转换IP地址为网络字节序
    if(inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr)<=0) {
        std::cerr << "Invalid address/ Address not supported" << std::endl;
        return -1;
    }

    // 连接到服务器
    if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
        std::cerr << "Connection Failed" << std::endl;
        return -1;
    }

    // 发送消息到服务器
    send(sock , hello , strlen(hello) , 0 );
    std::cout << "Hello message sent" << std::endl;

    // 从服务器接收消息
    valread = read( sock , buffer, 1024);
    std::cout << buffer << std::endl;

    // 关闭socket
    close(sock);
    return 0;
}

而且会给出思路：

要注意的是，有时候代码经过验证会有bug，不是绝对正确的，但是你只要不断追问并给出问题，他就可以自我完善，最终让代码正确。 

2. 数据分析

这里的数据分析不是指数据挖掘等等方法，我还没有测试过，但只要给他一个图表，他就可以分析整个过程，例如：

但是要记住，他会胡说八道！因此看到错误向他反馈，chatGPT就会慢慢修正，例如：

🎶重度玩法

1. 假装训练神经网络

这个玩法属于是重度GPT用户了，五花八门，最简单的就是让他直接运行，当然完整版甚至可以冒充一个Linux终端：

 

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision.datasets import MNIST
from torchvision.transforms import Compose, ToTensor, Normalize
from torchvision.models import alexnet

# 设置设备为GPU，如果可用
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# 加载MNIST数据集
transform = Compose([ToTensor(), Normalize((0.1307,), (0.3081,))])
train_dataset = MNIST(root="./data", train=True, download=True, transform=transform)
test_dataset = MNIST(root="./data", train=False, download=True, transform=transform)

# 创建数据加载器
train_loader = DataLoader(train_dataset, batch_size=128, shuffle=True, num_workers=4)
test_loader = DataLoader(test_dataset, batch_size=128, shuffle=False, num_workers=4)

# 定义AlexNet模型
model = alexnet(num_classes=10)
model.to(device)

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)

# 训练模型
for epoch in range(10):
    # 训练模型
    model.train()
    train_loss = 0.0
    train_correct = 0
    for batch_idx, (data, target) in enumerate(train_loader):
        data, target = data.to(device), target.to(device)
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, target)
        loss.backward()
        optimizer.step()

        # 计算训练损失和准确率
        train_loss += loss.item() * data.size(0)
        pred = output.argmax(dim=1, keepdim=True)
        train_correct += pred.eq(target.view_as(pred)).sum().item()

    train_loss /= len(train_loader.dataset)
    train_acc = train_correct / len(train_loader.dataset)

    # 在测试集上评估模型
    model.eval()
    test_loss = 0.0
    test_correct = 0
    with torch.no_grad():
        for data, target in test_loader:
            data, target = data.to(device), target.to(device)
            output = model(data)
            loss = criterion(output, target)

            # 计算测试损失和准确率
            test_loss += loss.item() * data.size(0)
            pred = output.argmax(dim=1, keepdim=True)
            test_correct += pred.eq(target.view_as(pred)).sum().item()

    test_loss /= len(test_loader.dataset)
    test_acc = test_correct / len(test_loader.dataset)

    # 输出训练结果
    print("Epoch [{}/{}], train loss: {:.4f}, train acc: {:.4f}, test loss: {:.4f}, test acc: {:.4f}"
          .format(epoch+1, 10, train_loss, train_acc, test_loss, test_acc))

这种玩法只是最简单的奥，复杂版大家可以看看，非常神奇。

🎶yin度玩法

看图说话，chatGPT没有人类狡猾系列😎：

 看来不听话，继续：

 被警告了😂。

 先到这里吧，其他玩法可以一起讨论┗|｀O′|┛ 嗷~~