# diy-chat1

**Repository Path**: goodshred/diy-chat1

## Basic Information

- **Project Name**: diy-chat1
- **Description**: No description available
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2024-03-07
- **Last Updated**: 2024-04-30

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# 方向
1. 数据处理
2. 解码器

# b站视频任务拆解
[transformer实战-单词预测-新版](https://www.cnblogs.com/cauwj/p/17536041.html)
[transformer实战-单词预测-旧版](https://blog.csdn.net/sinat_28015305/article/details/109410129)
[b站视频]( https://b23.tv/h2D5kCv)

[手写transformer源码](https://nlp.seas.harvard.edu/2018/04/03/attention.html)
[课程代码:Transformer介绍及架构解析](https://blog.csdn.net/sinat_28015305/article/details/109384223?spm=1001.2014.3001.5502)

[课程代码:使用Transformer构建语言模型](https://blog.csdn.net/sinat_28015305/article/details/109410129?spm=1001.2014.3001.5502)


import warnings
warnings.filterwarnings('ignore')


# 问题
memory = self.transformer(src, tgt)  decoder传2个参数？encoder传1个参数？

# 一些参考链接
https://github.com/cs32963/babyGPT/blob/main/model.py
https://github.com/honeyandme/all-the-way-to-chatgpt/tree/main

https://chat.tinycms.xyz:3002/

独热编码： https://zhuanlan.zhihu.com/p/668263688
# 中文分词
```python
pip install jieba

```

训练数据：一篇文章
入参：一个问题
出参：一个回答


PyTorch中的 forward() 方法详解 https://zhuanlan.zhihu.com/p/370234492



```python
import torch

if __name__ == "__main__":
    '''
    对于一个一维向量，增加维度有两个方向。
    dim=0这个方向，相当于直接把整个向量作为高维张量的一个值，可以说是水平扩展。(在最外面加括号)
    dim=1这个方向，相当于让原向量的每个维度独立成一个向量，可以说垂直扩展(给每一个元素加括号)
    '''
    x = torch.tensor([[1, 2], [3, 4]])
    print(torch.unsqueeze(x, 0))    # tensor([[[1, 2],[3, 4]]])
    '''
    tensor([[[1, 2]],[[3, 4]]])
    '''
   # print(torch.unsqueeze(x, 1))
```


view就相当于是reshape（变换后不能少元素），重构张量：https://zhuanlan.zhihu.com/p/87856193，
view(-1)将张量变成一维张量,view(-1,a)表示不指定行，指定列，比如[1,2,3,4]，那么a只能是1（4行1列），2（2行2列），4（1行4列）


生成式对抗预训练：训练数据data=[我 想要 一杯 咖啡]，那么dataLoader([我,想要],[想要，一杯]，[一杯，咖啡])，
for batch_idx, (input_seq, target_seq) in enumerate(train_loader):就可以得到输入序列和目标序列


torch.ones((4, 4, 2)) 创建了一个形状为（4,4,2）的张量，其中所有元素都为1【torch.ones((4, 4, 2))和torch.ones(4, 4, 2)效果一样，不过参数类型不同的区别而已，前者是一个参数，格式是元组，后者是3个参数】
torch.rand(4, 4, 2)  创建一个形状为（4,4,2）的张量，其中的每个元素都是从均匀分布（在区间 [0, 1) 内）中随机抽取的

`nn.Linear(d_model, vocab_size)` 是 PyTorch 中神经网络模块 `nn` 中的一个线性层（Linear Layer）的定义。这段代码表示创建了一个线性层，其输入特征数量为 `d_model`，输出特征数量为 `vocab_size`。

具体来说，线性层将输入的特征向量（大小为 `d_model`）与权重矩阵相乘，然后加上偏置向量，最终输出一个大小为 `vocab_size` 的特征向量。这个过程可以表示为 $y = xW^T + b$，其中 $x$ 是输入特征向量，$W$ 是权重矩阵，$b$ 是偏置向量，$y$ 是输出特征向量。

在神经网络中，线性层通常用于学习输入特征与输出特征之间的线性映射关系。这在许多神经网络模型中都是非常常见的操作，例如在多层感知机（MLP）中，线性层通常用于隐藏层和输出层之间的连接。

输入特征向量的形状为 (batch_size, d_model)，输出特征向量的形状为 (batch_size, vocab_size)。

# 维度梳理
 memory = self.transformer(src, tgt) 【tensor(32,32,256)】
 output = self.fc(memory) 【tensor(32,32,27)】27是词典的长度
 

'''
1. 生成词汇表，set集合，并将index,value字典保存下来，这样就能将每个单词转成数字
2. 然后使用位置编码可以得到在数据集中单词与单词的相关度
3. 
'''


data = torch.rand(2,4)
print(data[:, :data.size(1)]) # 第一维度取所有，第二维度取4
print(data[:, :data.size(0)]) # 第一维度取所有，第二维度取2
'''
tensor([[0.7693, 0.4567, 0.9566, 0.5424],
        [0.9279, 0.7374, 0.3833, 0.9136]])
tensor([[0.7693, 0.4567],
        [0.9279, 0.7374]])
'''

-------位置编码：二维张量不需要位置编码，所以在这里做了一个升维pe = pe.unsqueeze(0)
# 定义位置编码器类, 我们同样把它看做一个层, 因此会继承nn.Module
class PositionalEncoding(nn.Module):
    def __init__(self, d_model, dropout, max_len=5000):
        super(PositionalEncoding, self).__init__()
        self.dropout = nn.Dropout(p=dropout)
        pe = torch.zeros(max_len, d_model)
        position = torch.arange(0, max_len).unsqueeze(1)
        div_term = torch.exp(torch.arange(0, d_model, 2) *
                             -(math.log(10000.0) / d_model))
        pe[:, 0::2] = torch.sin(position * div_term)
        pe[:, 1::2] = torch.cos(position * div_term)
        # [5000,4]---》[1，5000,4]
        pe = pe.unsqueeze(0)
        self.register_buffer('pe', pe)
    # x=[2,4]
    def forward(self, x):
        # pe=[1，5000,4]
        # return self.pe
        # return  self.pe[:, :pe.size(1)]
        # cc=[1,4,4],5000行取前4行
        cc = self.pe[:, :x.size(1)]
        print(cc)
        print(x)
        x += x + cc
        print(x)
        # x = x + Variable(self.pe[:, :x.size(1)],
        #                  requires_grad=False)
        return x
        # return self.dropout(x)


data = torch.rand(2, 4)
encoding = PositionalEncoding(4, 0.1)
encoding1 = encoding(data)
print(encoding1)