人工智能在德州扑克比赛中击败人类玩家_凤凰财经
人工智能在德州扑克比赛中击败人类玩家
用微信扫描二维码分享至好友和朋友圈
中国证券网讯 据新浪科技12日报道，加拿大与捷克研究人员开发了扑克机器人，它已经在一对一比赛和无限下注德州扑克比赛中打败了人类职业玩家，扑克机器人的胜利标志着AI取得了新的突破。
中国证券网讯 据新浪科技12日报道，加拿大与捷克研究人员开发了扑克机器人，它已经在一对一比赛和无限下注德州扑克比赛中打败了人类职业玩家，扑克机器人的胜利标志着AI取得了新的突破。研究人员称，程序用“逼近法”打败了人类对手，“逼近法”与直觉有点相似。密歇根大学游戏理论与AI教授迈克尔·韦尔曼（Michael Wellman）认为：“如果真是这样，意味着游戏AI取得了明显进步。首先，它是一个里程碑，AI在游戏中打败了扑克职业玩家。其次，它将一些新创意结合在一起，开创了激动人心的新方法，我们可以用这种方法应付信息不完全的游戏。”本周晚些时候，匹兹堡赌场将会举办扑克锦标赛，到时几名世界级扑克玩家将会与卡内基梅隆大学开发的程序对决。卡内基梅隆大学计算机教授图奥马斯·桑德赫尔（Tuomas Sandholm）是程序的主要开发者，他说参赛的选手比之前测试时的选手强很多，在20多天的比赛中，玩家将会打出12万手扑克，研究人员可以统计数据，为开发工作提供帮助。一直以来，人们认为扑克对于电脑来说过于复杂，锦标赛也许可以向我们证明AI已经可以在扑克上超越人类了。扑克软件DeepStack曾经打败过职业玩家，它是加拿大阿尔伯塔大学计算机教授迈克尔·保林（Michael Bowling）领导开发的，查尔斯特大学和捷克理工大学的研究人员也参与了研发。网上刊发了一份研究报告，研究人员在报告中表示，DeepStack与几名人类玩家比赛，打了4.5万手扑克，轻松获胜。人类也曾与AI在其它游戏中对决，相比而言扑克更加复杂。扑克不确定因素很多，比如对手可能会欺骗，在现实世界中到处都是欺骗，AI还不懂得怎样欺骗。扑克玩家看不到对手的牌，但在西洋棋、国际象棋和围棋中，大家可以看清对方的棋子。今年年初时，Alphabet子公司DeepMind开发的AI程序打败了李世石，他是韩国知名职业围棋高手。对于机器来说，不限注德州扑克太难了，每一手牌都有10的160次方种（10的后面跟160个0）可能。DeepStack通过自己与自己打扑克不断学习。每打完一局，系统就会修改优化策略，让技能更上层楼。由于不限注扑克很复杂，系统通过玩限注扑克来提高技巧。为了处理复杂性问题，研究人员使用了快速逼近技术，他们将之前的扑克比赛资料输入深度学习算法，不断优化精炼。密歇根大学韦尔曼认为，扑克是一种复杂的游戏，采用新技术之后，系统碰到各种情况都可以有效应对，这是新的突破；以前要绘制整个树，将各种可能性找出来。研究人员将DeepStack的逼近技术与人类玩家的直觉类比，当对手欺骗或者拿到一手可以获胜的牌时，人类会用直觉判断，比如根据对手的语言来判断，机器不同，它根据对手的下注模式来判断。研究人员称：“我们可以将这种估计看成是DeepStack的直觉。”通过观察扑克玩家在多次对决中赢得的金额，系统可以评估玩家的表现，而不是根据桌面上的下注额判断。与优秀的职业选手相比，DeepStack的胜率高了大约9倍。2015年，保林与阿尔伯塔大学的同事找到了解决方案，他们开发的扑克机器可以玩限注德州扑克，表现很完美。参加匹兹堡锦标赛的机器人名叫“Libratus”，它是图奥马斯·桑德赫尔（Tuomas Sandholm）与学生诺姆·布朗（Noam Brown）合作开发的，Libratus用匹兹堡超级计算中心的强大硬件运行。
复盘大师【fupan588】：关注这个号的人都在股市赚钱了，资深分析师为你揭秘后市操作策略，次日热点早知道，让你提前布局，尽情在股市赚大钱。ps：定期抽大奖!股市早报，投资前瞻，涨停预测，牛股捕捉，尽在微信号【凤凰证券】或者【ifengstock】
用微信扫描二维码分享至好友和朋友圈
免责声明：本文仅代表作者个人观点，与凤凰网无关。其原创性以及文中陈述文字和内容未经本站证实，对本文以及其中全部或者部分内容、文字的真实性、完整性、及时性本站不作任何保证或承诺，请读者仅作参考，并请自行核实相关内容。
预期年化利率
凤凰点评：凤凰集团旗下公司，轻松理财。
凤凰点评：业绩长期领先，投资尖端行业。
凤凰点评：进可攻退可守，抗跌性能尤佳。
同系近一年收益
凤凰点评：震荡市场首选，防御性能极佳且收益喜人，老总私人追加百万。
凤凰证券官方微信
播放数：2397175
播放数：593865
播放数：1839468
播放数：5808920[广告]投资优惠入口:
对文章打分
德州扑克人机大战：人工智能上半程领先
(window.slotbydup=window.slotbydup || []).push({
id: '945055',
container: s,
size: '300,250',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '649316',
container: s,
size: '300,250',
display: 'inlay-fix'
阅读 (36254) 评论 (91)
阅读 (23272) 评论 (60)
阅读 (22776) 评论 (59)
阅读 (42498) 评论 (44)
阅读 (36582) 评论 (91)
阅读 (35925) 评论 (91)
Advertisment ad adsense googles&img src=&/v2-5c985f3a68b68e6e151ef030a797a50f_b.jpg& data-rawwidth=&600& data-rawheight=&301& class=&origin_image zh-lightbox-thumb& width=&600& data-original=&/v2-5c985f3a68b68e6e151ef030a797a50f_r.jpg&&&blockquote&&h2&引言&/h2&&p&TensorFlow是Google基于DistBelief进行研发的第二代人工智能学习系统，被广泛用于语音识别或图像识别等多项机器深度学习领域。其命名来源于本身的运行原理。Tensor（张量）意味着N维数组，Flow（流）意味着基于数据流图的计算，TensorFlow代表着张量从图象的一端流动到另一端计算过程，是将复杂的数据结构传输至人工智能神经网中进行分析和处理的过程。&/p&&p&TensorFlow完全开源，任何人都可以使用。可在小到一部智能手机、大到数千台数据中心服务器的各种设备上运行。&br&&/p&&p&『机器学习进阶笔记』系列将深入解析TensorFlow系统的技术实践，从零开始，由浅入深，与大家一起走上机器学习的进阶之路。&/p&&/blockquote&&br&&h2&Goal&/h2&&p&本文目标是利用TensorFlow做一个简单的图像分类器，在比较大的数据集上，尽可能高效地做图像相关处理，从Train，Validation到Inference，是一个比较基本的Example， 从一个基本的任务学习如果在TensorFlow下做高效地图像读取，基本的图像处理，整个项目很简单，但其中有一些trick，在实际项目当中有很大的好处， 比如绝对不要一次读入所有的 的数据到内存（尽管在Mnist这类级别的例子上经常出现)…&/p&&p&最开始看到是这篇blog里面的&a href=&/?target=http%3A///archives/10897& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&TensorFlow练习22: 手写汉字识别&i class=&icon-external&&&/i&&/a&, 但是这篇文章只用了140训练与测试，试了下代码 很快，但是当扩展到所有的时，发现32g的内存都不够用，这才注意到原文中都是用numpy，会先把所有的数据放入到内存，但这个不必须的，无论在MXNet还是TensorFlow中都是不必 须的，MXNet使用的是DataIter，会在程序运行的过程中异步读取数据，TensorFlow也是这样的，TensorFlow封装了高级的api，用来做数据的读取，比如TFRecord，还有就是从filenames中读取， 来异步读取文件，然后做shuffle batch，再feed到模型的Graph中来做模型参数的更新。具体在tf如何做数据的读取可以看看&a href=&/?target=https%3A//www.tensorflow.org/how_tos/reading_data/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&reading data in tensorflow&i class=&icon-external&&&/i&&/a&&/p&&img src=&/v2-1a66eaa351ca_b.jpg& data-rawwidth=&2500& data-rawheight=&1256& class=&origin_image zh-lightbox-thumb& width=&2500& data-original=&/v2-1a66eaa351ca_r.jpg&&&br&&p&这里我会拿到所有的数据集来做训练与测试，算作是对斗大的熊猫上面那篇文章的一个扩展。&/p&&h2&Batch Generate&/h2&&p&数据集来自于&a href=&/?target=http%3A//www.nlpr./CN/folder/folder8.shtml& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&中科院自动化研究所&i class=&icon-external&&&/i&&/a&，感谢分享精神！！！具体下载:&/p&&br&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&wget http://www.nlpr./databases/download/feature_data/HWDB1.1trn_gnt.zip
wget http://www.nlpr./databases/download/feature_data/HWDB1.1tst_gnt.zip
&/code&&/pre&&/div&&p&解压后发现是一些gnt文件，然后用了斗大的熊猫里面的代码，将所有文件都转化为对应label目录下的所有png的图片。（注意在HWDB1.1trn_gnt.zip解压后是alz文件，需要再次解压 我在mac没有找到合适的工具，windows上有alz的解压工具)。&/p&&br&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&import os
import numpy as np
import struct
from PIL import Image
data_dir = '../data'
train_data_dir = os.path.join(data_dir, 'HWDB1.1trn_gnt')
test_data_dir = os.path.join(data_dir, 'HWDB1.1tst_gnt')
def read_from_gnt_dir(gnt_dir=train_data_dir):
def one_file(f):
header_size = 10
while True:
header = np.fromfile(f, dtype='uint8', count=header_size)
if not header.size: break
sample_size = header[0] + (header[1]&&8) + (header[2]&&16) + (header[3]&&24)
tagcode = header[5] + (header[4]&&8)
width = header[6] + (header[7]&&8)
height = header[8] + (header[9]&&8)
if header_size + width*height != sample_size:
image = np.fromfile(f, dtype='uint8', count=width*height).reshape((height, width))
yield image, tagcode
for file_name in os.listdir(gnt_dir):
if file_name.endswith('.gnt'):
file_path = os.path.join(gnt_dir, file_name)
with open(file_path, 'rb') as f:
for image, tagcode in one_file(f):
yield image, tagcode
char_set = set()
for _, tagcode in read_from_gnt_dir(gnt_dir=train_data_dir):
tagcode_unicode = struct.pack('&H', tagcode).decode('gb2312')
char_set.add(tagcode_unicode)
char_list = list(char_set)
char_dict = dict(zip(sorted(char_list), range(len(char_list))))
print len(char_dict)
import pickle
f = open('char_dict', 'wb')
pickle.dump(char_dict, f)
train_counter = 0
test_counter = 0
for image, tagcode in read_from_gnt_dir(gnt_dir=train_data_dir):
tagcode_unicode = struct.pack('&H', tagcode).decode('gb2312')
im = Image.fromarray(image)
dir_name = '../data/train/' + '%0.5d'%char_dict[tagcode_unicode]
if not os.path.exists(dir_name):
os.mkdir(dir_name)
im.convert('RGB').save(dir_name+'/' + str(train_counter) + '.png')
train_counter += 1
for image, tagcode in read_from_gnt_dir(gnt_dir=test_data_dir):
tagcode_unicode = struct.pack('&H', tagcode).decode('gb2312')
im = Image.fromarray(image)
dir_name = '../data/test/' + '%0.5d'%char_dict[tagcode_unicode]
if not os.path.exists(dir_name):
os.mkdir(dir_name)
im.convert('RGB').save(dir_name+'/' + str(test_counter) + '.png')
test_counter += 1
&/code&&/pre&&/div&&p&处理好的数据，放到了云盘，大家可以直接在我的云盘来下载处理好的数据集&a href=&/?target=https%3A///s/1o84jIrg& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&HWDB1&i class=&icon-external&&&/i&&/a&. 这里说明下，char_dict是汉字和对应的数字label的记录。&/p&&p&得到数据集后，就要考虑如何读取了，一次用numpy读入内存在很多小数据集上是可以行的，但是在稍微大点的数据集上内存就成了瓶颈，但是不要害怕，TensorFlow有自己的方法：&/p&&br&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&def batch_data(file_labels,sess, batch_size=128):
image_list = [file_label[0] for file_label in file_labels]
label_list = [int(file_label[1]) for file_label in file_labels]
print 'tag2 {0}'.format(len(image_list))
images_tensor = tf.convert_to_tensor(image_list, dtype=tf.string)
labels_tensor = tf.convert_to_tensor(label_list, dtype=tf.int64)
input_queue = tf.train.slice_input_producer([images_tensor, labels_tensor])
labels = input_queue[1]
images_content = tf.read_file(input_queue[0])
# images = tf.image.decode_png(images_content, channels=1)
images = tf.image.convert_image_dtype(tf.image.decode_png(images_content, channels=1), tf.float32)
# images = images / 256
pre_process(images)
# print images.get_shape()
labels = tf.one_hot(labels, 3755)
image_batch, label_batch = tf.train.shuffle_batch([images, labels], batch_size=batch_size, capacity=50000,min_after_dequeue=10000)
# print 'image_batch', image_batch.get_shape()
coord = tf.train.Coordinator()
threads = tf.train.start_queue_runners(sess=sess, coord=coord)
return image_batch, label_batch, coord, threads
&/code&&/pre&&/div&&p&简单介绍下，首先你需要得到所有的图像的path和对应的label的列表，利用tf.convert_to_tensor转换为对应的tensor， 利用tf.train.slice_input_producer将image_list ,label_list做一个slice处理，然后做图像的读取、预处理，以及label的one_hot表示，然后就是传到tf.train.shuffle_batch产生一个个shuffle batch，这些就可以feed到你的 模型。 slice_input_producer和shuffle_batch这类操作内部都是基于queue，是一种异步的处理方式,会在设备中开辟一段空间用作cache，不同的进程会分别一直往cache中塞数据 和取数据，保证内存或显存的占用以及每一个mini-batch不需要等待，直接可以从cache中获取。&/p&&img src=&/v2-2c079a9c26ba6733213a_b.jpg& data-rawwidth=&740& data-rawheight=&504& class=&origin_image zh-lightbox-thumb& width=&740& data-original=&/v2-2c079a9c26ba6733213a_r.jpg&&&br&&h2&Data Augmentation&/h2&&p&由于图像场景不复杂，只是做了一些基本的处理，包括图像翻转，改变下亮度等等，这些在TensorFlow里面有现成的api，所以尽量使用TensorFlow来做相关的处理：&/p&&br&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&def pre_process(images):
if FLAGS.random_flip_up_down:
images = tf.image.random_flip_up_down(images)
if FLAGS.random_flip_left_right:
images = tf.image.random_flip_left_right(images)
if FLAGS.random_brightness:
images = tf.image.random_brightness(images, max_delta=0.3)
if FLAGS.random_contrast:
images = tf.image.random_contrast(images, 0.8, 1.2)
new_size = tf.constant([FLAGS.image_size,FLAGS.image_size], dtype=tf.int32)
images = tf.image.resize_images(images, new_size)
return images
&/code&&/pre&&/div&&h2&Build Graph&/h2&&p&这里很简单的构造了一个两个卷积+一个全连接层的网络，没有做什么更深的设计，感觉意义不大，设计了一个dict，用来返回后面要用的所有op，还有就是为了方便再训练中查看loss和accuracy， 没有什么特别的，很容易理解, labels 为None时 方便做inference。&/p&&br&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&def network(images, labels=None):
endpoints = {}
conv_1 = slim.conv2d(images, 32, [3,3],1, padding='SAME')
max_pool_1 = slim.max_pool2d(conv_1, [2,2],[2,2], padding='SAME')
conv_2 = slim.conv2d(max_pool_1, 64, [3,3],padding='SAME')
max_pool_2 = slim.max_pool2d(conv_2, [2,2],[2,2], padding='SAME')
flatten = slim.flatten(max_pool_2)
out = slim.fully_connected(flatten,3755, activation_fn=None)
global_step = tf.Variable(initial_value=0)
if labels is not None:
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(out, labels))
train_op = tf.train.AdamOptimizer(learning_rate=0.0001).minimize(loss, global_step=global_step)
accuracy = tf.reduce_mean(tf.cast(tf.equal(tf.argmax(out, 1), tf.argmax(labels, 1)), tf.float32))
tf.summary.scalar('loss', loss)
tf.summary.scalar('accuracy', accuracy)
merged_summary_op = tf.summary.merge_all()
output_score = tf.nn.softmax(out)
predict_val_top3, predict_index_top3 = tf.nn.top_k(output_score, k=3)
endpoints['global_step'] = global_step
if labels is not None:
endpoints['labels'] = labels
endpoints['train_op'] = train_op
endpoints['loss'] = loss
endpoints['accuracy'] = accuracy
endpoints['merged_summary_op'] = merged_summary_op
endpoints['output_score'] = output_score
endpoints['predict_val_top3'] = predict_val_top3
endpoints['predict_index_top3'] = predict_index_top3
return endpoints
&/code&&/pre&&/div&&h2&Train&/h2&&p&train函数包括从已有checkpoint中restore，得到step，快速恢复训练过程，训练主要是每一次得到mini-batch，更新参数，每隔eval_steps后做一次train batch的eval，每隔save_steps 后保存一次checkpoint。&/p&&br&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&def train():
sess = tf.Session()
file_labels = get_imagesfile(FLAGS.train_data_dir)
images, labels, coord, threads = batch_data(file_labels, sess)
endpoints = network(images, labels)
saver = tf.train.Saver()
sess.run(tf.global_variables_initializer())
train_writer = tf.train.SummaryWriter('./log' + '/train',sess.graph)
test_writer = tf.train.SummaryWriter('./log' + '/val')
start_step = 0
if FLAGS.restore:
ckpt = tf.train.latest_checkpoint(FLAGS.checkpoint_dir)
saver.restore(sess, ckpt)
print &restore from the checkpoint {0}&.format(ckpt)
start_step += int(ckpt.split('-')[-1])
(':::Training Start:::')
while not coord.should_stop():
# ('step {0} start'.format(i))
start_time = time.time()
_, loss_val, train_summary, step = sess.run([endpoints['train_op'], endpoints['loss'], endpoints['merged_summary_op'], endpoints['global_step']])
train_writer.add_summary(train_summary, step)
end_time = time.time()
(&the step {0} takes {1} loss {2}&.format(step, end_time-start_time, loss_val))
if step & FLAGS.max_steps:
# (&the step {0} takes {1} loss {2}&.format(i, end_time-start_time, loss_val))
if step % FLAGS.eval_steps == 1:
accuracy_val,test_summary, step = sess.run([endpoints['accuracy'], endpoints['merged_summary_op'], endpoints['global_step']])
test_writer.add_summary(test_summary, step)
('===============Eval a batch in Train data=======================')
( 'the step {0} accuracy {1}'.format(step, accuracy_val))
('===============Eval a batch in Train data=======================')
if step % FLAGS.save_steps == 1:
('Save the ckpt of {0}'.format(step))
saver.save(sess, os.path.join(FLAGS.checkpoint_dir, 'my-model'), global_step=endpoints['global_step'])
except tf.errors.OutOfRangeError:
# print &============train finished=========&
('==================Train Finished================')
saver.save(sess, os.path.join(FLAGS.checkpoint_dir, 'my-model'), global_step=endpoints['global_step'])
coord.request_stop()
coord.join(threads)
sess.close()
&/code&&/pre&&/div&&p&Graph&/p&&img src=&/v2-0e134fec6a341cb06b80a556e1e01434_b.png& data-rawwidth=&2106& data-rawheight=&2704& class=&origin_image zh-lightbox-thumb& width=&2106& data-original=&/v2-0e134fec6a341cb06b80a556e1e01434_r.png&&&br&&p&Loss and Accuracy&br&&/p&&img src=&/v2-5d3a1a99a47ebda7efa8ed98be90ac2e_b.jpg& data-rawwidth=&558& data-rawheight=&604& class=&origin_image zh-lightbox-thumb& width=&558& data-original=&/v2-5d3a1a99a47ebda7efa8ed98be90ac2e_r.jpg&&&br&&h2&Validation&/h2&&p&训练完成之后，想对最终的模型在测试数据集上做一个评估，这里我也曾经尝试利用batch_data，将slice_input_producer中epoch设置为1，来做相关的工作，但是发现这里无法和train 共用，会出现epoch无初始化值的问题（train中传epoch为None），所以这里自己写了shuffle batch的逻辑，将测试集的images和labels通过feed_dict传进到网络，得到模型的输出， 然后做相关指标的计算：&/p&&br&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&def validation():
# it should be fixed by using placeholder with epoch num in train stage
sess = tf.Session()
file_labels = get_imagesfile(FLAGS.test_data_dir)
test_size = len(file_labels)
print test_size
val_batch_size = FLAGS.val_batch_size
test_steps = test_size / val_batch_size
print test_steps
# images, labels, coord, threads= batch_data(file_labels, sess)
images = tf.placeholder(dtype=tf.float32, shape=[None, 64, 64, 1])
labels = tf.placeholder(dtype=tf.int32, shape=[None,3755])
# read batch images from file_labels
# images_batch = np.zeros([128,64,64,1])
# labels_batch = np.zeros([128,3755])
# labels_batch[0][20] = 1
endpoints = network(images, labels)
saver = tf.train.Saver()
ckpt = tf.train.latest_checkpoint(FLAGS.checkpoint_dir)
saver.restore(sess, ckpt)
# (&restore from the checkpoint {0}&.format(ckpt))
# ('Start validation')
final_predict_val = []
final_predict_index = []
groundtruth = []
for i in range(test_steps):
start = i* val_batch_size
end = (i+1)*val_batch_size
images_batch = []
labels_batch = []
labels_max_batch = []
('=======start validation on {0}/{1} batch========='.format(i, test_steps))
for j in range(start,end):
image_path = file_labels[j][0]
temp_image = Image.open(image_path).convert('L')
temp_image = temp_image.resize((FLAGS.image_size, FLAGS.image_size),Image.ANTIALIAS)
temp_label = np.zeros([3755])
label = int(file_labels[j][1])
# print label
temp_label[label] = 1
# print &====&,np.asarray(temp_image).shape
labels_batch.append(temp_label)
# print &====&,np.asarray(temp_image).shape
images_batch.append(np.asarray(temp_image)/255.0)
labels_max_batch.append(label)
# print images_batch
images_batch = np.array(images_batch).reshape([-1, 64, 64, 1])
labels_batch = np.array(labels_batch)
batch_predict_val, batch_predict_index = sess.run([endpoints['predict_val_top3'],
endpoints['predict_index_top3']], feed_dict={images:images_batch, labels:labels_batch})
('=======validation on {0}/{1} batch end========='.format(i, test_steps))
final_predict_val += batch_predict_val.tolist()
final_predict_index += batch_predict_index.tolist()
groundtruth += labels_max_batch
sess.close()
return final_predict_val, final_predict_index, groundtruth
&/code&&/pre&&/div&&p&在训练20w个step之后，大概能达到在测试集上能够达到：&/p&&img src=&/v2-b53f1a60f7ef821c445b0_b.jpg& data-rawwidth=&694& data-rawheight=&115& class=&origin_image zh-lightbox-thumb& width=&694& data-original=&/v2-b53f1a60f7ef821c445b0_r.jpg&&&br&&p&相信如果在网络设计上多花点时间能够在一定程度上提升accuracy和top 3 accuracy.有兴趣的小伙伴们可以玩玩这个数据集。&/p&&h2&Inference&/h2&&br&&div class=&highlight&&&pre&&code class=&language-text&&&span&&/span&def inference(image):
temp_image = Image.open(image).convert('L')
temp_image = temp_image.resize((FLAGS.image_size, FLAGS.image_size),Image.ANTIALIAS)
sess = tf.Session()
('========start inference============')
images = tf.placeholder(dtype=tf.float32, shape=[None, 64, 64, 1])
endpoints = network(images)
saver = tf.train.Saver()
ckpt = tf.train.latest_checkpoint(FLAGS.checkpoint_dir)
saver.restore(sess, ckpt)
predict_val, predict_index = sess.run([endpoints['predict_val_top3'],endpoints['predict_index_top3']], feed_dict={images:temp_image})
sess.close()
return final_predict_val, final_predict_index
&/code&&/pre&&/div&&p&运气挺好，随便找了张图片就能准确识别出来&/p&&img src=&/v2-fae8f16dfee3d3a8c229eb_b.jpg& data-rawwidth=&1352& data-rawheight=&346& class=&origin_image zh-lightbox-thumb& width=&1352& data-original=&/v2-fae8f16dfee3d3a8c229eb_r.jpg&&&br&&h2&Summary&/h2&&p&综上，就是利用tensorflow做中文手写识别的全部，从如何使用tensorflow内部的queue来有效读入数据，到如何设计network， 到如何做train，validation，inference，珍格格流程比较清晰， 美中不足的是，原本打算是在训练过程中，来对测试集做评估，但是在使用queue读test_data_dir下的filenames，和train本身的好像有点问题，不过应该是可以解决的，我这里就pass了。另外可能 还有一些可以改善的地方，比如感觉可以把batch data one hot的部分写入到network，这样，减缓在validation时内存会因为onehot的sparse开销比较大。&/p&&p&感觉这个中文手写汉字数据集价值很大，后面感觉会有好多可以玩的，比如&/p&&ul&&li&可以参考项亮大神的这篇文章&a href=&/p/& class=&internal&&端到端的OCR：验证码识别&/a&做定长的字符识别和不定长的字符识别，定长的基本原理是说，可以把最终输出扩展为k个输出， 每个值表示对应的字符label，这样cnn模型在feature extract之后就可以自己去识别对应字符而无需人工切割；而LSTM+CTC来解决不定长的验证码，类似于将音频解码为汉字&/li&&li&最近GAN特别火，感觉可以考虑用这个数据来做某个字的生成，和text2img那个项目&a href=&/?target=https%3A///paarthneekhara/text-to-image& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&text-to-image&i class=&icon-external&&&/i&&/a&&/li&&/ul&&p&这部分的代码都在我的github上&a href=&/?target=https%3A///burness/tensorflow-101& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&tensorflow-101&i class=&icon-external&&&/i&&/a&，有遇到相关功能,想参考代码的可以去上面找找，没准就能解决你们遇到的一些小问题.&/p&&br&&br&&p&——————&br&&/p&&h2&相关阅读推荐：&/h2&&p&&a href=&/p/& class=&internal&&机器学习进阶笔记之七 | MXnet初体验&/a&&br&&/p&&p&&a href=&/p/& class=&internal&&机器学习进阶笔记之六 | 深入理解Fast Neural Style&/a&&br&&/p&&p&&a href=&/p/& class=&internal&&机器学习进阶笔记之五 | 深入理解VGG\Residual Network&/a&&br&&/p&&p&&a href=&/p/& class=&internal&&机器学习进阶笔记之四 | 深入理解GoogLeNet&/a&&br&&/p&&p&&a href=&/p/& class=&internal&&机器学习进阶笔记之三 | 深入理解Alexnet &/a&&br&&/p&&p&&a href=&/p/& class=&internal&&机器学习进阶笔记之二 | 深入理解Neural Style&/a&&br&&/p&&p&&a href=&/p/& class=&internal&&机器学习进阶笔记之一 | TensorFlow安装与入门 &/a&&br&&/p&&br&&p&&br&&/p&&br&本文由『&b&UCloud内核与虚拟化研发团队&/b&』提供。&br&&br&&blockquote&&p&&b&关于作者：&/b&&/p&&p&Burness（&a href=&/people/822e01cbeee9& data-hash=&822e01cbeee9& class=&member_mention& data-hovercard=&p$b$822e01cbeee9& data-editable=&true& data-title=&@段石石&&@段石石&/a& ）， UCloud平台研发中心深度学习研发工程师，tflearn Contributor & tensorflow Contributor，做过电商推荐、精准化营销相关算法工作，专注于分布式深度学习框架、计算机视觉算法研究，平时喜欢玩玩算法，研究研究开源的项目，偶尔也会去一些数据比赛打打酱油，生活中是个极客，对新技术、新技能痴迷。&/p&&p&你可以在Github上找到他：&a href=&/?target=http%3A///& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&http://&/span&&span class=&visible&&/&/span&&span class=&invisible&&&/span&&i class=&icon-external&&&/i&&/a&&/p&&/blockquote&&br&&p&「UCloud机构号」将独家分享云计算领域的技术洞见、行业资讯以及一切你想知道的相关讯息。&/p&&p&欢迎提问&求关注 o(*////▽////*)q～&/p&&p&以上。&/p&
引言TensorFlow是Google基于DistBelief进行研发的第二代人工智能学习系统，被广泛用于语音识别或图像识别等多项机器深度学习领域。其命名来源于本身的运行原理。Tensor（张量）意味着N维数组，Flow（流）意味着基于数据流图的计算，TensorFlow代表着张量从…
来自我们学校的最新消息：&br&&br&神经网络机器学习系统近日在德州扑克比赛中第一次战胜人类专家。&br&论文链接: &a href=&///?target=http%3A//t.cn/RMxoJTp& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Expert-Level Artificial Intelligence in No-Limit Poker&i class=&icon-external&&&/i&&/a&&br&&br&相比较2015年Michael Bowling在Science上发表的&a href=&///?target=http%3A//www.sciencemag.org/content/347/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Heads-up limit hold’em poker is solved&i class=&icon-external&&&/i&&/a&，该版本解决了双人限注德州扑克 （heads-up limit Texas hold'em poker），本次版本为No-Limit Poker.&br&&br&论文摘要：&br&&p&Artificial intelligence has seen a number of breakthroughs in recent years, with
games often serving as significant milestones. A common feature of games with
these successes is that they involve information symmetry among the players,
where all players have identical information. This property of perfect infor-
mation, though, is far more common in games than in real-world problems.
Poker is the quintessential game of imperfect information, and it has been a
longstanding challenge problem in artificial intelligence. In this paper we in-
troduce DeepStack, a new algorithm for imperfect information settings such as
poker. It combines recursive reasoning to handle information asymmetry, de-
composition to focus computation on the relevant decision, and a form of intu-
ition about arbitrary poker situations that is automatically learned from self-
play games using deep learning. In a study involving dozens of participants
and 44,000 hands of poker,&b&&i& DeepStack becomes the first computer program to
beat professional poker players in heads-up no-limit Texas hold’em.&/i&&/b& Further-
more, we show this approach dramatically reduces worst-case exploitability
compared to the abstraction paradigm that has been favored for over a decade. &/p&&br&&blockquote&&p&引自新智元公众号：&a href=&///?target=https%3A//mp./s%3F__biz%3DMzI3MTA0MTk1MA%3D%3D%26mid%3D%26idx%3D1%26sn%3Ddf6cd66d12ae0e0fd359f35%26chksm%3Dfd2afca2a7bd7d4abf6c41bce5709dccebf%26scene%3D0%26key%3Dde54e7c557ca8b575cb7c75c3f4bba5786b9bfdd7c699cb59ccdf51f4a5ca8a2aa1dbb6c97d1ce1dacd205e1de6f2f087e85a372ea6a5%26ascene%3D0%26uin%3DODI1NzQ3Njgx%26devicetype%3DiMac%2BMacBookPro12%252C1%2BOSX%2BOSX%2B10.12%2Bbuild%%26version%3Dnettype%3DWIFI%26fontScale%3D100%26pass_ticket%3D6SmuOj616Ji4IR6gHd8BuELsUKsjmNfk23pUWDVnpipUdP7rCGialXVFkPsz504j& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&【重磅】AI 首次在德州扑克战胜人类职业玩家，新算法让机器拥有“直觉”（附论文）&i class=&icon-external&&&/i&&/a&&/p&&p&差不多是对论文原文的翻译&/p&&p&来自加拿大和捷克的几位计算机科学研究者近日在 arXiv 上贴出论文，介绍了一种用于不完美信息（例如扑克）的新算法，DeepStack 结合使用循环推理来处理信息不对称，使用分解将计算集中在相关的决策上，并且使用一种深度学习技术从单人游戏中自动学习的有关扑克任意状态的直觉形式&strong&。研究者在论文中称，在一项有数十名参赛者进行的44000手扑克的比赛中，DeepStack 成为第一个在一对一无限注德州扑克中击败职业扑克玩家的计算机程序。&/strong&&/p&&br&非完美信息博弈&br&&p&游戏长久以来都被认为是用来测量人工智能进步的一个基准。在过去的20年间，我们见证了许多游戏程序已经在许多游戏上超越了人类，比如西洋双陆棋、跳棋、国际象棋、Jeopardy 、Atari 电子游戏和围棋。计算机程序在这些方面的成功涉及的都是信息的对称性，也就是对于当下的游戏状态，所有的玩家能够获得的确定性信息是相同的。这种完美信息的属性也是让这些程序取得成功的算法的核心，比如，在游戏中的局部搜索。&br&&/p&&br&&p&现代游戏理论创建者、计算机先锋 von Neumann 曾对无完美信息游戏中的推理行为进行过解释：“现实世界与此不同，现实世界包含有很多赌注、一些欺骗的战术，还涉及你会思考别人会认为你将做什么。” von Neumann 最痴迷的一个游戏是扑克，在这个游戏中，玩家在得到自己的牌后，会轮流下注，让对手跟注，他们或跟注或弃牌。扑克是一种非完美信息游戏，玩家只能根据自己手上的牌提供的非对称的信息来对游戏状态进行评估。&/p&&br&&p&在一对一对战（也就是只有两位玩家）的有限下注德州扑克中，AI 曾经取得了一些成功。但是，一对一有限注的德州扑克，全部的决策点（decision points）只有不到10的14次方个。作为对比，计算机已经在围棋上完胜人类专业棋手，围棋是一个完美信息的游戏，约包含有10的170次方个决策点。&/p&&br&&p&非完美信息游戏要求更复杂的推理能力。在特定时刻的正确决策依赖于对手所透露出来的个人信息的概率分布，这通常会在他们的行动中表现出来。但是， 对手的行为如何暗示他的信息，反过来也要取决于他对我们的私人信息有多少了解，我们的行为已经透露了多少信息。这种循环性的推理正是为什么一个人很难孤立地推理出游戏的状态，不过在完美信息游戏中，这是局部搜索方法的核心。&/p&&br&&p&在非完美信息游戏中，比较有竞争力的AI 方法通常是对整个游戏进行推理，然后得出一个完整的优先策略。CFR （ Counterfactual regret minimization）是其中一种战术，使用自我博弈来进行循环推理，也就是在多次成功的循环中，通过采用自己的策略来对抗自己。如果游戏过大，难以直接解决，常见的方法是先解决更小的、浓缩型的游戏。最后，如果要玩最初的大型的游戏，需要把原始版本的游戏中设计的模拟和行为进行转移，到一个更“浓缩”的游戏中完成。&/p&&p&虽然这一方法让计算机在 HUNL 一类的游戏中进行推理变得可行，但是，它是通过把HUNL下的10的160次方个场景压缩到10的14次方缩略场景的来实现的。这种方法有很大的可能性会丢失信息，所有这类的程序离专业的人类玩家水平还差得很远。&/p&&br&&p&2015年，计算机程序 Claudico 输给了一个专业扑克玩家团队，并且是以较大的劣势输掉的比赛。此外，最近，在年度计算机扑克竞赛中，人们发现，基于“浓缩”的计算机程序有着大量的缺点。其中4个使用了这一方法的计算机程序，其中包括从2016年来一直位列前茅的程序，被认为使用了一个局部最佳响应的技巧，使得在一个策略能输掉多少这一决策上，产生一个更加接近下限的答案。所有这四个基于“浓缩”方法的程序都可能会输得很惨，用量化来表示，是每局都弃牌所属的四倍。&/p&&br&&p&DeepStack 采用了一个完全不同的方法。它持续地使用CFR中的循环推理来处理信息不对称的问题。但是，它并不会计算和存储一个完整的优先策略用于博弈，所以也不需要进行简要的提炼（浓缩）。反之，在游戏中，它会在每一个具体的场景出现时就进行考虑， 但是并不是独立的。 &/p&&br&&p&通过使用一个快速的近似估计来代替某一种深度的计算，它能避免对整个游戏的剩余部分进行推理。这种估计可以被看成是 DeepStack 的直觉：在任何可能的扑克情境下，持有任何可能的个人牌的牌面大小的直觉。&/p&&br&&p&最终，从某种程度上来说与人类的很像的 DeepStack 的直觉，是需要被训练的。我们使用了随机生成的扑克情景用深度学习进行训练。最终，我们证明了，DeepStack从理论上来说是可行的，比起基于“浓缩”的方法，它能产生从实质上需要更少地探索的策略，同时，它也是世界上首个在HUNL游戏中击败人类专业玩家的计算机程序，平均赢率超过450 mbb/g。（mbb/g,milli-big-blinds per game ,是用于衡量扑克玩家表现的指数，50 mbb/g 可以就认为是一个较大的优势，750mbb/g 就是对手每局都弃牌的赢率。）&/p&&br&神经网络机器学习系统第一次战胜人类职业玩家&br&&p&&strong&跟职业选手对抗结果&/strong&&/p&&br&&p&为了把 DeepStack 跟人类专家相比较，我们雇用了国际扑克联盟（International Federation of Poker）里的专业扑克选手。选手们在4周中完成3000局比赛。为了激励选手，给排名最高的前三（以AIVAT计）分别予以 5000加元、2500加元和1250加元的奖励。比赛在日和12月12日之间在线上举行，扑克选手可以选择最多同时玩4局，这在线上很常见。总共有来自17个国家的33名选手跟 DeepStack 进行了较量。DeepStack 跟每个人比赛的表现如表 1：&/p&&br&&p&&br&表 1：跟职业扑克选手较量结果，以 AIVAT 和所赢得的筹码进行衡量，以 mbb/g 为单位。&/p&&br&&p&&br&表 2：向前分解根据在哪一轮而具体分析。F, C, 1/2P, P ,2P 和 A 分别是如下的缩写：弃牌（Fold），跟进（Call），二分之一底池押注（half of a pot-sized bet），底池押注（a pot-sized bet），双倍底池押注（twice a pot-sized bet）以及全注（All in）。最后一列表示当超过深度限制的时候用到了哪个神经网络：flop 网络， turn 网络，或者辅助网络。&/p&&p&&strong&比赛速度&/strong&&/p&&br&&p&分解计算和神经网络评估在一个 GPU 上实现。这使得它可以一次快速批量调用反事实价值网络上多个子公共树。这是让 DeepStack 变快的关键。在 Torch7 中开发，在 NVIDIA GeForce GTX 1080 显卡上运行。很多以上的实现手段都是为了让 DeepStack 快速运行，理想上是像人打牌一样快。表 3 展示了 DeepStack 和人类在前一步骤的之后和提交下一个步骤之前的平均间隔时间。平均看来，DeepStack 比起人类选手快很多。不过我们要记住人类选手同时可以进行4局比赛（虽然很少有人同时进行两局以上），所以当轮到人类选手比赛时，它可能正在另外一盘比赛上。&/p&&br&&p&表 3： 人类和 DeepStack 的思考时间，DeepStack 在第一轮叫注（Pre-flop）平均时间超级快，这表明第一轮叫注时的状态通常能命中缓存。&br&&/p&&br&&br&&p&表 4： 不同程序使用局部最佳反馈（LBR：local best response）的最低程度。LBR 仅仅评估每一轮在下表中所列出的动作。F, C, 1/2P, P ,2P 和 A 缩写意义同上。&/p&&br&&br&&p&&strong&最佳反馈估值（Best-response Values） vs 自玩估值（Self-play Values）&/strong&&/p&&br&&p&DeepStack 在持续分解计算中采用自玩估值而非最佳反馈估值。之前的预测试用 CFR-D 解决更小的比赛，这表明自玩估值产生的策略通常攻击性更小，与最佳反馈估值产生的策略相比，在和测试智能代理一对一的表现更好。图 5 展示了一个例子，关于 DeepStack在特定第五张牌的博弈中有着不同数字的分解迭代的攻击性。除了缺少对它稳固性的理论评价，用自玩估值看上去就像最佳反馈估值一样最终收敛至低攻击性策略。&/p&&br&&br&&p&图 5：DeepStack 在第五张牌开始前特定公共状态下的攻击性和分解迭代数量之间的方程。&/p&&br&&p&算法 DeepStack ：让机器拥有“直觉”&/p&&br&&p&DeepStack 是一大类的序列不完美信息博弈的通用算法。我们将解释 DeepStack 在 HUNL（heads-up no-limit，一对一无限注）德州扑克中的作用。扑克游戏的状态可以分为玩家的私人信息，即两张牌面朝下的手牌，以及公共状态，包括牌面朝上的公共牌和玩家的下注顺序。游戏中公共状态的可能序列形成公共树，每个公共状态有一个相关联的子公共树。见下图6：&/p&&br&&p&&br&图6：HUNL公共树的一部分。红色和湖蓝色代表玩家的动作。绿色代表被翻开的公共牌。&/p&&br&&p&DeepStack 算法试图计算玩游戏的低利用率策略，即，求解一个近似的纳什均衡（Nash equilibrium）。DeepStack在玩牌期间计算这个策略，公共树的状态如图7所示。这种本地的计算使得 DeepStack 在对现有算法来说规模太大的游戏中可推理，因为需要抽象出的游戏的10的160次方决策点下降到10的14次方，这让算法变得易处理。&br&&/p&&br&&br&&br&&p&图7：DeepStack 概览图。（a）DeepStack 对在每个公共状态的动作进行 re-solves，使用 depth-limited lookahead，其中子树值的计算用训练好的深度神经网络（b）通过随机生成的扑克状态在玩牌前进行训练（c）最终状态如图3.&/p&&br&&p&DeepStack 算法由三个部分组成：针对当前公共状态的本地策略计算（local strategy computation），使用任意扑克状态的学习价值函数的 depth-limited lookahead，以及预测动作的受限集合。&/p&&br&&p&&strong&连续 Re-Solving&/strong&&/p&&br&&ul&&li&&p&Own Action：将对手的反事实值替换为在为我们自己选择动作的解决策略中计算的值。使用计算策略和贝叶斯规则更新我们自己的动作范围。&/p&&/li&&br&&li&&p&Chance Action：用从最后一次分解为这个动作计算出的反事实值替换对手反事实值。通过清除在任何新公共牌不可能的手牌范围，更新我们自己的范围。&/p&&/li&&/ul&&ul&&li&&p&Opponent Action：不用做什么。&/p&&/li&&/ul&&br&&p&&strong&Limited Lookahead 和 Sparse Trees&/strong&&/p&&br&&p&连续re-solving在理论上是可行的，但实际使用上不现实。它没有维持一个完整的策略，除非游戏接近结束，re-solving本身就很棘手。例如，对于第一次动作的re-solving需要为整个游戏临时计算近似解决方案。&/p&&br&&p&&strong&Deep Counterfactual Value Networks&/strong&&br&&/p&&br&&p&深度神经网络（DNN）已被证明在图像和语音识别、自动生成音乐以及玩游戏等任务上是强有力的模型。DeepStack 使用DNN和定制的架构作为它的 depth-limited lookahead其的价值函数。如图8。训练两个独立的网络：一个在第一次三张公共牌被处理（flop网络）后估计反事实值，另一个在处理第四张公共牌（turn网络）后估计反事实值。一个辅助网络用于在发任意公共牌之前加速对前面的动作的re-solving。&/p&&br&&br&&p&图8：Deep Counterfactual Value Networks。网络的输入是pot的大小，公共牌和玩家范围，玩家范围先被处理为bucket ranges。输出来自七个完全连接的隐藏层，被后处理以保证值满足零和限制（zero-sum constraint）。&/p&&br&&p&CMU 又被截胡&/p&&br&&p&近日，新智元在报道中提到，被称为“人脑 vs 人工智能：跟不跟 ” 的赛事将于1月11日在匹兹堡的 Rivers 赌场启幕。比赛期间，职业扑克手 Jason Les， Dong Kim， Daniel McAulay 和 Jimmy Chou 将在20天的时间和 CMU 计算机程序玩120000手一对一不限注的德州扑克。&/p&&br&&p&CMU的人工智能系统名叫 Libratus ，相比去年失败的 Claudico，其终于策略发生了改变。 Libratus 会用 Bridges 计算机实时计算新的终局解决方法和算法，而不是像 Claudico 那么依赖终局。&/p&&br&&p&另外，Claudico 常用的策略是 limping，这是一个扑克术语，指跟注混进去看看，而不是加注或者放弃。而 Libratus 偶尔也会这样。&/p&&br&&p&可以看到，和上文中提到的 DeepStack一样，他们希望攻克的也是一对一（两个选手）不限注的的德州扑克难题，这是一个极度复杂的游戏，有10的160次方信息集——每个集合都根据出牌方的理解有不同的路径。这个巨大的信息集比整个宇宙的原子数还多。&/p&&br&&p&而综合两个机构的介绍，其使用的方法也有相似性，即采用实时计算。CMU的比赛于11日举行，而这边论文已经发布在arXiv上，看起来，CMU又被截胡了。&/p&&/blockquote&
来自我们学校的最新消息： 神经网络机器学习系统近日在德州扑克比赛中第一次战胜人类专家。 论文链接:
相比较2015年Michael Bowling在Science上发表的，该…
&p&刚好大致过了一遍最新的论文：&a href=&///?target=https%3A//arxiv.org/pdf/v1.pdf& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&https://&/span&&span class=&visible&&arxiv.org/pdf/&/span&&span class=&invisible&&4v1.pdf&/span&&span class=&ellipsis&&&/span&&i class=&icon-external&&&/i&&/a& ，AI在双人无限注heads-up no-limit 德州扑克中战胜了职业玩家。&/p&&p&简单Po几个论文里的观点和细节吧：&/p&&p&1. 无限注的难度远高于有限注的德扑，接近围棋的难度。双人有限注德扑有&img src=&///equation?tex=10%5E%7B14%7D& alt=&10^{14}& eeimg=&1&& 个决策点，围棋有&img src=&///equation?tex=10%5E%7B170%7D& alt=&10^{170}& eeimg=&1&&个决策点，而双人无限注有&img src=&///equation?tex=10%5E%7B160%7D& alt=&10^{160}& eeimg=&1&& 。在计算的复杂程度上可见一斑。&/p&&p&2. 扑克是一种具有不完美信息特性的游戏，因为对手的手牌是隐藏着的，只能通过对手的行为来推理对手可能掌握的手牌，在这篇文章里对手行为包括对手的下注、跟注、弃牌等动作，这里涉及到一些欺骗的战术例如在没什么胜算的情况下虚张声势的下很多筹码。比完美信息游戏（如围棋等对抗双方信息完全共享的游戏）需要更复杂的推理过程。&/p&&p&3. 直觉，说好听点就是像人的直觉一样快速判断场面，说白了其实就是一个快速估算场面的深度神经网络，通过输入底池里的筹码数、公共牌和玩家可能拿牌情况的概率分布，输出是在任意拿牌场景下的Value&/p&&img src=&/v2-f4f5aa0b8ec52aa9602d1cbe18f0ca45_b.png& class=&content_image&&&p&4. 没有用到专业的牌局进行神经网络的训练，不同于AlphaGo用了大量的棋局做训练，这个模型用的是随机生成的牌局（随机产生公共牌、底池筹码、玩家拿牌概率）和尝试性的动作带来的结果（在随机生成的输入情况下模拟玩家跟牌后的结果）作为训练数据。&/p&&p&5. 做了有针对性的优化后，思考时间很短，但是不排除有可能人类玩家同时在进行多局游戏的情况。&/p&&img src=&/v2-5b8464dbea0e7df06672_b.png& class=&content_image&&&br&&p&&b&总的来说，结果挺优秀，但是个人感觉方法上的闪光点不多，应该远远不是德扑AI的最终形态。&/b&&/p&
刚好大致过了一遍最新的论文： ，AI在双人无限注heads-up no-limit 德州扑克中战胜了职业玩家。简单Po几个论文里的观点和细节吧：1. 无限注的难度远高于有限注的德扑，接近围棋的难度。双人有限注德扑有10^{14} 个决策点，围棋有10^{17…
1.&Hadoop.Operations.pdf.zip&&a href=&///?target=http%3A///s/vDOQs6xMAQH62& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&http://&/span&&span class=&visible&&/s/vDOQs&/span&&span class=&invisible&&6xMAQH62&/span&&span class=&ellipsis&&&/span&&i class=&icon-external&&&/i&&/a&&br&2.&Hadoop权威指南(中文版)(带书签).pdf&&a href=&///?target=http%3A///s/wxJYuVE573j& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Hadoop权威指南(中文版)(带书签).pdf&i class=&icon-external&&&/i&&/a&&br&3.&[Hadoop权威指南(第2版)].pdf&&a href=&///?target=http%3A///s/vmaSwlKBP5Kt& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&[Hadoop权威指南(第2版)].pdf&i class=&icon-external&&&/i&&/a&&br&4.&hadoop权威指南第3版2012.rar&&a href=&///?target=http%3A///s/aN4iIpKT0Kml& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&hadoop权威指南第3版2012.rar&i class=&icon-external&&&/i&&/a&&br&&br&5.《Hadoop技术内幕：深入解析HadoopCommon和HDFS.pdf&&a href=&///?target=http%3A///s/dlA_OphOI5AQU& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&《Hadoop技术内幕：深入解析Hadoop Common和HDFS.pdf&i class=&icon-external&&&/i&&/a&&br&6.&Hadoop技术内幕：深入解析MapReduce架构设计与实现原理.pdf&&a href=&///?target=http%3A///s/uIsyCUsePIjoh& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Hadoop技术内幕：深入解析MapReduce架构设计与实现原理.pdf&i class=&icon-external&&&/i&&/a&&br&&br&7.&Hadoop实战.pdf&&a href=&///?target=http%3A///s/BXMAwF_-NCyZw& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Hadoop实战.pdf&i class=&icon-external&&&/i&&/a&&br&8.&Hadoop实战-陆嘉恒(高清完整版).pdf&&a href=&///?target=http%3A///s/z5rVAAQ3zblXs& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Hadoop实战-陆嘉恒(高清完整版).pdf&i class=&icon-external&&&/i&&/a&&br&9.&Hadoop实战(第2版).pdf&&a href=&///?target=http%3A///s/j6KrzC8boQ1& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Hadoop实战(第2版).pdf&i class=&icon-external&&&/i&&/a&&br&10.&HadoopinAction.pdf&&a href=&///?target=http%3A///s/BLZQKXQryIW7z& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Hadoop in Action.pdf&i class=&icon-external&&&/i&&/a&&br&&br&11&Hadoop in practice.pdf&&a href=&///?target=http%3A///s/CbeFlyMYjJq3C& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Hadoop in practice.pdf&i class=&icon-external&&&/i&&/a&&br&12&HadoopThe.Definitive.Guide,3Ed.pdf&&a href=&///?target=http%3A///s/dlQXvZtzIH6KO& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Hadoop The.Definitive.Guide,3Ed.pdf&i class=&icon-external&&&/i&&/a&&br&13.&O'Reilly.Hadoop.The.Definitive.Guide.3rd.Edition.May.2012.pdf&&a href=&///?target=http%3A///s/znRfJCcREJGsZ& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&O'Reilly.Hadoop.The.Definitive.Guide.3rd.Edition.May.2012.pdf&i class=&icon-external&&&/i&&/a&&br&&br&14.&hadoop入门实战手册.pdf&&a href=&///?target=http%3A///s/aprYE9iSa5XEs& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&hadoop入门实战手册.pdf&i class=&icon-external&&&/i&&/a&&br&15.&Hadoop入门手册.chm&&a href=&///?target=http%3A///s/dDOrPlQHwCtJ& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Hadoop入门手册.chm&i class=&icon-external&&&/i&&/a&&br&&br&16.&windows下配置cygwin、hadoop等并运行mapreduce及mapreduce程序讲解.doc&&a href=&///?target=http%3A///s/drDKePjiE_dtP& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&windows下配置cygwin、hadoop等并运行mapreduce及mapreduce程序讲解.doc&i class=&icon-external&&&/i&&/a&&br&17&在Windows上安装Hadoop教程.pdf&&a href=&///?target=http%3A///s/zbLG_VnilVLPF& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&在Windows上安装Hadoop教程.pdf&i class=&icon-external&&&/i&&/a&&br&&br&18.&Hadoop源代码分析(完整版).pdf&&a href=&///?target=http%3A///s/bef7_LzOlZB5& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Hadoop源代码分析(完整版).pdf&i class=&icon-external&&&/i&&/a&&br&19.&hadoop-api.CHM&&a href=&///?target=http%3A///s/aGkLoGJkdIegt& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&hadoop-api.CHM&i class=&icon-external&&&/i&&/a&&br&&br&20.&HBase-Hadoop@小米.pptx& &a href=&///?target=http%3A///s/z83zdriL8kvgi& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&HBase-Hadoop@小米.pptx&i class=&icon-external&&&/i&&/a&&br&21.&但彬-Hadoop平台的大数据整合.pdf&&a href=&///?target=http%3A///s/u90dUcJt2FEnP& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&但彬-Hadoop平台的大数据整合.pdf&i class=&icon-external&&&/i&&/a&&br&&br&22.&QCon2013-罗李-Hadoop在阿里.pdf&&a href=&///?target=http%3A///s/u5f-a75unTu1& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&QCon2013-罗李&i class=&icon-external&&&/i&&/a&&br&23.&百度hadoop计算技术发展.pdf&&a href=&///?target=http%3A///s/aX0ftWKG8HXua& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&百度hadoop计算技术发展.pdf&i class=&icon-external&&&/i&&/a&&br&24.&QCon-吴威-基于Hadoop的海量数据平台.pdf&&a href=&///?target=http%3A///s/Er65NDisGiC& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&QCon-吴威-基于Hadoop的海量数据平台.pdf&i class=&icon-external&&&/i&&/a&&br&25.&8步安装好你的hadoop.docx&&a href=&///?target=http%3A///s/wfP0FRVUCC1& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&8步安装好你的hadoop.docx&i class=&icon-external&&&/i&&/a&&br&26.&hadoop运维经验分享.ppsx&&a href=&///?target=http%3A///s/Er65NDit1x7& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&hadoop运维经验分享.ppsx&i class=&icon-external&&&/i&&/a&&br&&br&27.&PPT集萃：20位Hadoop专家分享大数据技术工具与最佳实践.rar&&a href=&///?target=http%3A///s/uf1uFDgIUS3q_& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&PPT集萃：20位Hadoop专家分享大数据技术工具与最佳实践.rar&i class=&icon-external&&&/i&&/a&&br&28.&Hadoop2.0基本架构和发展趋势.pdf&&a href=&///?target=http%3A///s/z7Iw9cNWdwcfd& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Hadoop 2.0基本架构和发展趋势.pdf&i class=&icon-external&&&/i&&/a&&br&29.&Hadoop与大数据技术大会PPT资料.rar&&a href=&///?target=http%3A///s/aX0ftWKG8HEgB& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Hadoop与大数据技术大会PPT资料.rar&i class=&icon-external&&&/i&&/a&&br&30.&Hadoop2011云计算大会.rar&&a href=&///?target=http%3A///s/aX0ftWKG8HlNE& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Hadoop2011云计算大会.rar&i class=&icon-external&&&/i&&/a&&br&&br&31.&hadoop开发者(1~3)期.zip&&a href=&///?target=http%3A///s/dpAuMB4WqHl7H& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&hadoop开发者.zip&i class=&icon-external&&&/i&&/a&
1."Hadoop.Operations.pdf.zip" 2."Hadoop权威指南(中文版)(带书签).pdf" 3."[Hadoop权威指南(第2版)].pdf" 4."hadoop权威指南第3版2012.rar"…
&img src=&/v2-d9c66747dbbdd5554484e_b.jpg& data-rawwidth=&1728& data-rawheight=&1080& class=&origin_image zh-lightbox-thumb& width=&1728& data-original=&/v2-d9c66747dbbdd5554484e_r.jpg&&&p&去年初写2016年项目计划的情景还历历在目，眨眼就一年过去了，vn.py项目在2016年的成长速度远远超出了我的预期。截止写这篇文章的日，vn.py项目在Github上收获了2244个Star以及1276个Fork，比起2016年初几乎翻了四倍，代码贡献者的数量超过了20人（其中17人是在Github上直接提交了代码），机构用户的数量也已经超过了50家。&/p&&h3&首先回顾2016年项目计划的完成情况&/h3&&p&整体上去年计划的完成情况还不错，只有一个期权的CTA策略因为标的波动太小没有去做。&/p&&p&&strong&代码方面：&/strong&&/p&&ol&&li&&p&完善飞创、易盛等相对小众接口的添加，这块将由社区驱动，作者主要负责代码检查和管理（增加了vn.xspeed、vn.sgit、vn.okcoin、vn.shzd等接口，易盛暂时还未有计划）&/p&&/li&&li&&p&整理vn.py项目中API的具体版本号，保证封装接口的对应，这点已经有多位用户提起过，项目初期没有做详细记录所以很多API的版本号一时都较难对上（已完成）&/p&&/li&&li&&p&Linux上API的编译以及vn.trader支持（已完成）&/p&&/li&&li&&p&基于VirtualBox的vn.py开发环境镜像，解决部分用户反映项目初期不知该如何搭建开发环境的问题，这个镜像会由官方长期维护下去（已完成）&/p&&/li&&/ol&&p&&strong&文章方面：&/strong&&/p&&ol&&li&&p&作者自己作为交易员的成长经历（通过知乎LIVE完成）&/p&&/li&&li&&p&vn.trader的使用教程（已完成）&/p&&/li&&li&&p&将ta-lib（技术分析）和quantlib（金融工程和量化）整合到vn.trader中应用的教程，解决目前策略开发过程中技术指标和量化函数缺乏的问题（已完成）&/p&&/li&&li&&p&一套关于开发基于股指交易ETF期权的CTA策略的教程（未完成，上证50指数波动太小，准备在2017年基于商品期权来开发）&/p&&/li&&/ol&&p&&strong&社区方面：&/strong&&/p&&ol&&li&&p&重新建设官方网站，目前使用的是托管在Github Pages上的Hexo静态博客，一来功能比较有限，二来有些用户反映Github时不时会被墙，考虑基于Flask重建一个托管在国内的官网（已完成，基于Pelican的新官网）&/p&&/li&&li&&p&有用户提出建设互动性更强的网站作为交流平台（如论坛或者知乎Q&A类似的模式），这点在考虑中，主要制约因素是作者参与的时间，可能考虑和更多的资深用户合作是个好主意？（已完成，维恩的派论坛）&/p&&/li&&/ol&&h3&然后展望一下2017年的项目计划&/h3&&p&2015年是vn.py项目的诞生年，主要在打基础和完善架构；2016年基于社区的反馈，增加了很多新的接口和扩展模块；2017年准备集中在上层应用的开发，进一步解决量化交易员在实盘交易中的痛点。&/p&&p&&strong&Spread Trading价差交易模块&/strong&&/p&&p&这个应该是目前呼声最高的应用，还有个名字叫做Pair Trading（配对交易），主要用于实现各种套利类的交易策略，如跨期套利、跨品种套利、跨市场套利等。&/p&&p&在设计vn.trader中的CTA策略模块时，为了给策略开发者提供最大的自由度，选择把所有的交易委托细节都暴露给策略逻辑来管理。和CTA策略不同的是，价差交易策略一般只给出开平仓的信号，而不会直接去负责交易委托的细节管理。因此整个模块的实现上需要提供额外的一层功能：Spreading Algo价差委托算法，用于接受策略给出的交易信号，并自动管理各条套利腿的委托挂撤。&/p&&p&&strong&Web界面&/strong&&/p&&p&越来越多的量化交易员开始拥有自己的交易服务器，无论是成本较低的云服务器还是机构比较常用的经纪商托管服务器。&/p&&p&当前vn.trader的GUI界面开发使用的是PyQt4，只能在提供图形界面的操作系统上使用（Windows或者启动了X11服务的Linux）。而很多交易服务器考虑到系统稳定性和性能延时等因素，使用的都是纯命令行工作模式的Linux，在这种情况下Web界面就成为了比较合理的选择。&/p&&p&外观上准备参考AlgoTrader的&a href=&/?target=http%3A//html5.algotrader.ch/& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Web界面&i class=&icon-external&&&/i&&/a&，技术方面初步考虑使用Flask、Websocket、Bootstrap和Vue.js（已经有人提醒这个可能是大坑），后续开发过程中如果发现不合适再更换。&/p&&p&&strong&Docker支持&/strong&&/p&&p&相信不少vn.py项目的用户在刚上手使用时都掉过各种各样Python环境配置方面的坑：弄错Anaconda的版本、弄错vcredist的版本、不知道如何使用pip安装三方包等。为了解决这个问题，之前打包制作了一个VirtualBox的Ubuntu镜像，实现了用户的开箱即用，但存在几个问题：镜像过大下载缓慢、打包复杂没有时间长期维护、只能在虚拟机中使用。&/p&&p&最近两年诞生了一种新的容器技术Docker，让开发者可以打包他们的应用以及依赖包到一个可移植的容器中，然后用户可以在任何支持Docker的机器上直接使用，无论是虚拟机还是真实服务器。同时Docker的打包过程允许只提供环境搭建的指令，当用户部署Docker时才根据指令去下载和搭建整个环境，因此镜像可以很小（只是个脚本），还提供类似Github的Docker Hub方便镜像资源的分享。&/p&&p&目前社区已经有用户在Docker中成功运行了vn.trader，但仅实现了CTP接口，同时是纯命令行模式没有GUI界面（使用脚本启动）。接下来官方支持的Docker会实现所有Linux下可用的接口，并提供界面方便使用（Web界面或者X11服务穿透）。&/p&&p&&strong&国际化支持&/strong&&/p&&p&准备提供项目的英文支持，计划分为两步：软件界面上的英文翻译和文档的英文翻译。尽管vn.py项目诞生时主要面向的是国内量化交易员，但随着项目的成长，现在感觉也到了可以走出去看看的时候了。同时个人对vn.ib接口无论是API功能支持还是性能方面都挺有信心，想试试看能否超越IbPy。&/p&&p&&strong&文档建设&/strong&&/p&&p&有个笑话：程序员最恨的事情之一是别人的项目不写文档，之二就是给自己的项目写文档。之前也是有不少人抱怨过vn.py项目的文档资料太少，只有知乎专栏和&a href=&/?target=http%3A//www.vnpy.org& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&http://www.&/span&&span class=&visible&&vnpy.org&/span&&span class=&invisible&&&/span&&i class=&icon-external&&&/i&&/a&上面不多的文章，文章的抽象程度也比较高，让用户在刚上手时无从下手。&/p&&p&2017年准备从用户使用的角度来设计一套全面的文档：入门使用、策略开发、扩展模块开发、架构细节、封装原理等，让新手能够循序渐进的学习，不至于一上来掉坑后爬不出来就气馁。&/p&&p&最近开始接受项目捐赠来维护一个vn.py项目基金，第一个考虑的用途就是支持项目文档的编写。由本人设计好整个文档的目录，并给出几篇示例性质的章节后，鼓励社区成员选择自己擅长的题目章节去编写文档，对于文档作者而言参与的价值包括：&/p&&ol&&li&在编写文档过程中遇到的问题，本人和另外几位社区管理员（资深用户）会提供更加充分的答疑解难，有条件的时候可以线下辅导；&/li&&li&最终文档在发布后会署名作者的姓名，过去两年Python开发经验在国内量化领域求职时已经慢慢成为了一个重要加分项，有直接的vn.py文档编写经历证明相信可以为简历增色不少；&/li&&li&一定量的资金回馈（从项目基金中支付），写文档时候的咖啡钱组织总还是出得起的。&/li&&/ol&&h1&最后，各种地缘政治因素的动荡注定了2017年不会是平静的一年，祝大家在市场的大幅波动中多多赚钱！&/h1&
去年初写2016年项目计划的情景还历历在目，眨眼就一年过去了，vn.py项目在2016年的成长速度远远超出了我的预期。截止写这篇文章的日，vn.py项目在Github上收获了2244个Star以及1276个Fork，比起2016年初几乎翻了四倍，代码贡献者的数量超过了20人…
&b&Hadoop&/b&&br&首先看一下Hadoop解决了什么问题，Hadoop就是解决了大数据（大到一台计算机无法进行存储，一台计算机无法在要求的时间内进行处理）的可靠存储和处理。&br&&ul&&li&HDFS，在由普通PC组成的集群上提供高可靠的文件存储，通过将块保存多个副本的办法解决服务器或硬盘坏掉的问题。&/li&&li&MapReduce，通过简单的Mapper和Reducer的抽象提供一个编程模型，可以在一个由几十台上百台的PC组成的不可靠集群上并发地，分布式地处理大量的数据集，而把并发、分布式（如机器间通信）和故障恢复等计算细节隐藏起来。而Mapper和Reducer的抽象，又是各种各样的复杂数据处理都可以分解为的基本元素。这样，复杂的数据处理可以分解为由多个Job（包含一个Mapper和一个Reducer）组成的有向无环图（DAG）,然后每个Mapper和Reducer放到Hadoop集群上执行，就可以得出结果。&/li&&/ul&&img src=&/adb253dbce2cbc_b.jpg& data-rawwidth=&627& data-rawheight=&195& class=&origin_image zh-lightbox-thumb& width=&627& data-original=&/adb253dbce2cbc_r.jpg&&（图片来源：&a href=&///?target=http%3A//www.slideshare.net/davidengfer/intro-to-the-hadoop-stack-javamug& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&http://www.&/span&&span class=&visible&&slideshare.net/davideng&/span&&span class=&invisible&&fer/intro-to-the-hadoop-stack-javamug&/span&&span class=&ellipsis&&&/span&&i class=&icon-external&&&/i&&/a&）&br&&br&用MapReduce统计一个文本文件中单词出现的频率的示例WordCount请参见：&a href=&///?target=http%3A//wiki.apache.org/hadoop/WordCount& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&WordCount - Hadoop Wiki&i class=&icon-external&&&/i&&/a&，如果对MapReduce不恨熟悉，通过该示例对MapReduce进行一些了解对理解下文有帮助。&br&&br&在MapReduce中，Shuffle是一个非常重要的过程，正是有了看不见的Shuffle过程，才可以使在MapReduce之上写数据处理的开发者完全感知不到分布式和并发的存在。&br&&img src=&/57b942a32d5b035a7f1d_b.jpg& data-rawwidth=&774& data-rawheight=&367& class=&origin_image zh-lightbox-thumb& width=&774& data-original=&/57b942a32d5b035a7f1d_r.jpg&&（图片来源： Hadoop Definitive Guide By Tom White）&br&广义的Shuffle是指图中在Map和Reuce之间的一系列过程。&br&&br&&b&Hadoop的局限和不足&/b&&br&但是，MapRecue存在以下局限，使用起来比较困难。&br&&ul&&li&抽象层次低，需要手工编写代码来完成，使用上难以上手。&/li&&li&只提供两个操作，Map和Reduce，表达力欠缺。&/li&&li&一个Job只有Map和Reduce两个阶段（Phase），复杂的计算需要大量的Job完成，Job之间的依赖关系是由开发者自己管理的。&/li&&li&处理逻辑隐藏在代码细节中，没有整体逻辑&/li&&li&中间结果也放在HDFS文件系统中&/li&&li&ReduceTask需要等待所有MapTask都完成后才可以开始&/li&&li&时延高，只适用Batch数据处理，对于交互式数据处理，实时数据处理的支持不够&/li&&li&对于迭代式数据处理性能比较差&/li&&/ul&&br&比如说，用MapReduce实现两个表的Join都是一个很有技巧性的过程，如下图所示：&br&&img src=&/886cdc16b356e016d3ce_b.jpg& data-rawwidth=&713& data-rawheight=&359& class=&origin_image zh-lightbox-thumb& width=&713& data-original=&/886cdc16b356e016d3ce_r.jpg&&（图片来源：&a href=&///?target=http%3A////real-world-hadoop-implementing-a-left-outer-join-in-hadoop-map-reduce.html& class=& wrap external& target=&_blank& rel=&nofollow noreferrer&&Real World Hadoop&i class=&icon-external&&&/i&&/a&）&br&&br&因此，在Hadoop推出之后，出现了很多相关的技术对其中的局限进行改进，如Pig，Cascading，JAQL，OOzie，Tez，Spark等。&br&&br&&b&Apache Pig&/b&&br&Apache Pig也是Hadoop框架中的一部分，Pig提供类SQL语言（Pig Latin）通过MapReduce来处理大规模半结构化数据。而Pig Latin是更高级的过程语言，通过将MapReduce中的设计模式抽象为操作，如Filter，GroupBy，Join，OrderBy，由这些操作组成&b&有向无环图（DAG）&/b&。例如如下程序：&br&&div class=&highlight&&&pre&&code class=&language-bash&&&span class=&nv&&visits&/span&
&span class=&o&&=&/span& load ‘/data/visits’ as &span class=&o&&(&/span&user, url, &span class=&nb&&time&/span&&span class=&o&&)&/span&&span class=&p&&;&/span&
&span class=&nv&&gVisits&/span&
&span class=&o&&=&/span& group visits by url&span class=&p&&;&/span&
&span class=&nv&&visitCounts&/span&
&span class=&o&&=&/span& foreach gVisits generate url, count&span class=&o&&(&/span&visits&span class=&o&&)&/span&&span class=&p&&;&/span&
&span class=&nv&&urlInfo&/span&
&span class=&o&&=&/span& load ‘/data/urlInfo’ as &span class=&o&&(&/span&url, category, pRank&span class=&o&&)&/span&&span class=&p&&;&/span&
&span class=&nv&&visitCounts&/span&
&span class=&o&&=&/span& join visitCounts by url, urlInfo by url&span class=&p&&;&/span&
&span class=&nv&&gCategories&/span& &span class=&o&&=&/span& group visitCounts by category&span class=&p&&;&/span&
&span class=&nv&&topUrls&/span& &span class=&o&&=&/span& foreach gCategories generate top&span class=&o&&(&/span&visitCounts,10&span class=&o&&)&/span&&span class=&p&&;&/span&
store topUrls into ‘/data/topUrls’&span class=&p&&;&/span&
&/code&&/pre&&/div&描述了数据处理的整个过程。&br&&br&而Pig Latin又是通过编译为MapReduce，在Hadoop集群上执行的。上述程序被编译成MapReduce时，会产生如下图所示的Map和Reduce：&br&&img src=&/27f938d43e54be4eba91c7899daa3bca_b.jpg& data-rawwidth=&692& data-rawheight=&455& class=&origin_image zh-lightbox-thumb& width=&692& data-original=&/27f938d43e54be4eba91c7899daa3bca_r.jpg&&&br&（图片来源：&a href=&///?target=http%3A//cs.nyu.edu/courses/Fall12/CSCI-GA./sigmod08-pig-latin.ppt& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&http://&/span&&span class=&visible&&cs.nyu.edu/courses/Fall&/span&&span class=&invisible&&12/CSCI-GA./sigmod08-pig-latin.ppt&/span&&span class=&ellipsis&&&/span&&i class=&icon-external&&&/i&&/a&）&br&&br&Apache Pig解决了MapReduce存在的大量手写代码，语义隐藏，提供操作种类少的问题。类似的项目还有Cascading，JAQL等。&br&&br&&b&Apache Tez&/b&&br&Apache Tez，Tez是HortonWorks的Stinger Initiative的的一部分。作为执行引擎，Tez也提供了&b&有向无环图（DAG）&/b&，DAG由顶点（Vertex）和边（Edge）组成，Edge是对数据的移动的抽象，提供了One-To-One，BroadCast，和Scatter-Gather三种类型，只有Scatter-Gather才需要进行Shuffle。&br&&br&以如下SQL为例：&br&&div class=&highlight&&&pre&&code class=&language-sql&&&span class=&k&&SELECT&/span& &span class=&n&&a&/span&&span class=&p&&.&/span&&span class=&k&&state&/span&&span class=&p&&,&/span& &span class=&k&&COUNT&/span&&span class=&p&&(&/span&&span class=&o&&*&/span&&span class=&p&&),&/span&
&span class=&n&&AVERAGE&/span&&span class=&p&&(&/span&&span class=&k&&c&/span&&span class=&p&&.&/span&&span class=&n&&price&/span&&span class=&p&&)&/span&
&span class=&k&&FROM&/span& &span class=&n&&a&/span&
&span class=&k&&JOIN&/span& &span class=&n&&b&/span& &span class=&k&&ON&/span& &span class=&p&&(&/span&&span class=&n&&a&/span&&span class=&p&&.&/span&&span class=&n&&id&/span& &span class=&o&&=&/span& &span class=&n&&b&/span&&span class=&p&&.&/span&&span class=&n&&id&/span&&span class=&p&&)&/span&
&span class=&k&&JOIN&/span& &span class=&k&&c&/span& &span class=&k&&ON&/span& &span class=&p&&(&/span&&span class=&n&&a&/span&&span class=&p&&.&/span&&span class=&n&&itemId&/span& &span class=&o&&=&/span& &span class=&k&&c&/span&&span class=&p&&.&/span&&span class=&n&&itemId&/span&&span class=&p&&)&/span&
&span class=&k&&GROUP&/span& &span class=&k&&BY&/span& &span class=&n&&a&/span&&span class=&p&&.&/span&&span class=&k&&state&/span&
&/code&&/pre&&/div&&img src=&/666f395a113ccc523a32_b.jpg& data-rawwidth=&864& data-rawheight=&431& class=&origin_image zh-lightbox-thumb& width=&864& data-original=&/666f395a113ccc523a32_r.jpg&&（图片来源：&a href=&///?target=http%3A//www.slideshare.net/hortonworks/apache-tez-accelerating-hadoop-query-processing& class=& external& target=&_blank& rel=&nofollow noreferrer&&&span class=&invisible&&http://www.&/span&&span class=&visible&&slideshare.net/hortonwo&/span&&span class=&invisible&&rks/apache-tez-accelerating-hadoop-query-processing&/span&&span class=&ellipsis&&&/span&&i class=&icon-external&&&/i&&/a&）&br&途中蓝色方块表示Map，绿色方块表示Reduce，云状表示写屏障（write barrier，一种内核机制，可以理解为持久的写），Tez的优化主要体现在：&br&&ol&&li&去除了连续两个作业之间的写屏障&/li&&li&去除了每个工作流中多余的Map阶段（Stage）&/li&&/ol&通过提供DAG语义和操作，提供了整体的逻辑，通过减少不必要的操作，Tez提升了数据处理的执行性能。&br&&br&&b&Apache Spark&/b&&br&Apache Spark是一个新兴的大数据处理的引擎，主要特点是提供了一个集群的分布式内存抽象，以支持需要工作集的应用。&br&&br&这个抽象就是RDD（Resilient Distributed Dataset），RDD就是一个不可变的带分区的记录集合，RDD也是Spark中的编程模型。Spark提供了RDD上的两类操作，转换和动作。转换是用来定义一个新的RDD，包括map, flatMap, filter, union, sample, join, groupByKey, cogroup, ReduceByKey, cros, sortByKey, mapValues等，动作是返回一个结果，包括collect, reduce, count, save, lookupKey。&br&&br&Spark的API非常简单易用，Spark的WordCount的示例如下所示：&br&&div class=&highlight&&&pre&&code class=&language-scala&&&span class=&k&&val&/span& &span class=&n&&spark&/span& &span class=&k&&=&/span& &span class=&k&&new&/span& &span class=&nc&&SparkContext&/span&&span class=&o&&(&/span&&span class=&n&&master&/span&&span class=&o&&,&/span& &span class=&n&&appName&/span&&span class=&o&&,&/span& &span class=&o&&[&/span&&span class=&kt&&sparkHome&/span&&span class=&o&&],&/span& &span class=&o&&[&/span&&span class=&kt&&jars&/span&&span class=&o&&])&/span&
&span class=&k&&val&/span& &span class=&n&&file&/span& &span class=&k&&=&/span& &span class=&n&&spark&/span&&span class=&o&&.&/span&&span class=&n&&textFile&/span&&span class=&o&&(&/span&&span class=&s&&&hdfs://...&&/span&&span class=&o&&)&/span&
&span class=&k&&val&/span& &span class=&n&&counts&/span& &span class=&k&&=&/span& &span class=&n&&file&/span&&span class=&o&&.&/span&&span class=&n&&flatMap&/span&&span class=&o&&(&/span&&span class=&n&&line&/span& &span class=&k&&=&&/span& &span class=&n&&line&/span&&span class=&o&&.&/span&&span class=&n&&split&/span&&span class=&o&&(&/span&&span class=&s&&& &&/span&&span class=&o&&))&/span&
&span class=&o&&.&/span&&span class=&n&&map&/span&&span class=&o&&(&/span&&span class=&n&&word&/span& &span class=&k&&=&&/span& &span class=&o&&(&/span&&span class=&n&&word&/span&&span class=&o&&,&/span& &span class=&mi&&1&/span&&span class=&o&&))&/span&
&span class=&o&&.&/span&&span class=&n&&reduceByKey&/span&&span class=&o&&(&/span&&span class=&k&&_&/span& &span class=&o&&+&/span& &span class=&k&&_&/span&&span class=&o&&)&/span&
&span class=&n&&counts&/span&&span class=&o&&.&/span&&span class=&n&&saveAsTextFile&/span&&span class=&o&&(&/span&&span class=&s&&&hdfs://...&&/span&&span class=&o&&)&/span&
&/code&&/pre&&/div&其中的file是根据HDFS上的文件创建的RDD，后面的flatMap，map，reduceByKe都创建出一个新的RDD，一个简短的程序就能够执行很多个转换和动作。&br&&br&在Spark中，所有RDD的转换都是是&b&惰性求值&/b&的。RDD的转换操作会生成新的RDD，新的RDD的数据依赖于原来的RDD的数据，每个RDD又包含多个分区。那么一段程序实际上就构造了一个由相互依赖的多个RDD组成的&b&有向无环图（DAG）。&/b&并通过在RDD上执行动作将这个有向无环图作为一个Job提交给Spark执行。&br&&br&例如，上面的WordCount程序就会生成如下的DAG&br&&div class=&highlight&&&pre&&code class=&language-scala&&&span class=&n&&scala&/span&&span class=&o&&&&/span& &span class=&n&&counts&/span&&span class=&o&&.&/span&&span class=&n&&toDebugString&/span&
&span class=&n&&res0&/span&&span class=&k&&:&/span& &span class=&kt&&String&/span& &span class=&o&&=&/span&
&span class=&nc&&MapPartitionsRDD&/span&&span class=&o&&[&/span&&span class=&err&&7&/span&&span class=&o&&]&/span& &span class=&n&&at&/span& &span class=&n&&reduceByKey&/span& &span class=&n&&at&/span& &span class=&o&&&&/span&&span class=&n&&console&/span&&span class=&k&&&:&/span&&span class=&mi&&14&/span& &span class=&o&&(&/span&&span class=&mi&&1&/span& &span class=&n&&partitions&/span&&span class=&o&&)&/span&
&span class=&nc&&ShuffledRDD&/span&&span class=&o&&[&/span&&span class=&err&&6&/span&&span class=&o&&]&/span& &span class=&n&&at&/span& &span class=&n&&reduceByKey&/span& &span class=&n&&at&/span& &span class=&o&&&&/span&&span class=&n&&console&/span&&span class=&k&&&:&/span&&span class=&mi&&14&/span& &span class=&o&&(&/span&&span class=&mi&&1&/span& &span class=&n&&partitions&/span&&span class=&o&&)&/span&
&span class=&nc&&MapPartitionsRDD&/span&&span class=&o&&[&/span&&span class=&err&&5&/span&&span class=&o&&]&/span& &span class=&n&&at&/span& &span class=&n&&reduceByKey&/span& &span class=&n&&at&/span& &span class=&o&&&&/span&&span class=&n&&console&/span&&span class=&k&&&:&/span&&span class=&mi&&14&/span& &span class=&o&&(&/span&&span class=&mi&&1&/span& &span class=&n&&partitions&/span&&span class=&o&&)&/span&
&span class=&nc&&MappedRDD&/span&&span class=&o&&[&/span&&span class=&err&&4&/span&&span class=&o&&]&/span& &span class=&n&&at&/span& &span class=&n&&map&/span& &span class=&n&&at&/span& &span class=&o&&&&/span&&span class=&n&&console&/span&&span class=&k&&&:&/span&&span class=&mi&&14&/span& &span class=&o&&(&/span&&span class=&mi&&1&/span& &span class=&n&&partitions&/span&&span class=&o&&)&/span&
&span class=&nc&&FlatMappedRDD&/span&&span class=&o&&[&/span&&span class=&err&&3&/span&&span class=&o&&]&/span& &span class=&n&&at&/span& &span class=&n&&flatMap&/span& &span class=&n&&at&/span& &span class=&o&&&&/span&&span class=&n&&console&/span&&span class=&k&&&:&/span&&span class=&mi&&14&/span& &span class=&o&&(&/span&&span class=&mi&&1&/span& &span class=&n&&partitions&/span&&span class=&o&&)&/span&
&span class=&nc&&MappedRDD&/span&&span class=&o&&[&/span&&span class=&err&&1&/span&&span class=&o&&]&/span& &span class=&n&&at&/span& &