from mxnet import nd

x, w_xh = nd.random.normal(shape=(3, 1)), nd.random.normal(shape=(1, 4))
h, w_hh = nd.random.normal(shape=(3, 4)), nd.random.normal(shape=(4, 4))

print(nd.dot(x, w_xh) + nd.dot(h, w_hh))

print(nd.dot(nd.concat(x, h, dim=1), nd.concat(w_xh, w_hh, dim=0)))

from mxnet import nd
import random
import zipfile

with zipfile.ZipFile(r'C:\Users\ROG\Downloads\d2l-zh\data\jaychou_lyrics.txt.zip') as zin:
    with zin.open('jaychou_lyrics.txt') as f:
        corpus_chars = f.read().decode('utf-8')
print(corpus_chars[:40])

# 这个数据集有6万多个字符。为了打印方便，我们把换行符替换成空格，然后仅使用前1万个字符来训练模型。

corpus_chars = corpus_chars.replace('\n', ' ').replace('\r', ' ')
corpus_chars = corpus_chars[0:10000]

# 建立字符索引

# 从你的先前代码中获取了一个字符串变量 corpus_chars，它包含了要处理的文本数据。

# Step 1: 创建索引到字符的映射 (idx_to_char)

# 这一步首先使用 set(corpus_chars) 获取了 corpus_chars 中不同的字符，然后使用 list() 转换为列表。
# 这样就创建了一个包含了文本中所有不同字符的列表 idx_to_char。
# 例如，如果文本中有字母 'a'、'b'、'c'，那么 idx_to_char 列表就会包含 ['a', 'b', 'c']。

idx_to_char = list(set(corpus_chars))

# Step 2: 创建字符到索引的映射 (char_to_idx)
char_to_idx = dict([(char, i) for i, char in enumerate(idx_to_char)])

# 这里使用了列表解析，遍历了 corpus_chars 中的每个字符，并为每个字符创建了一个键值对 (char, i)，
# 其中 char 是字符，i 是该字符在列表中的索引。这样就建立了字符到索引的映射。
# 例如，如果字符 'a' 在 corpus_chars 中第一次出现，它会被映射到索引 0，以此类推。

# Step 3: 计算词汇表大小 (vocab_size)
vocab_size = len(char_to_idx)

# 这一步简单地计算了 char_to_idx 字典的长度，即不同字符的数量。
# 这个数量就是词汇表的大小，通常用于设置神经网络中的嵌入层的维度，或者作为输出层的类别数。
# 例如，如果文本中有 26 个不同的字母，则 vocab_size 就是 26。

# 最终，你可以使用 char_to_idx 字典将文本中的字符转换为整数索引，
# 使用 idx_to_char 列表将整数索引转换回字符，以便进行深度学习模型的训练和预测。

print(vocab_size)

corpus_indices = [char_to_idx[char] for char in corpus_chars]
sample = corpus_indices[:20]
print('chars:', ''.join([idx_to_char[idx] for idx in sample]))
print('indices:', sample)


# 随机采样

def data_iter_random(corpus_indices, batch_size, num_steps):
    num_examples = (len(corpus_indices) - 1) // num_steps
    epoch_size = num_examples // batch_size
    examples_indices = list(range(num_examples))
    random.shuffle(examples_indices)

    def _data(pos):
        return corpus_indices[pos: pos + num_steps]

    for i in range(epoch_size):
        i = i * batch_size
        batch_indices = examples_indices[i:i + batch_size]

        x = [_data(j * num_steps) for j in batch_indices]
        y = [_data(j * num_steps + 1) for j in batch_indices]

        yield nd.array(x), nd.array(y)


my_seq = list(range(30))
for x, y in data_iter_random(my_seq, batch_size=2, num_steps=6):
    print('X: ', x, '\nY:', y, '\n')


def data_iter_consecutive(corpus_indices, batch_size, num_steps, ctx=None):
    corpus_indices = nd.array(corpus_indices, ctx=ctx)
    data_len = len(corpus_indices)
    batch_len = data_len // batch_size
    indices = corpus_indices[0: batch_size * batch_len].reshape((
        batch_size, batch_len))
    epoch_size = (batch_len - 1) // num_steps
    for i in range(epoch_size):
        i = i * num_steps
        X = indices[:, i: i + num_steps]
        Y = indices[:, i + 1: i + num_steps + 1]
        yield X, Y


for X, Y in data_iter_consecutive(my_seq, batch_size=2, num_steps=6):
    print('X: ', X, '\nY:', Y, '\n')