设计考量

HDFS设计假设、目标

• 硬件失效
  • 硬件的异常比软件的异常更加常见
• 流式数据访问
  • Dataflow
  • hdfs是量身定制，并非以通用业务为目的
  • 关注吞吐量，并非响应时间

• 存储数据较大

• 简化的数据一致性模型

  • 数据写入之后，不允许再修改了，只允许在后面追加
• 多硬件平台支持
  • 易于运行不同的平台上（故用java编写）
• 移动计算能力比移动数据更划算
  • 计算和存储采用就近原则，计算离数据最近
  • 移动计算就是移动代码，对远程的数据进行计算

如何应对大文件

文件由数据块集合组成

• 通常每块大小为64MB
• 与os的块的区别：
  • os的目的：省io的时间、不满还是会占整个block的大小的
  • hdfs目的：把大的文件切小、不满是不会占64mb的

索引文件

• 跨机器索引

HDFS 架构

HDFS节点类型

• NameNode 每个集群一个名字节点（master）
  • 负责文件系统元数据操作、数据块的复制和定位
• SecondaryNamenode NameNode的备份
• Datanode

NameNode ：

• 作用：管理节点、接收用户的操作请求
• 核心数据文件包括：
  • 元数据镜像文件fsimage: 维护文件系统树以及文件树中所有的文件/目录的元数据
  • 操作日志文件EditLog: 记录所有针对文件的创建、删除、重命名等操作。
    • 如果元数据镜像文件可以承受恢复的代价，那么日志也可以不需要了，日志为了减轻元数据镜像文件的负担。
• 元数据保存在内存中
• 做了block和datanode之间的映射关系

SecondaryNameNode

• 执行过程：
  • 定期从Namenode上下载fsimage,edits，二者合并，生成新的fsimage
  • 在本地保存，并写回NameNode
• 它是“检查点”，而不是“热备份”（即并非实时备份）

DataNode

• 作用：一共文件的存储
• 文件块：一个Linux文件
• HDFS中，如果一个文件小于一个数据块的大小，并不占用整个数据块存储空间
• 数据备份：默认是三个
• 文件内容保存在磁盘

文件访问

文件写入HDFS

• NameNode 告知客户端文件的每一个数据块存储在何处
  b. 客户端将数据块直接传输到指定的数据节点数据访问

从HDFS读取文件

• 从NameNode 返回每个数据块的位置给客户端
• 从数据节点上传数据块（不同的数据块可以并行读取）

数据读取策略

文件访问模型

• “一次写入多次读取”
  • 修改内容需删除，重新写入
  • 仅允许追加append()
    • 注： 此为追加一个block，而不是在原来的block追加内容
• 好处：避免读写冲突，无需文件锁

HDFS数据备份

备份与一致性

• 一个文件有若干备份

• 备份之间是否可能不一致？

  • 同时append两个备份

容错机制

• HDFS在设计时就考虑到故障（硬件和软件）会经常出现

• DataNode故障：

  • “宕机”：节点上面的所有数据都会被标记为“不可读”
  • 定期检查备份因子

• NameNode故障

  • 根据SecondaryNameNode中的Fslmage和Editlog数据进行恢复

• 其他故障

  • 磁盘错误或故障：数据校验
  • 交换机/机架故障
  • 数据中心故障

HDFS功能

• 适用：

  • 大文件存储、流式数据访问

• 不合适:

  • 大量小文件（无法完美利用数据并行读取）
  • 随机读取（因为有固定的代价）
  • 低延迟读取

​

#

数据压缩的原理

压缩：

• 通过一些有别于原始编码的特殊编码方式来保存数据，使数据占用的存储空间比较小
• 压缩可以减少网络传输时间，但是压缩和解压缩需要时间

解压缩：

• 将被压缩的数据从特殊编码方式还原为原始数据的过程
• 解压需要时间
• 压缩算法的评价
  • 时间：压缩速度、解压速度
  • 空间： 压缩比 = 压缩后所占空间/压缩前所占空间
  • 故 压缩时间要短、空间占比要小

序列化与压缩

序列化的意义：

• 编写程序写文件A，另一个程序读取文件A
• 进程通信时传输的数据
  • 基本数据类型实例：int，long，double等数值
  • 用户自定义类的实例：对象
• 如何完成进程间的对象传送？
  • C c = new C(x,x,x)；是在另外一个进程，调用class c 吗
  • 然后class c是作为进程通信时传输的数据，进行序列化传到C c 所在的进程？

定义：

• 序列化：把对象状态按照一定的格式转换成有序字节流，以便在网络上传输或者保存在本地文件中
• 反序列化：从文件中或网络上获得序列化后的对象字节流后，根据字节流中所保存的对象状态及描述信息，重建对象

序列化：

• 数据需要序列化以后才能在服务端和客户端之间传输。
• 这个服务端和客户端的概念是广义的，可以在网络上，也可以在同一台机器的不同进程中，甚至在同一个进程中进行通信。
• 序列化协议：JSON、XML、Thrift、Protobuf…

进程与线程的区别

​ a. 线程是进程的一个实体，是CPU调度和分派的基本单 b. 进程在执行过程中拥有独立的内存单元，而多个线程共享内存
​ c. 线程不能够独立执行，必须依赖进程
​

进程间的通信方式

a. 进程之间需要交换数据
b. 进程各自有不同的用户地址空间
i. 同一台机器
ii. 不同机器
c. 通过操作系统内核
d. 方式：信号，信号量，消息队列（小的）、文件 、管道(pipe)、 有名管道（FIFO) 、 共享内存 、套接字

远程过程调用RPC

进程间通信方式 IPC

a. 控制 control flow ： 信号，信号量，消息队列（小的）
i. 信号：
1) 信号可以在任何时候由内核发给某一进程
ii. 消息队列：
1) 两个不相关进程间。独立于发送进程、接受进程而存在。
iii. 信号量：
1) 进程间对共享数据的互斥访问

b. 数据 data flow ：文件 、管道(pipe)、 有名管道（FIFO) 、 共享内存 、套接字
i. 管道：半双工（数据只能向一个方向流动）、只能用于父子进程或兄弟进程之间（必须在同一台机器上，两台机器上不存在）、实质是一个内核缓冲区，独立于文件系统
ii. 匿名管道：半双工、不相关的进程也可以，有名管道的名字存在于文件系统中，内容存放在内存中
iii. 共享内存：
1) 内核留出了一块内存区，可以由需要访问的进程将其映射到自己的私有地址空间
2) 需要同步机制来达到进程间的同步及互斥
iv. 套接字：
1) TCP/IP 的网络通信
2) 进程间使用套接字中的相关函数来通信
3) 本地单机或跨网络

​

• 注：需要端口的原因：区别服务种类，一台主机上可能存有很多数据

分布式系统

分布式系统应用

• 科学计算：CPU是瓶颈
• 数据密集：数据IO是计算过程的瓶颈
• 智能家居
• 事务处理
• 传感网络：扫车牌是否能进门？

纵向扩展： scalue-up （提高单台机器的处理能力）

• 异步通信： 成批传输数据
  • 将check form 从服务器端转移到客户端，可以减轻服务器端的压力，进而可以提高单台机器的处理能力。
  • 可能双方的时钟频率不一致

横向扩展：scale-out （增加机器的数量）

事务处理：

• 考虑到并发控制，假如没有事务处理，可以会读到脏数据、丢失数据修改等等

大数据处理

大数据概念：

• 大量化、快速化（双十一购物）、多样化、价值化

Web1.0 与 Web2.0的区别：

• 前者是只有文本、图像、视频(用户不能发帖，只能看）
• 后者用户可以发帖，数据量更大了。
• 大数据由结构化（10% 在数据库中）和非结构化数据（90%）组成

分布式数据处理系统

分布式数据管理 两大核心技术：

• 分布式事务管理：NoSQL/NewSQL
• 分布式数据处理：批处理/流计算

进程通信

序列化与压缩

• 序列化的三种途径：
  • 一种持久化格式：一个对象序列化以后他的编码可以存储在磁盘上
  • 通信数据格式
• 序列化的作用：
  • 把对象变成一串字节流，是持久化的一种方式（保存在磁盘上）
• 序列化机制：将数据转换为连续的byte数据，并且不用担心平台移植性。
• 两者都是为了节省空间
• 序列化可理解为将一个组合办公桌（对象）按标准拆解为散件，以方便运输（网络上传输），到达目的地后再重新组装成一个整体办公桌，所以序列化的目的不是压缩，而是变成 流以方便网络传输并能重新组装为对象, 后来大家又发现一张桌子有四条腿，不需要运输1111这种方式，改成1,4就可以了，这就是压缩了。

支持数据管理的底层系统

• 元数据管理系统：Zookeeper
• 资源管理系统：Yarn
• 分布式文件系统：HDFS

面向分析的分布式数据处理系统

• 批处理系统：MapReduce、Spark
• 流计算系统：Storm、Spark Streaming
• 批处理流计算一体化系统：Google Dataflow、Flink

支持领域应用的分布式数据处理系统

• 图数据处理系统：Hama、GraphX、Gelly
• 可扩展机器学习系统：Mahout、SystemML、Parameter Server、Tensorflow

分布式编程

经典问题：

• 单词计算

分布式并行编程：

• 传统并行编程：MPI:
  基于消息传递的并行程序。消息传递指的是并行运行的各个进程具有自己独立的堆栈和代码段，作为互不相关的多个程序独立运行，进程之间的信息交互全然通过显示地调用通信函数来完毕。
• MapReduce

分布式编程模型

• MapReduce （实现<key,value>的键值对）
• DAG模型
• Dataflow模型（流计算和批处理的一体化）
• 流计算模型
• 图计算模型（顶点-边）
• 迭代模型
• 广播变量模型（Kmeans中的参数）

第十三章 索引结构

13.1 顺序文件上的索引

• 稠密索引：一个索引对应一个元组
• 稀疏索引：一个索引对应一个数据块
• 多级索引：在索引上建立索引，高级索引量少可以放于内存，减少在磁盘中查找索引的I/O开销

总结

• 目的：想知道oracle Automatic Wordload Repository（AWR）中有哪些我们可以获取得以利用
• 关键字：snapshot(快照)、baselines（基线）、Adaptive Thresholds(自适应阀值)、Space Consumption(空间消耗)
• 启动： STATISTICS_LEVEL设为TYPICAL或ALL
• 总结：只是一个历史性能数据的库，不具备实时的功能

​

AWR包括的统计信息

• 对象统计
• 时间模型统计
• 系统和会话统计
• 获取会话历史统计

​

Snapshot

• 默认oracle每个小时自动产生一次快照，并保留8天负载统计信息
• 可通过自动数据库诊断器进行分析（ADDM）
  • 定期分析AWR数据
  • 诊断性能问题的起因
  • 为纠错提供推荐
  • 定义系统中没问题的部分
• AWR比较不同快照之间的差异来确定捕获影响系统负载的SQL语句【这个有意思】
• 可以修改Snapshot设置的单个参数，Retention（保留时间，min=1，max=100 年），Interval（收集的频率 min=10分钟,max=1年）、Topnsql（指定收集的比较占用资源的SQL数量 ,min=30,max=100000000）

​

Baselines

• 定义：专门用于比较的基准线，Baseline中包含指定时间点时的性能数据，过期也不会被清除
• 使用：
  • 检阅DBA_HIST_SNAPSHOT视图中已存在的快照
  • 用CREATE_BASELINE过程来创建期望快照范围基线
• 类型：
  • 固定基线
  • 移动窗口基线
  • 模板基线

Adaptive Thresholds

• 可以监控和检测性能问题，同时可以最大限度地减少管理开销。

Space Consumption

• AWR中空间消耗由是三个因素导致：
  • 系统中活动时间的会话数
  • 快照间隔
  • 历史数据的保留期

数据库系统实现 第一章

• DBMS信息类型包括：
  • 数据
  • 元数据
  • 日志记录：记录对数据库所做改变的信息（保证持久性）
  • 统计信息：DBMS收集和存储的关于数据库中的各个关系或其它成分的大小、取值等信息
  • 索引：对数据进行高效存取

1
2
3
4
5
6
7
8
9

import pandas as pd
import jieba
import numpy as np
from sklearn import feature_extraction
from sklearn.feature_extraction.text import TfidfTransformer
from sklearn.feature_extraction.text import CountVectorizer
from sklearn import svm
from sklearn.metrics import precision_recall_fscore_support
from sklearn.svm import SVC

1
2
3
4

def read_data(url):
    data = pd.read_csv(url,encoding='utf-8')
    data.fillna("null",inplace=True)      #使用inplace参数会改掉本身 
    return data

数据清洗

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

def clean_text(text):
    text = str(text)
    text = text.replace('\n', '')
    text = text.replace('<br />', ' ')
    text = text.replace(';', ',')
    return text
def tokenize_df_content(data):
    df_empty = pd.DataFrame()
    return df_empty.assign(content_tokens=data["content"].map(clean_text)).assign(title_tokens=data['title'].map(clean_text)).assign(label_tokens=data['ann_labels'].map(clean_text))
#将content&title&ann_labels的内容都进行过清洗，形成一个新的dataframe

def stop_words():
    stop_words_file = open('stopword.txt', 'r')
    stopwords_list = []
    for line in stop_words_file.readlines():
        stopwords_list.append(line)
    return stopwords_list

对content&title进行分词

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

def jieba_data(data,i):
    stopwords_list = stop_words()
    data_title=jieba.cut(data['title_tokens'][i])
    data_content=jieba.cut(data["content_tokens"][i])
    data_result = " "
    for title_word in data_title:
        if(title_word not in stopwords_list):
            data_result += title_word+" "
    for content_word in data_content:
        if(content_word not in stopwords_list):
         data_result += content_word+" "
    
    return data_result

def jieba_label(data_result,data,i):
    stopwords_list = stop_words()
    data_label = jieba.cut(data['label_tokens'][i])
    for label_word in data_label:
        if(label_word not in stopwords_list):
            data_result += label_word+" "
    
    return data_result

训练集的jieba分词

1
2
3
4

def train_jieba(data,i):
    data_result = jieba_data(data,i);
    result = jieba_label(data_result,data,i);
    return result;

测试集的jieba分词

1
2
3

def test_jieba(data,i):
    data = jieba_data(data,i);
    return data;

读取数据

1
2
3
4
5
6
7

if __name__ == '__main__':
    train_data_x = read_data('df_news_train_ecnu.csv')
    test_data_x = read_data('df_news_test_ecnu.csv')
    y_train = np.loadtxt("y_train_ecnu.csv", delimiter=",",encoding='utf-8')  #读入文件并以矩阵或向量的形式输出
    y_test = np.loadtxt("y_test_ecnu.csv", delimiter=",",encoding='utf-8')
    print(train_data_x.shape)
    print(test_data_x.shape)

输出：(2582, 5)
    (1107, 5)

获得标签值

1
2
3
4

unimportant_idx = 44
   train_label_y = y_train[:, unimportant_idx]
   test_label_y = y_test[:, unimportant_idx]
   print("# unimportant / total news in training data: ", int(sum(y_train[:, unimportant_idx])), "/", len(y_train[:, unimportant_idx]))

分词并保存分词结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

train_data_clean_x = tokenize_df_content(train_data_x)
   test_data_clean_x = tokenize_df_content(test_data_x)
   print(train_data_x.shape)
   print(test_data_x.shape)
   print(train_data_clean_x.shape)
   print(test_data_clean_x.shape)   #此时的标签是content_tokens title_tokens label_tokens
   
   train_x = []       #训练集的语料库
   test_x = []        #测试集的语料库
   for i in range(len(train_data_clean_x)):
           train_x.append(train_jieba(train_data_clean_x,i))
   for i in range(len(test_data_clean_x)):
           test_x.append(test_jieba(test_data_clean_x,i))

   train_x = np.array(train_x)
   test_x = np.array(test_x)
   np.savetxt("tmp/X_train.csv", train_x, delimiter=",",fmt = "%s",encoding="utf-8")
   np.savetxt("tmp/X_test.csv", test_x, delimiter=",",fmt = "%s",encoding="utf-8")

输出：
    (2582, 5)
    (1107, 5)
    (2582, 3)
    (1107, 3)

tfidf 之构造权重矩阵

1
2
3
4
5
6
7

    vectorizer = CountVectorizer()  #只考虑词汇在文本中出现的频率
    transformer = TfidfTransformer()  #tfidf值
    train_tfidf=transformer.fit_transform(vectorizer.fit_transform(train_x))#将tf-idf矩阵抽取出来，元素a[i][j]表示j词在i类文本中的tf-idf权重  
    print(train_tfidf.shape)
    test_tfidf = transformer.transform(vectorizer.transform(test_x))  #先拟合fit，找到该part的整体指标，对于test，transform保证train、test处理方式相同。
#     test_weight = test_tfidf.toarray()
#     print(test_weight.shape)

输出：(2582, 72998)

tfidf 之打印特征文本

1
2
3
4
5
6
7

weight = train_tfidf.toarray() 
word = vectorizer.get_feature_names()  #获取词袋模型中的所有词语 
for i in range(5):#打印每类文本的tf-idf词语权重，第一个for遍历所有文本，第二个for便利某一类文本下的词语权重  
    print("************************第",i,"篇文章的词语tf-idf权重**********************"  )
    for j in range(len(word)):
        if(weight[i][j] >0.1):   
            print(word[j],weight[i][j])

输出：
    ************************第 0 篇文章的词语tf-idf权重**********************
    一致性 0.30716252706000763    
    仿制 0.21851023802630334
    医疗机构 0.27535485762167283
    原研 0.2036921591200047
    ......

二分类【非重要新闻】¶

1
2
3
4
5
6
7

svmmodel = SVC(C = 1 , kernel= "linear") #kernel：rbf, poly在这里都没有线性的好

nn = svmmodel.fit(train_tfidf,train_label_y)
print(nn)
pre_test_label = svmmodel.predict(test_tfidf)
test_data_x["category"] = pre_test_label
np.savetxt("tmp/test_data_label.csv", test_data_x, delimiter=",",fmt = "%s",encoding="utf-8")

评判指标

1
2

from sklearn.metrics import classification_report
print(classification_report(test_label_y, pre_test_label))

输出：
             precision    recall  f1-score   support

    0.0       0.76      0.92      0.83       783
    1.0       0.59      0.29      0.39       324

    avg / total       0.71      0.73      0.70      1107

#

好系统的标准

• 功能通用、完善
  • 满足尽量多应用的需求
• 实现细节对应用透明
  • 应用开发独立于系统实现

数据模型定义

• 数据的逻辑组织方式（数据的基本结构和结构的语义）

  • 文档模型（Mongodb 2000s)
  • 层次模型（IBM IMS 1960s)
  • 网状模型（GE IDS 1960s）
  • 关系模型（SQL DB 1970s~80s)

• 注：数据模型—决定—> 数据的访问方式 / DBMS的访问接口——> 系统的功能性、性能、易用性

数据库模式（Schema)

• 对数据库中数据的结构性描述

  • 参照schema才能正确书写查询

• 一种数据库元数据（Metadata），描述数据长什么样子（相当于一个模板）

  1 2 3 4 5 6

  Schema { Name:string, Manufacturer:string Catalog_numver:num }

• Data Model相当于Schema的Metadata，即Meta Metadata
  注：Mongodb没有一个特定的schema的过程，只是程序猿在存数据的时候脑子里有这个schema

数据模型：JSON/BSON

如何衡量数据模型的能力？

表达能力：

• 数据本身能够表达什么信息？
  • 计算机能够理解的信息
• 查询能够满足哪些信息需求？

  注： 表达能力越强，查询时返回的值越快越准确
  

表达能力的两个维度

• 范围：能够满足哪些信息需求
  • 上限为Turing Completeness（程序设计语言能做到的范围）（数据库的查询做不到Turing Completeness）
• 精简程度：用户描述需求是是否方便
  • Prolog比Java表达更强更精炼，因为Prolog逻辑性强
    注：数据库系统将查询的语言转换成数据库查找的语言

数据模型的论战：

• Charles Bachman 网状模型 Navigational Database Network Model

  Edgar F.Codd       关系模型    Relational Database Relation Model
  

• 70年代末更倾向于关系数据库

• 网状数据库(Navigational DB)
  a. 查询通过指针访问

• Codd坚持的看法

  • DBMS应该和应用程序尽可能保持相互独立（模块化）
    • 数据的存放顺序与程序无关
    • 数据的使用与程序无关
    • 数据的访问方式与程序无关（网状和层次模型违背了这点）

如何避免依赖性

• 提升数据模型的表达能力
• 声明是程序设计语言(而不是过程式语言）
  • Prolog 、 SQL 、 First Order Logic（一阶逻辑语言）
  • 只把需求说出来，不说具体怎么做。
  • 注：关系型数据库就着重声明式语言,Mongodb是声明式语言，但是拿到数据之后，还是得通过java等过程式语言进行处理

问答：

• 声明式程序一定比过程式的更好吗？
  • 并不是
• 表达能力越高越好吗？
  • 不是，度的把握，如单反照相机和傻瓜相机

​
​