# 创建虚拟环境
python -m venv d2l_learn

# 激活虚拟环境
.\d2l_learn\Scripts\activate

# 退出虚拟环境
deactivate

# 安装pytorch
pip install torch==2.4.1 torchvision==0.19.1 torchaudio==2.4.1  --index-url https://download.pytorch.org/whl/cu121

# 安装d2l依赖包
pip install pandas requests IPython matplotlib scipy notebook

# 下载d2l，获取d2l模块，放入Lib\site-packages文件夹，因为 pip install d2l 直接安装报错
git clone https://github.com/d2l-ai/d2l-en.git
git clone https://github.com/d2l-ai/d2l-zh-pytorch-colab.git

# 打开Jupyter笔记本
cd .\d2l-zh-pytorch-colab\
jupyter notebook

import torch
from torch import nn
from d2l import torch as d2l

# 构建神经网络结构
net = nn.Sequential(
    nn.Conv2d(1, 6, kernel_size=5, padding=2), nn.Sigmoid(),
    nn.AvgPool2d(kernel_size=2, stride=2),
    nn.Conv2d(6, 16, kernel_size=5), nn.Sigmoid(),
    nn.AvgPool2d(kernel_size=2, stride=2),
    nn.Flatten(),
    nn.Linear(16 * 5 * 5, 120), nn.Sigmoid(),
    nn.Linear(120, 84), nn.Sigmoid(),
    nn.Linear(84, 10))

# 查看每一层输出结果
X = torch.rand(size=(1, 1, 28, 28), dtype=torch.float32)
for layer in net:
    X = layer(X)
    print(layer.__class__.__name__,'output shape: \t',X.shape)

# 准备数据
batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size=batch_size)

# 模型评估
def evaluate_accuracy_gpu(net, data_iter, device=None): #@save
    """使用GPU计算模型在数据集上的精度"""
    if isinstance(net, nn.Module):
        net.eval()  # 设置为评估模式
        if not device:
            device = next(iter(net.parameters())).device
    # 正确预测的数量，总预测的数量
    metric = d2l.Accumulator(2)
    with torch.no_grad():
        for X, y in data_iter:
            if isinstance(X, list):
                # BERT微调所需的（之后将介绍）
                X = [x.to(device) for x in X]
            else:
                X = X.to(device)
            y = y.to(device)
            metric.add(d2l.accuracy(net(X), y), y.numel())
    return metric[0] / metric[1]

# 模型训练
#@save
def train_ch6(net, train_iter, test_iter, num_epochs, lr, device):
    """用GPU训练模型(在第六章定义)"""
    def init_weights(m):
        if type(m) == nn.Linear or type(m) == nn.Conv2d:
            nn.init.xavier_uniform_(m.weight)
    net.apply(init_weights)
    print('training on', device)
    net.to(device)
    optimizer = torch.optim.SGD(net.parameters(), lr=lr)
    loss = nn.CrossEntropyLoss()
    animator = d2l.Animator(xlabel='epoch', xlim=[1, num_epochs],
                            legend=['train loss', 'train acc', 'test acc'])
    timer, num_batches = d2l.Timer(), len(train_iter)
    for epoch in range(num_epochs):
        # 训练损失之和，训练准确率之和，样本数
        metric = d2l.Accumulator(3)
        net.train()
        for i, (X, y) in enumerate(train_iter):
            timer.start()
            optimizer.zero_grad()
            X, y = X.to(device), y.to(device)
            y_hat = net(X)
            l = loss(y_hat, y)
            l.backward()
            optimizer.step()
            with torch.no_grad():
                metric.add(l * X.shape[0], d2l.accuracy(y_hat, y), X.shape[0])
            timer.stop()
            train_l = metric[0] / metric[2]
            train_acc = metric[1] / metric[2]
            if (i + 1) % (num_batches // 5) == 0 or i == num_batches - 1:
                animator.add(epoch + (i + 1) / num_batches,
                             (train_l, train_acc, None))
        test_acc = evaluate_accuracy_gpu(net, test_iter)
        animator.add(epoch + 1, (None, None, test_acc))
    print(f'loss {train_l:.3f}, train acc {train_acc:.3f}, '
          f'test acc {test_acc:.3f}')
    print(f'{metric[2] * num_epochs / timer.sum():.1f} examples/sec '
          f'on {str(device)}')

# 训练和评估LeNet-5模型

lr, num_epochs = 0.9, 10
train_ch6(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())

# 下载公钥
wget -O cpolar-public.key http://openwrt.cpolar.com/releases/public.key
opkg-key add cpolar-public.key

# 更新包管理器
opkg update

# 安装cpolar插件

opkg install cpolar

# 查看 pip 下载包缓存位置
pip cache dir

# 清理所有缓存
pip cache purge

# 查看 pip 安装包位置
pip show package_name

# venv
python -m venv .my-env
source .my-env/bin/activate

# pip安装 pytorch gpu 版本
pip install torch==2.4.1 torchvision==0.19.1 torchaudio==2.4.1  --index-url https://download.pytorch.org/whl/cu121
pip install transformers

# pip安装默认 pytorch cpu 版本
pip install torch==2.4.1 torchvision==0.19.1 torchaudio==2.4.1 --index-url https://download.pytorch.org/whl/cpu
pip install transformers

# 方括号 [] 的作用是指定额外的可选依赖包。
pip install "transformers[torch]"

import torch
print(torch.__version__)  # 应该显示 2.4.1+cu121
print(torch.cuda.is_available())  # 应该为 True（GPU版本）
print(torch.version.cuda)  # 应该显示 12.1

from transformers import pipeline

pipeline = pipeline(task="text-generation", model="Qwen/Qwen2.5-1.5B")
pipeline("the secret to baking a really good cake is ")

Script\activate

set HF_ENDPOINT=https://hf-mirror.com
echo %HF_ENDPOINT%

# 下载大模型默认保存位置：C:\Users\jack\.cache\huggingface\hub\
hf download Qwen/Qwen2.5-0.5B

# 自定义大模型保存位置
hf download Qwen/Qwen2.5-0.5B --local-dir ./LLM/Qwen/Qwen2.5-0.5B

# 自定义数据集保存位置
hf download --repo-type dataset --local-dir DataSet/glue glue

vcpkg install openssl asio tinyxml2 fastcdr foonathan-memory --triplet x64-windows

cd i:\project\Fast-DDS\
git clone https://github.com/eProsima/foonathan_memory_vendor.git
cd foonathan_memory_vendor
mkdir build && cd build
cmake -DCMAKE_INSTALL_PREFIX=i:/install/foonathan_memory_vendor ..
cmake --build . --config Release --target install

cd i:\project\Fast-DDS\
git clone https://github.com/eProsima/Fast-CDR.git
cd Fast-CDR
mkdir build && cd build
cmake -A x64 -DCMAKE_INSTALL_PREFIX=i:/install/fastcdr ..
cmake --build . --config Release --target install

cd i:\project\Fast-DDS\
git clone https://github.com/eProsima/Fast-DDS.git
cd Fast-DDS
mkdir build && cd build
cmake -DCMAKE_INSTALL_PREFIX=i:/install/fastdds   ..
cmake --build . --config Release --target install

eprosima_find_thirdparty(Asio asio VERSION 1.13.0)

警告 C4819 该文件包含不能在当前代码页(936)中表示的字符。请将该文件保存为 Unicode 格式以防止数据丢失

include '..\implib.inc'

; XYZLIBRARY.??4CXyz@@QAEAAV0@$$QAV0@@Z ord.1
implib XyzLibrary.dll, ??4CXyz@@QAEAAV0@$$QAV0@@Z
; XYZLIBRARY.??4CXyz@@QAEAAV0@ABV0@@Z ord.2
implib XyzLibrary.dll, ??4CXyz@@QAEAAV0@ABV0@@Z
; XYZLIBRARY.?Foo@CXyz@@QAEHH@Z ord.3
implib XyzLibrary.dll, ?Foo@CXyz@@QAEHH@Z
; XYZLIBRARY.GetXyz ord.4
implib XyzLibrary.dll, GetXyz
; XYZLIBRARY._GetXyz@0 ord.5
implib XyzLibrary.dll, _GetXyz@0
; XYZLIBRARY._XyzFoo@8 ord.6
implib XyzLibrary.dll, _XyzFoo@8
; XYZLIBRARY._XyzRelease@4 ord.7
implib XyzLibrary.dll, _XyzRelease@4

endlib

\bin\dll2def c:\windows\system32\kernel32.dll kernel32.def

\bin\fasm kernel32.def kernel32.lib

# 示例1

std::thread myThread ( thread_fun);
//函数形式为void thread_fun()
myThread.join();
//同一个函数可以代码复用，创建多个线程

# 示例2

std::thread myThread ( thread_fun(100));
myThread.join();
//函数形式为void thread_fun(int x)
//同一个函数可以代码复用，创建多个线程

# 示例3

std::thread (thread_fun,1).detach();
//直接创建线程，没有名字
//函数形式为void thread_fun(int x)

if (myThread.joinable()) foo.join();

#include <iostream>                // std::cout
#include <thread>                // std::thread
#include <mutex>                // std::mutex, std::unique_lock
#include <condition_variable>    // std::condition_variable

std::mutex mtx; // 全局互斥锁.
std::condition_variable cv; // 全局条件变量.
bool ready = false; // 全局标志位.

void do_print_id(int id)
{
	std::unique_lock <std::mutex> lck(mtx);
	while (!ready) // 如果标志位不为 true, 则等待...
		cv.wait(lck); // 当前线程被阻塞, 当全局标志位变为 true 之后,
	   // 线程被唤醒, 继续往下执行打印线程编号id.
	std::cout << "thread " << id << '\n';
}

void go()
{
	std::unique_lock <std::mutex> lck(mtx);
	ready = true; // 设置全局标志位为 true.
	cv.notify_all(); // 唤醒所有线程.
}

int main()
{
	std::thread threads[10];
	// spawn 10 threads:
	for (int i = 0; i < 10; ++i)
		threads[i] = std::thread(do_print_id, i);

	std::cout << "10 threads ready to race...\n";
	go(); // go!

	for (auto & th : threads)
		th.join();

	return 0;
}

#include <iostream>
#include <vector>
#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <functional>
#include <future>


class ThreadPool {
public:
    ThreadPool(size_t numThreads) : stop(false) {
        for (size_t i = 0; i < numThreads; ++i) {
            workers.emplace_back([this] {
                while (true) {
                    std::function<void()> task;
                    {
                        std::unique_lock<std::mutex> lock(queueMutex);
                        condition.wait(lock, [this] { return stop || !tasks.empty(); });
                        if (stop && tasks.empty()) {
                            return;
                        }
                        task = std::move(tasks.front());
                        tasks.pop();
                    }
                    task();
                }
            });
        }
    }

    template<typename F, typename... Args>
    auto enqueue(F&& f, Args&&... args) -> std::future<typename std::result_of<F(Args...)>::type> {
        using return_type = typename std::result_of<F(Args...)>::type;

        auto task = std::make_shared<std::packaged_task<return_type()>>(std::bind(std::forward<F>(f), std::forward<Args>(args)...));

        std::future<return_type> result = task->get_future(); // 返回一个futur对象，result通过result.get()获取线程函数的返回值 如果线程函数没有执行完就会阻塞在result.get()
        {
            std::unique_lock<std::mutex> lock(queueMutex);
            if (stop) {
                throw std::runtime_error("enqueue on stopped ThreadPool");
            }
            tasks.emplace([task]() { (*task)(); }); // Lambda函数是一种可调用对象 Lambda函数的语法为[捕获列表](参数列表) { 函数体 }。
        }
        condition.notify_one();
        return result;
    }

    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(queueMutex);
            stop = true;
        }
        condition.notify_all();
        for (std::thread& worker : workers) {
            worker.join();
        }
    }

private:
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;
    std::mutex queueMutex;
    std::condition_variable condition;
    bool stop;
};

// 示例任务函数
int  printHello(int num) {
    std::cout << "Hello from thread " << std::this_thread::get_id() << "! Num: " << num << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(1));
    return num;
}

int main() {
    ThreadPool pool(4);

    std::vector<std::future<int>> results; 

    // 提交任务到线程池
    std::cout << "Enqueuing tasks..." << std::endl;
    for (int i = 0; i < 8; ++i) {
        results.push_back(pool.enqueue(printHello, i));
    }

    for (int i = 0; i < 8; ++i) {
        int num = results[i].get(); // 获取线程函数的返回值
        std::cout<< "获取到线程函数的返回值：" << num << std::endl;    // 获取线程函数的返回值  
    }

    // 等待任务完成
    std::this_thread::sleep_for(std::chrono::seconds(5));

    return 0;
}