Beacon学习周记2（2022暑期项目）

import tensorflow as tf
print(tf.__version__)
mnist = tf.keras.datasets.fashion_mnist
(training_images, training_labels), (test_images, test_labels) = mnist.load_data()
training_images=training_images.reshape(60000, 28, 28, 1)
training_images=training_images / 255.0
test_images = test_images.reshape(10000, 28, 28, 1)
test_images=test_images/255.0
model = tf.keras.models.Sequential([
  tf.keras.layers.Conv2D(64, (3,3), activation='relu', input_shape=(28, 28, 1)),
  tf.keras.layers.MaxPooling2D(2, 2),
  tf.keras.layers.Conv2D(64, (3,3), activation='relu'),
  tf.keras.layers.MaxPooling2D(2, 2),
  tf.keras.layers.Flatten(),
  tf.keras.layers.Dense(128, activation='relu'),
  tf.keras.layers.Dense(10, activation='softmax')
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.summary()
model.fit(training_images, training_labels, epochs=5)
test_loss = model.evaluate(test_images, test_labels)

import tensorflow as tf
print(tf.__version__)

mnist = tf.keras.datasets.fashion_mnist
(training_images, training_labels), (test_images, test_labels) = mnist.load_data()

training_images=training_images.reshape(60000, 28, 28, 1)
training_images=training_images / 255.0
test_images = test_images.reshape(10000, 28, 28, 1)
test_images=test_images/255.0

model = tf.keras.models.Sequential([
  tf.keras.layers.Conv2D(64, (3,3), activation='relu', input_shape=(28, 28, 1)),
  tf.keras.layers.MaxPooling2D(2, 2),
  tf.keras.layers.Conv2D(64, (3,3), activation='relu'),
  tf.keras.layers.MaxPooling2D(2, 2),
  tf.keras.layers.Flatten(),
  tf.keras.layers.Dense(128, activation='relu'),
  tf.keras.layers.Dense(10, activation='softmax')
])

model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

model.summary()

model.fit(training_images, training_labels, epochs=5)
test_loss = model.evaluate(test_images, test_labels)

import scipy.sparse as sp
import numpy as np, os, re, itertools, math


# build_knowledge总结：
# 1.输出的最大序列长度是囊括训练集、验证集的实际最大长度-1
# 2.将训练集、验证集中所有序列的最后一个或两个篮子中的物品算进频度
def build_knowledge(training_instances, validate_instances):
    MAX_SEQ_LENGTH = 0  # 最大序列长度
    item_freq_dict = {}  # 物品频度字典

    for line in training_instances:  # training_instances是训练集，这个training_instances是train.txt按行读取后的内容。每个line是一个篮子序列
        elements = line.split("|")  # 生成每个line所表示的蓝子列表，len(elements)即序列中的篮子个数（对应README.md中所说的格式：篮子之间用"|"分割）

        if len(elements) - 1 > MAX_SEQ_LENGTH:  # 貌似若仅一个篮子，则最大序列长度依然是0，若有两个篮子，就会为1，所以实际上最大篮子序列长度会-1，因为第一个"篮子"永远是0或1
            MAX_SEQ_LENGTH = len(elements) - 1

        if len(elements) == 3:  # 3个篮子（实际长度为2）的序列如此特殊
            basket_seq = elements[1:]  # 取第二个篮子和第三个篮子（也就是两个实际的篮子）作为basket_seq
        else:
            basket_seq = [elements[-1]]  # 否则若序列的篮子数不为3就只取最后一个篮子作为basket_seq。官方回答是This method is to build the adjacency matrix. In order to avoid duplicate counts on computing pair frequency, hence I ignore baskets that are already considered.

        for basket in basket_seq:  # 对于basket_seq中的每个篮子
            item_list = re.split('[\\s]+', basket)  # item_list即是该篮子中物品的列表（对应README.md中所说的格式：篮子之间用" "分割，其中[\\s]+匹配任意多个空白字符）
            for item_obs in item_list:  # 对于item_list中的每个物品
                if item_obs not in item_freq_dict:  # 如果这个item_freq_dict字典中没有以item_obs物品为键的键值对的话
                    item_freq_dict[item_obs] = 1  # 添加该物品并置频度为1
                else:
                    item_freq_dict[item_obs] += 1  # 频度+1

    for line in validate_instances:  # 验证集
        elements = line.split("|")

        if len(elements) - 1 > MAX_SEQ_LENGTH:
            MAX_SEQ_LENGTH = len(elements) - 1

        label = int(elements[0])  # label是该篮子序列的第一个篮子
        if label != 1 and len(elements) == 3:  # 经过查看，在训练集、验证集、测试集文件中，确实只有validate.txt中的篮子序列，第一个"篮子"有可能出现"1"，其他两个数据集这一处只可能是"0"
            basket_seq = elements[1:]
        else:
            basket_seq = [elements[-1]]

        for basket in basket_seq:
            item_list = re.split('[\\s]+', basket)
            for item_obs in item_list:
                if item_obs not in item_freq_dict:
                    item_freq_dict[item_obs] = 1
                else:
                    item_freq_dict[item_obs] += 1  # 验证集数据也算进总频度字典中了

    items = sorted(list(item_freq_dict.keys()))  # items是一个按物品各自的ID升序排序的物品列表，列出所有出现过的物品
    item_dict = dict()
    item_probs = []  # 可能性？
    for item in items:
        item_dict[item] = len(item_dict)  # 物品ID可能不连续有跳跃，例如items可能为[1,2,4,7,9]，现在我们把这五个重新命名为第0号物品、第1号物品...第四号物品，item_dict此时就为{1: 0, 2: 1, 4: 2, 7: 3, 9: 4}（见附录第一条）
        item_probs.append(item_freq_dict[item])  # 复制频度，相当于把item_freq_dict按键升序排列后依次提取值（频度）组成item_probs列表

    item_probs = np.asarray(item_probs, dtype=np.float32)  # 将item_probs转化为ndarray类型，其中每个频度又被转化成32位浮点数格式
    item_probs /= np.sum(item_probs)  # 归一化了，现在每个元素体现出"占比"

    reversed_item_dict = dict(zip(item_dict.values(), item_dict.keys()))  # reversed_item_dict为{0: 1, 1: 2, 2: 4, 3: 7, 4: 9}
    return MAX_SEQ_LENGTH, item_dict, reversed_item_dict, item_probs  # build_knowledge方法接收训练集、验证集，返回最长篮子序列长度、ID-序号字典、序号-ID字典、按ID升序的物品频度可能性数组

def build_sparse_adjacency_matrix_v2(training_instances, validate_instances, item_dict):
    NB_ITEMS = len(item_dict)  # 所有出现过的物品的数量，不过貌似是最后一个或两个篮子中的物品才会被统计到

    pairs = {}
    for line in training_instances:
        elements = line.split("|")

        if len(elements) == 3:
            basket_seq = elements[1:]
        else:
            basket_seq = [elements[-1]]

        for basket in basket_seq:
            item_list = re.split('[\\s]+', basket)
            id_list = [item_dict[item] for item in item_list]  # 将每个篮子中物品的序号（原始顺序的）依次存入id_list（例如[4,2,0,1,3]）

            for t in list(itertools.product(id_list, id_list)):  # 做笛卡尔积，结合外层的两循环，产生了统计训练集中，每个篮子序列最后一个或两个篮子中共同出现的物品对的频度（对于共同出现的物品A、B，A与B、B与A分别统计1次）
                add_tuple(t, pairs)

    for line in validate_instances:
        elements = line.split("|")

        label = int(elements[0])
        if label != 1 and len(elements) == 3:
            basket_seq = elements[1:]
        else:
            basket_seq = [elements[-1]]

        for basket in basket_seq:
            item_list = re.split('[\\s]+', basket)
            id_list = [item_dict[item] for item in item_list]

            for t in list(itertools.product(id_list, id_list)):  # 验证集的物品对频度也被累计统计到了
                add_tuple(t, pairs)

    return create_sparse_matrix(pairs, NB_ITEMS)

# add_tuple作用是让pairs来记录出现在同一篮子中的两个不同物品构成的二元组出现的频度（论文中的F）
def add_tuple(t, pairs):  
    assert len(t) == 2  # 确保一下是二元组
    if t[0] != t[1]:
        if t not in pairs:
            pairs[t] = 1
        else:
            pairs[t] += 1

# create_sparse_matrix作用是产生论文中的矩阵F的压缩形态（多个坐标+值的三元组形态，因为可能太稀疏了）
def create_sparse_matrix(pairs, NB_ITEMS):
    row = [p[0] for p in pairs]  # 将pairs字典中的键（序号二元组）中的第一个元素提取出来做成列表row
    col = [p[1] for p in pairs]  # 将pairs字典中的键（序号二元组）中的第二个元素提取出来做成列表col
    data = [pairs[p] for p in pairs]  # 将pairs字典中的值（频度）提取出来做成列表data

    adj_matrix = sp.csc_matrix((data, (row, col)), shape=(NB_ITEMS, NB_ITEMS), dtype="float32")  # 此时adj_matrix就是F的压缩形态。具体而言，将物品按从0开始挨个编序后，这样的序号构成的二元组就是pairs字典的键，其值是频度。sp.csc_matrix以坐标+值的方式构造出来NB_ITEMSxNB_ITEMS大小的矩阵。也就是把这个矩阵中row[0],col[0]的坐标处的值置为data[0]（32位浮点数格式），也就是频度
    nb_nonzero = len(pairs)  # adj_matrix中非零元素的个数
    density = nb_nonzero * 1.0 / NB_ITEMS / NB_ITEMS  # adj_matrix的密度
    print("Density: {:.6f}".format(density))  # 打印密度，保留6位小数

    return sp.csc_matrix(adj_matrix, dtype="float32")