当前位置：首页 > news >正文

第N1周：one-hot编码案例

news 来源：原创 2025/5/24 16:22:37

>- **🍨 本文为[🔗365天深度学习训练营]中的学习记录博客**
>- **🍖 原作者：[K同学啊]**

本人往期文章可查阅：深度学习总结

本周任务：

加载页面顶端的的 .txt 文件，使用字典序列方法与one-hot编码进行数字化处理。

🏡 我的环境：

语言环境：Python3.11

编译器：PyCharm

深度学习环境：Pytorch

- torch==2.0.0+cu118

- torchvision==0.18.1+cu118
显卡：NVIDIA GeForce GTX 1660

1. one-hot 编码概念

自然语言处理（NLP）入门，绕不开的第一个概念就是词向量。什么是词向量，这个东西又是做什么用的呢？

文字对于计算机来说仅仅只是一个个符号，计算机无法理解其中含义，更无法处理。因此，NLP第一步就是：将文本数字化。

NLP中最早期的文本数字化方法，就是将文本转换为字典序列。如：“阿” 是新华字典中第一个单词，所以它的字典序列就是 1。

比较直观的文本数字化方法是采用上面提到的字典序列。例如，对于一个有三个类别的问题，可以用1、2和3分别表示这三个类别。但是，这种数字化方法存在一个问题，就是模型可能会错误地认为不同类别之间存在一些顺序或距离关系，而实际上这些关系可能是不存在的或者不具有实际意义的。

为了避免这种问题，引入了one-hot编码（也称独热编码）。one-hot编码的基本思想是将每个类别映射到一个向量，其中只有一个元素的值为1，其余元素的值为0。这样，每个类别之间就是相互独立的，不存在顺序或距离关系。例如，对于三个类别的情况，可以使用如下的one-hot编码：

类别1：[1,0,0]
类别2：[0,1,0]
类别3：[0,0,1]

这样的表示方式有助于模型更好地理解文本含义。在深度学习中，神经网络的输入层通常使用one-hot编码来表示分类变量。这种编码方式不仅能够避免不必要的关系假设，还能够提供清洗的输入表示，有助于模型的学习和泛化。

例如：

John likes to watch movies. Mary likes too
John also likes to watch football games.

以上两句可以构造一个词典：

{"John":1,"likes":2,"to":3,"watch":4,"movies":5,"also":6,"football":7,"games":8,"Mary":9,"too":10}

one-hot可表示为：

John:[1,0,0,0,0,0,0,0,0,0]
likes:[0,1,0,0,0,0,0,0,0,0]
…………等等，以此类推

（1）one-hot优点：

解决了分类器不好处理离散数据的问题，能够处理非连续型数值特征。

（2）one-hot缺点：

在文本表征表上有些缺点非常突出，首先one-hot编码是一个词袋模型，是不考虑词和词之间的顺序问题，它是假设词和词之间是相互独立的，但是在大部分情况下词和词之间是相互影响的。

one-hot编码得到的特征是离散稀疏的，每个单词的one-hot编码维度是整个词汇表的大小，维度非常巨大，编码稀疏，会使得计算代价变大。

2. 英文文本案例

import torch
import torch.nn.functional as F

# 示例文本
texts=['Hello, how are you?','I am doing well, thank you!','Goodbye.']


# 构建词表
word_index={}
index_word={}
for i,word in enumerate(set(" ".join(texts).split())):
    word_index[word]=i
    index_word[i]=word
    
# 将文本转化为整数序列
sequences=[[word_index[word] for word in text.split()] for text in texts]

# 获取词汇表大小，即单词的数量
vocab_size=len(word_index)

# 创建一个形状为 (len(texts),vocab_size) 的零矩阵，用于存储 one-hot 编码
one_hot_results=torch.zeros(len(texts),vocab_size)
# 将整数序列转化为one-hot编码
for i,seq in enumerate(sequences):
    one_hot_results[i,seq]=1
    
# 打印结果
print("词汇表：")
print(word_index)
print("\n文本：")
print(texts)
print("\n文本序列：")
print(sequences)
print("\nOne-Hot编码：")
print(one_hot_results)

运行结果：

词汇表：
{'are': 0, 'thank': 1, 'I': 2, 'Goodbye.': 3, 'how': 4, 'you?': 5, 'Hello,': 6, 'well,': 7, 'you!': 8, 'am': 9, 'doing': 10}

文本：
['Hello, how are you?', 'I am doing well, thank you!', 'Goodbye.']

文本序列：
[[6, 4, 0, 5], [2, 9, 10, 7, 1, 8], [3]]

One-Hot编码：
tensor([[1., 0., 0., 0., 1., 1., 1., 0., 0., 0., 0.],
        [0., 1., 1., 0., 0., 0., 0., 1., 1., 1., 1.],
        [0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0.]])

2.1 enumerate

enumerate 是Python中的一个内置函数，用于在循环中同时获取元素及其索引。它将一个可迭代对象（如列表、元组、字符串等）转换为一个枚举对象（enumerate对象），其中每个元素是一个包含索引和值的元组 (index, value)。

enumerate(inerable, start=0) ：

iterable ：需要枚举的可迭代对象。
start ：索引的起始值，默认为0。

示例：

假设我们有一个列表 fruits，我们希望在循环中同时获取每个水果的名称及索引：

fruits=["apple","banana","cherry"]

# 使用普通循环
index=0
for fruit in fruits:
    print(index,fruit)
    index+=1

# 使用 enumerate
for index, fruit in enumerate(fruits):
    print(inde,fruit)

输出：

0 apple
1 banana
2 cherry

可以看出， enumerate 的输出与手动维护索引变量的输出完全一致，但代码更加简洁。

2.2 sequences=[[word_index[word] for word in text.split()] for text in texts]

这段代码展示了如何将一组文本转换为基于词索引的序列。这在自然语言处理（NLP）中是一个常见的预处理步骤，通常用于将文本数据转换为模型可以处理的数值形式。

（1）texts：这是一个包含多个文本句子的列表。如：

texts = ['Hello, how are you?', 'I am doing well, thank you!', 'Goodbye.']

（2）word_index：这是一个字典，将每个单词映射到一个唯一的索引。

word_index = {'hello': 0, 'how': 1, 'are': 2, 'you': 3, 'i': 4, 'am': 5, 'doing': 6, 'well': 7, 'thank': 8, 'goodbye': 9}

（3） text.split()：将每个文本句子分割成单词列表。

例如：'Hello, how are you?' 被分割为 ['Hello,', 'how', 'are', 'you?']

（4）word_index[word]：将每个单词转换为其对应的索引。

（5）总体而言，假设：

texts = ['Hello, how are you?', 'I am doing well, thank you!', 'Goodbye.']
word_index = {'Hello,': 0, 'how': 1, 'are': 2, 'you?': 3, 'I': 4, 'am': 5, 'doing': 6, 'well,': 7, 'thank': 8, 'you!': 9, 'Goodbye.': 10}

运行代码后，sequences 的结果为：

sequences = [
    [0, 1, 2, 3],  # 对应 'Hello, how are you?'
    [4, 5, 6, 7, 8, 9],  # 对应 'I am doing well, thank you!'
    [10]  # 对应 'Goodbye.'
]

3. 中文文本案例

import torch
import torch.nn.functional as F

# 示例中文文本
texts=['你好，最近怎么样？','我过得很好，谢谢！','K同学啊']

# 构建词汇表
word_index={}
index_word={}
for i,word in enumerate(set("".join(texts))):
    word_index[word]=i
    index_word[i]=word
    
# 将文本转化为整数序列
sequences=[[word_index[word] for word in text] for text in texts]

# 获取词汇表大小
vocab_size=len(word_index)

# 将整数序列转化为one-hot编码
one_hot_results=torch.zeros(len(texts),vocab_size)
for i,seq in enumerate(sequences):
    one_hot_results[i,seq]=1
    
# 打印结果
print("词汇表：")
print(word_index)
print("\n文本：")
print(texts)
print("\n文本序列：")
print(sequences)
print("\nOne-Hot编码：")
print(one_hot_results)

运行结果：

词汇表：
{'近': 0, '同': 1, '很': 2, '，': 3, '过': 4, '！': 5, 'K': 6, '你': 7, '我': 8, '样': 9, '学': 10, '得': 11, '怎': 12, '啊': 13, '？': 14, '最': 15, '谢': 16, '好': 17, '么': 18}

文本：
['你好，最近怎么样？', '我过得很好，谢谢！', 'K同学啊']

文本序列：
[[7, 17, 3, 15, 0, 12, 18, 9, 14], [8, 4, 11, 2, 17, 3, 16, 16, 5], [6, 1, 10, 13]]

One-Hot编码：
tensor([[1., 0., 0., 1., 0., 0., 0., 1., 0., 1., 0., 0., 1., 0., 1., 1., 0., 1.,
         1.],
        [0., 0., 1., 1., 1., 1., 0., 0., 1., 0., 0., 1., 0., 0., 0., 0., 1., 1.,
         0.],
        [0., 1., 0., 0., 0., 0., 1., 0., 0., 0., 1., 0., 0., 1., 0., 0., 0., 0.,
         0.]])

可以注意到上面的案例是以字（字符）为基本单位的，而不是按单词（或词）进行拆分，所以，在 join(texts) 后面不需要添加 .split() 函数。因此，word_index 和 index_word 实际上是基于字符的映射，而不是基于单词的映射。如：

texts = ['你好，最近怎么样？', '我过得很好，谢谢！', 'K同学啊']

运行代码后：

word_index = {
    '你': 0, '好': 1, '，': 2, '最': 3, '近': 4, '怎': 5, '么': 6, '样': 7, '？': 8,
    '我': 9, '得': 10, '很': 11, '谢': 12, '！': 13, 'K': 14, '同': 15, '学': 16, '啊': 17
}

index_word = {
    0: '你', 1: '好', 2: '，', 3: '最', 4: '近', 5: '怎', 6: '么', 7: '样', 8: '？',
    9: '我', 10: '得', 11: '很', 12: '谢', 13: '！', 14: 'K', 15: '同', 16: '学', 17: '啊'
}

但词语被拆分开后，显然会失去原有的意思。在下面的案例中，我们使用jieba分词工具对句子进行划分。

4. 使用jieba进行分词

使用结巴分词（jieba）进行中文文本的分词处理，然后将分词后的结果转化为one-hot编码。首先，确保你已经安装了结巴分词库。

pip安装语句：pip install jieba

import torch
import torch.nn.functional as F
import jieba

# 示例中文文本
texts=['你好，最近怎么样？','我过得很好，谢谢！','再见。']

# 使用结巴分词进行分词
tokenized_texts=[list(jieba.cut(text)) for text in texts]

# 构建词汇表
word_index={}
index_word={}
for i,word in enumerate(set([word for text in tokenized_texts for word in text])):
    word_index[word]=i
    index_word[i]=word
    
# 将文本转化为整数序列
sequences=[[word_index[word] for word in text] for text in tokenized_texts]

# 获取词汇表大小
vocab_size=len(word_index)

# 将整数序列转化为one-hot编码
one_hot_results=torch.zeros(len(texts),vocab_size)
for i,seq in enumerate(sequences):
    one_hot_results[i,seq]=1
    
# 打印结果
print("词汇表：")
print(word_index)
print("\n文本：")
print(texts)
print("\n分词结果：")
print(tokenized_texts)
print("\n文本序列：")
print(sequences)
print("\nOne-Hot编码：")
print(one_hot_results)

运行结果：

词汇表：
{'你好': 0, '。': 1, '谢谢': 2, '最近': 3, '？': 4, '怎么样': 5, '我过': 6, '好': 7, '很': 8, '，': 9, '！': 10, '得': 11, '再见': 12}

文本：
['你好，最近怎么样？', '我过得很好，谢谢！', '再见。']

分词结果
[['你好', '，', '最近', '怎么样', '？'], ['我过', '得', '很', '好', '，', '谢谢', '！'], ['再见', '。']]

文本序列：
[[0, 9, 3, 5, 4], [6, 11, 8, 7, 9, 2, 10], [12, 1]]

One-Hot编码：
tensor([[1., 0., 0., 1., 1., 1., 0., 0., 0., 1., 0., 0., 0.],
        [0., 0., 1., 0., 0., 0., 1., 1., 1., 1., 1., 1., 0.],
        [0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1.]])

4.1 tokenized_texts=[list(jieba.cut(text)) for text in texts]

这段代码展示了如何使用 jieba 分词工具对中文文本进行分词处理。

（1）jieba.cut(text)

jieba.cut(text) 是 jieba 分词库的核心功能，它将输入的文本字符串 text 分割成单词列表。
返回值是一个生成器（generator），因此需要用 list() 将其转换为列表。

运行代码后：

tokenized_texts = [
    ['你好', '，', '最近', '怎么样', '？'],
    ['我', '过得', '很', '好', '，', '谢谢', '！'],
    ['再见', '。']
]

4.2 enumerate

这段代码展示了如何从分词后的文本中构建词汇表（word_index 和 index_word）。

（1）列表推导式

[word for text in tokenized_texts for word in text] 将所有分词结果展平为一个一维列表。

['你好', '最近', '怎么样', '我', '过得', '很', '好', '谢谢', '再见']

（2）set()

使用 set() 去重，确保每个单词只出现一次。

（3）enumerate()

为每个单词分配一个唯一的索引，并构建 word_index 和 index_word。

word_index = {
    '你好': 0,
    '最近': 1,
    '怎么样': 2,
    '我': 3,
    '过得': 4,
    '很': 5,
    '好': 6,
    '谢谢': 7,
    '再见': 8
}

index_word = {
    0: '你好',
    1: '最近',
    2: '怎么样',
    3: '我',
    4: '过得',
    5: '很',
    6: '好',
    7: '谢谢',
    8: '再见'
}

4.3 sequences语句

同2.2解释，假设：

tokenized_texts = [
    ['你好', '最近', '怎么样'],
    ['我', '过得', '很', '好', '谢谢'],
    ['再见']
]

运行代码后：

Sequences: [
    [0, 1, 2],  # 对应 '你好 最近 怎么样'
    [3, 4, 5, 6, 7],  # 对应 '我 过得 很 好 谢谢'
    [8]  # 对应 '再见'
]

5. 任务文件案例

import torch
import torch.nn.functional as F
import jieba

# 定义文件路径
filename=r'E:\DATABASE\N-series\N1\任务文件.txt'
# 打开文件并读取内容
with open(filename,"r",encoding="utf-8") as file:
    context=file.read()
    sentences=context.split()

# 使用结巴分词进行分词
tokenized_texts=[list(jieba.cut(sentence)) for sentence in sentences]

# 构建词汇表
word_index={}
index_word={}
for i,word in enumerate(set([word for text in tokenized_texts for word in text])):
    word_index[word]=i
    index_word[i]=word
    
# 将文本转化为整数序列
sequences=[[word_index[word] for word in text] for text in tokenized_texts]

# 获取词汇表大小
vocab_size=len(word_index)

# 将整数序列转化为one-hot编码
one_hot_results=torch.zeros(len(sentences),vocab_size)
for i,seq in enumerate(sequences):
    one_hot_results[i,seq]=1

# 打印结果
print("词汇表：")
print(word_index)
print("\n文本：")
print(sentences)
print("\n分词结果：")
print(tokenized_texts)
print("\n文本序列：")
print(sequences)
print("\nOne-Hot编码：")
print(one_hot_results)

运行结果：

词汇表：
{'内容': 0, '不': 1, '）': 2, '“': 3, '问题': 4, '分别': 5, '不同': 6, '映射': 7, '1': 8, '模型': 9, '而': 10, '一些': 11, '关系': 12, '编码': 13, '错误': 14, '直观': 15, '、': 16, '可能': 17, '其中': 18, '。': 19, '独立': 20, '但是': 21, '这是': 22, '也': 23, '和': 24, '顺序': 25, '相互': 26, '啊': 27, '为': 28, '或者': 29, '一个': 30, '了': 31, '称': 32, '就是': 33, '天': 34, '这种': 35, '基本': 36, '思想': 37, '训练营': 38, 'hot': 39, '例如': 40, '每个': 41, '距离': 42, '类别': 43, '提到': 44, '到': 45, '引入': 46, '其余': 47, '0': 48, '”': 49, '表示': 50, '这样': 51, '学习': 52, '使用': 53, '这些': 54, '三个': 55, '情况': 56, '，': 57, '深度': 58, '是': 59, '：': 60, 'K': 61, '同学': 62, '2': 63, '元素': 64, '可以': 65, 'one': 66, '将': 67, '这': 68, '采用': 69, '或': 70, '避免': 71, '实际上': 72, '有': 73, '会': 74, '地': 75, '向量': 76, '只有': 77, '编码方式': 78, '比较': 79, '实际意义': 80, '（': 81, '独热': 82, '365': 83, '教案': 84, '之间': 85, '值': 86, '具有': 87, '3': 88, '-': 89, '字典': 90, '认为': 91, '上面': 92, '用': 93, '的': 94, '序列': 95, '为了': 96, '存在': 97, '对于': 98, '如下': 99}

文本：
['比较直观的编码方式是采用上面提到的字典序列。', '例如，对于一个有三个类别的问题，可以用1、2和3分别表示这三个类别。', '但是，这种编码方式存在一个问题，就是模型可能会错误地认为不同类别之间存在一些顺序或距离关系', '而实际上这些关系可能是不存在的或者不具有实际意义的，为了避免这种问题，引入了one-hot编码（也称独热编码）。', 'one-hot编码的基本思想是将每个类别映射到一个向量，其中只有一个元素的值为1，其余元素的值为0。', '这样，每个类别之间就是相互独立的，不存在顺序或距离关系。', '例如，对于三个类别的情况，可以使用如下的one-hot编码：', '这是K同学啊的“365天深度学习训练营”教案内容']

分词结果：
[['比较', '直观', '的', '编码方式', '是', '采用', '上面', '提到', '的', '字典', '序列', '。'], ['例如', '，', '对于', '一个', '有', '三个', '类别', '的', '问题', '，', '可以', '用', '1', '、', '2', '和', '3', '分别', '表示', '这', '三个', '类别', '。'], ['但是', '，', '这种', '编码方式', '存在', '一个', '问题', '，', '就是', '模型', '可能', '会', '错误', '地', '认为', '不同', '类别', '之间', '存在', '一些', '顺序', '或', '距离', '关系'], ['而', '实际上', '这些', '关系', '可能', '是', '不', '存在', '的', '或者', '不', '具有', '实际意义', '的', '，', '为了', '避免', '这种', '问题', '，', '引入', '了', 'one', '-', 'hot', '编码', '（', '也', '称', '独热', '编码', '）', '。'], ['one', '-', 'hot', '编码', '的', '基本', '思想', '是', '将', '每个', '类别', '映射', '到', '一个', '向量', '，', '其中', '只有', '一个', '元素', '的', '值', '为', '1', '，', '其余', '元素', '的', '值', '为', '0', '。'], ['这样', '，', '每个', '类别', '之间', '就是', '相互', '独立', '的', '，', '不', '存在', '顺序', '或', '距离', '关系', '。'], ['例如', '，', '对于', '三个', '类别', '的', '情况', '，', '可以', '使用', '如下', '的', 'one', '-', 'hot', '编码', '：'], ['这是', 'K', '同学', '啊', '的', '“', '365', '天', '深度', '学习', '训练营', '”', '教案', '内容']]

文本序列：
[[79, 15, 94, 78, 59, 69, 92, 44, 94, 90, 95, 19], [40, 57, 98, 30, 73, 55, 43, 94, 4, 57, 65, 93, 8, 16, 63, 24, 88, 5, 50, 68, 55, 43, 19], [21, 57, 35, 78, 97, 30, 4, 57, 33, 9, 17, 74, 14, 75, 91, 6, 43, 85, 97, 11, 25, 70, 42, 12], [10, 72, 54, 12, 17, 59, 1, 97, 94, 29, 1, 87, 80, 94, 57, 96, 71, 35, 4, 57, 46, 31, 66, 89, 39, 13, 81, 23, 32, 82, 13, 2, 19], [66, 89, 39, 13, 94, 36, 37, 59, 67, 41, 43, 7, 45, 30, 76, 57, 18, 77, 30, 64, 94, 86, 28, 8, 57, 47, 64, 94, 86, 28, 48, 19], [51, 57, 41, 43, 85, 33, 26, 20, 94, 57, 1, 97, 25, 70, 42, 12, 19], [40, 57, 98, 55, 43, 94, 56, 57, 65, 53, 99, 94, 66, 89, 39, 13, 60], [22, 61, 62, 27, 94, 3, 83, 34, 58, 52, 38, 49, 84, 0]]

One-Hot编码：
tensor([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0.,
         0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
         0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
         0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0.,
         0., 0., 0., 0., 0., 0., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
         1., 0., 1., 0., 1., 1., 0., 0., 0., 0.],
        [0., 0., 0., 0., 1., 1., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 1., 0.,
         0., 1., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0.,
         0., 0., 0., 0., 1., 0., 0., 1., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0.,
         0., 1., 0., 1., 0., 0., 0., 0., 0., 1., 0., 1., 0., 0., 1., 0., 0., 0.,
         0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0.,
         0., 0., 0., 1., 1., 0., 0., 0., 1., 0.],
        [0., 0., 0., 0., 1., 0., 1., 0., 0., 1., 0., 1., 1., 0., 1., 0., 0., 1.,
         0., 0., 0., 1., 0., 0., 0., 1., 0., 0., 0., 0., 1., 0., 0., 1., 0., 1.,
         0., 0., 0., 0., 0., 0., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
         0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0.,
         0., 0., 1., 1., 0., 0., 1., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.,
         0., 1., 0., 0., 0., 0., 0., 1., 0., 0.],
        [0., 1., 1., 0., 1., 0., 0., 0., 0., 0., 1., 0., 1., 1., 0., 0., 0., 1.,
         0., 1., 0., 0., 0., 1., 0., 0., 0., 0., 0., 1., 0., 1., 1., 0., 0., 1.,
         0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0.,
         1., 0., 0., 1., 0., 1., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 1.,
         1., 0., 0., 0., 0., 0., 0., 0., 1., 1., 1., 0., 0., 0., 0., 1., 0., 1.,
         0., 0., 0., 0., 1., 0., 1., 1., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 1., 1., 0., 0., 0., 0., 1., 0., 0., 0., 0.,
         1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 1., 0., 0., 0., 0., 0.,
         1., 1., 0., 1., 0., 1., 0., 1., 0., 1., 0., 1., 1., 0., 0., 0., 0., 0.,
         0., 0., 0., 1., 0., 1., 0., 0., 0., 0., 1., 0., 1., 1., 0., 0., 0., 0.,
         0., 0., 0., 0., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 1.,
         0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],
        [0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0.,
         0., 1., 1., 0., 0., 0., 0., 1., 1., 0., 0., 0., 0., 0., 0., 1., 0., 0.,
         0., 0., 0., 0., 0., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0.,
         0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0.,
         0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.,
         0., 0., 0., 0., 1., 0., 0., 1., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.,
         0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
         0., 0., 0., 1., 1., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1.,
         0., 1., 1., 1., 0., 0., 1., 0., 0., 0., 0., 1., 1., 0., 0., 0., 0., 0.,
         0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1.,
         0., 0., 0., 0., 1., 0., 0., 0., 1., 1.],
        [1., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
         0., 0., 0., 0., 1., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 1., 0.,
         0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 1., 0.,
         0., 0., 0., 0., 1., 0., 0., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
         0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 1., 0., 0., 0., 0., 0.,
         0., 0., 0., 0., 1., 0., 0., 0., 0., 0.]])