星尘—程序猿的小站

【自然语言处理】中文分词

2018年11月12日 admin 评论已被关闭

词汇与分词技术一、分词流派机械式分词基于词典，直接根据词典中的词条切分简单、实用，缺点是词典的完备性护问 […]

分类: 技术，让世界更美好。标签:

【自然语言处理】n元语法（n-gram）

2018年9月27日 admin 评论已被关闭

概念 n元语法（英语：n-gram）指文本中连续出现的n个语词。n元语法模型是基于(n-1)阶马尔可夫链的一 […]

分类: 技术，让世界更美好。标签:

阿里算法策略简介

2018年3月9日 admin 评论已被关闭

法策略名称简介技术点备注
基于内容的推荐
1.根据物品表的keywords（one-hot）,description(分词),properties（one-hot）字段抽取特征

2.使用特征通过相识度算法建立物品-物品topN,再根据用户行为对用户做出推荐

相识度算法
特征工程（分词，特征抽取，特征标准化，one-hot编码，特征变换算法）
物品特征如何计算相识度矩阵
4
默认推荐基于pv、权重、随机分桶、最新上架、物品信息的其中一个策略产生默认推荐无
基于itemCF的推荐
1.根据行为提取三元组

2.根据物品相似度算法建立物品相似度矩阵，根据矩阵对用户的行为做出推荐

相识度算法
近线离线数据流程配合

分类: 技术，让世界更美好。标签:

MNIST

2018年3月9日 admin 评论已被关闭

import os

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'

# mnist 数据集参数
INPUT_NODE = 784 # 输入层节点数，也就是图片的像素数
OUTPUT_NODE = 10 # 输出层节点数，也就是属于0到9的那个数字

# 神经网络参数
LAYER1_NODE = 500 # 隐藏层节点数，这里只有一个隐藏层
BATCH_SIZE = 100 # 一个训练batch中数据个数
LEARNING_RATE_BASE = 0.8 # 基础学习率
LEARNING_RATE_DECAY = 0.99 # 学习率的衰减率
REGULARIZATION_RATE = 0.0001 # 描述模型复杂度的正则化项在损失函数中的系数
TRAINING_STEPS = 30000 # 训练的轮数
MOVING_AVERAGE_DECAY = 0.99 # 滑动平均衰减率


#前向传播
def inference(input_tensor, avg_class, weights1, biases1, weights2, biases2):
    # 当没有提供滑动平均类时，直接使用参数当前的取值
 if avg_class is None:
    # 计算隐藏层的前向传播结果，这里使用ReLU激活函数
  layer1 = tf.nn.relu(tf.matmul(input_tensor, weights1) + biases1)
    # 计算输出层的前向传播结果，因为在计算损失函数的时候会一并计算softmax函数，
  # 所以这里不需要加入激活函数，而且不加入softmax不会影响预测结果。因为预测时使用的是不同类别对应节点输出值的相对大小，
  # 有没有softmax对最后的分类结果计算没有影响。于是在整个神经网络传播时可以不加入最后的softmax层。
  return tf.matmul(layer1, weights2) + biases2
  else:
    # 首先使用avg_class.average函数计算得出变量的滑动平均值，然后再计算相应的神经网络前向传播结果。
  layer1 = tf.nn.relu(tf.matmul(input_tensor, avg_class.average(weights1)) + avg_class.average(biases1))
    return tf.matmul(layer1, avg_class.average(weights2)) + avg_class.average(biases2)


#训练过程
def train(mnist):
    # 设置x和y的输入格式
 x = tf.placeholder(tf.float32, [None, INPUT_NODE], name="x-input")
    y_ = tf.placeholder(tf.float32, [None, OUTPUT_NODE], name="y-input")

    # 生成隐藏层参数
 weights1 = tf.Variable(tf.truncated_normal([INPUT_NODE, LAYER1_NODE], stddev=0.1))
    biases1 = tf.Variable(tf.constant(0.1, shape=[LAYER1_NODE]))

    # 生成输出层参数
 weights2 = tf.Variable(tf.truncated_normal([LAYER1_NODE, OUTPUT_NODE], stddev=0.1))
    biases2 = tf.Variable(tf.constant(0.1, shape=[OUTPUT_NODE]))

    # 计算在当前参数下神经网络前向传播结果。这里给出用于计算滑动平均的类为None，所以函数不会使用参数的滑动平均值
 y = inference(x, None, weights1, biases1, weights2, biases2)

    # 定义存储训练轮数的变量。这个变量不需要计算滑动平均值，所以这里制定这个变量为不可训练变量（trainable=true）。在使用tf训练神经网络的
 # 时候一般代表训练轮数的变量指定为不可训练变量
 global_step = tf.Variable(0, trainable=False)

    # 给定滑动平均衰减率和训练轮数，初始化滑动平均类。给定训练轮数变量可以加快训练早起的变量的更新速度
 variable_averages = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)

    # 为所有的可训练变量应用滑动平均类
 variable_averages_op = variable_averages.apply(tf.trainable_variables())

    # 计算使用了滑动平均类后的前向传播结果
 average_y = inference(x, variable_averages, weights1, biases1, weights2, biases2)

    # 计算交叉熵，作为刻画真实值和预测值之间的差距的损失函数
 cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y, labels=tf.argmax(y_, 1))

    # 计算在当前batch中所有样例交叉熵平均值
 cross_entropy_mean = tf.reduce_mean(cross_entropy)

    # 计算L2正则化损失函数
 regularizer = tf.contrib.layers.l2_regularizer(REGULARIZATION_RATE)

    # 计算正则化损失。一般只计算神经网络边上权重的正则化损失，而不使用偏置项
 regularization = regularizer(weights1) + regularizer(weights2)

    # 总损失等于正则化损失和交叉熵损失的和
 loss = cross_entropy_mean + regularization

    # 设置指数衰减的学习率
 learning_rate = tf.train.exponential_decay(
        LEARNING_RATE_BASE,
 global_step,
 mnist.train.num_examples / BATCH_SIZE,
 LEARNING_RATE_DECAY
    )

    # 使用GradientDescentOptimizer优化算法优化损失函数。注意这里损失函数包含了交叉熵损失和L2正则化损失
 train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step=global_step)

    # 训练神经网络模型的时候，每过一遍数据，需要反向传播更新神经网络的参数，又更新每个参数的滑动平均值
 with tf.control_dependencies([train_step, variable_averages_op]):
        train_op = tf.no_op(name="train")

    #
 correct_prediction = tf.equal(tf.argmax(average_y, 1), tf.argmax(y_, 1))

    #
 accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

    # 初始化会话，开始训练
 with tf.Session() as sess:
        tf.initialize_all_variables().run()
        validate_feed = {x: mnist.validation.images, y_: mnist.validation.labels}
        test_feed = {x: mnist.test.images, y_: mnist.test.labels}
        for i in range(TRAINING_STEPS):
            if i % 1000 == 0:
                validate_acc = sess.run(accuracy, feed_dict=validate_feed)
                print("经过了 %d 步训练，使用平均模型，验证数据准确度是 %g" % (i, validate_acc))
            xs, ys = mnist.train.next_batch(BATCH_SIZE)
            sess.run(train_op, feed_dict={x: xs, y_: ys})
        test_acc = sess.run(accuracy, feed_dict=test_feed)
        print("经过了 %d 步训练，使用平均模型，测试数据的准确度是 %g" % (TRAINING_STEPS, test_acc))


def main(argv=None):
    # 导入数据，每一条格式为两个一维数组，size为10的数字标记和size为784的图片
 mnist = input_data.read_data_sets("d:/mnist/data", one_hot=True)
    print("训练数据大小：", mnist.train.num_examples)
    print("验证数据大小：", mnist.validation.num_examples)
    print("测试数据大小：", mnist.test.num_examples)
    train(mnist)


if __name__ == '__main__':
    tf.app.run()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

import os

import tensorflow as tf

from tensorflow.examples.tutorials.mnist import input_data

os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'

# mnist 数据集参数

INPUT_NODE = 784 # 输入层节点数，也就是图片的像素数

OUTPUT_NODE = 10 # 输出层节点数，也就是属于0到9的那个数字

# 神经网络参数

LAYER1_NODE = 500 # 隐藏层节点数，这里只有一个隐藏层

BATCH_SIZE = 100 # 一个训练batch中数据个数

LEARNING_RATE_BASE = 0.8 # 基础学习率

LEARNING_RATE_DECAY = 0.99 # 学习率的衰减率

REGULARIZATION_RATE = 0.0001 # 描述模型复杂度的正则化项在损失函数中的系数

TRAINING_STEPS = 30000 # 训练的轮数

MOVING_AVERAGE_DECAY = 0.99 # 滑动平均衰减率

#前向传播

def inference(input_tensor, avg_class, weights1, biases1, weights2, biases2):

# 当没有提供滑动平均类时，直接使用参数当前的取值

if avg_class is None:

# 计算隐藏层的前向传播结果，这里使用ReLU激活函数

layer1 = tf.nn.relu(tf.matmul(input_tensor, weights1) + biases1)

# 计算输出层的前向传播结果，因为在计算损失函数的时候会一并计算softmax函数，

# 所以这里不需要加入激活函数，而且不加入softmax不会影响预测结果。因为预测时使用的是不同类别对应节点输出值的相对大小，

# 有没有softmax对最后的分类结果计算没有影响。于是在整个神经网络传播时可以不加入最后的softmax层。

return tf.matmul(layer1, weights2) + biases2

else:

# 首先使用avg_class.average函数计算得出变量的滑动平均值，然后再计算相应的神经网络前向传播结果。

layer1 = tf.nn.relu(tf.matmul(input_tensor, avg_class.average(weights1)) + avg_class.average(biases1))

return tf.matmul(layer1, avg_class.average(weights2)) + avg_class.average(biases2)

#训练过程

def train(mnist):

# 设置x和y的输入格式

x = tf.placeholder(tf.float32, [None, INPUT_NODE], name="x-input")

y_ = tf.placeholder(tf.float32, [None, OUTPUT_NODE], name="y-input")

# 生成隐藏层参数

weights1 = tf.Variable(tf.truncated_normal([INPUT_NODE, LAYER1_NODE], stddev=0.1))

biases1 = tf.Variable(tf.constant(0.1, shape=[LAYER1_NODE]))

# 生成输出层参数

weights2 = tf.Variable(tf.truncated_normal([LAYER1_NODE, OUTPUT_NODE], stddev=0.1))

biases2 = tf.Variable(tf.constant(0.1, shape=[OUTPUT_NODE]))

# 计算在当前参数下神经网络前向传播结果。这里给出用于计算滑动平均的类为None，所以函数不会使用参数的滑动平均值

y = inference(x, None, weights1, biases1, weights2, biases2)

# 定义存储训练轮数的变量。这个变量不需要计算滑动平均值，所以这里制定这个变量为不可训练变量（trainable=true）。在使用tf训练神经网络的

# 时候一般代表训练轮数的变量指定为不可训练变量

global_step = tf.Variable(0, trainable=False)

# 给定滑动平均衰减率和训练轮数，初始化滑动平均类。给定训练轮数变量可以加快训练早起的变量的更新速度

variable_averages = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)

# 为所有的可训练变量应用滑动平均类

variable_averages_op = variable_averages.apply(tf.trainable_variables())

# 计算使用了滑动平均类后的前向传播结果

average_y = inference(x, variable_averages, weights1, biases1, weights2, biases2)

# 计算交叉熵，作为刻画真实值和预测值之间的差距的损失函数

cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y, labels=tf.argmax(y_, 1))

# 计算在当前batch中所有样例交叉熵平均值

cross_entropy_mean = tf.reduce_mean(cross_entropy)

# 计算L2正则化损失函数

regularizer = tf.contrib.layers.l2_regularizer(REGULARIZATION_RATE)

# 计算正则化损失。一般只计算神经网络边上权重的正则化损失，而不使用偏置项

regularization = regularizer(weights1) + regularizer(weights2)

# 总损失等于正则化损失和交叉熵损失的和

loss = cross_entropy_mean + regularization

# 设置指数衰减的学习率

learning_rate = tf.train.exponential_decay(

LEARNING_RATE_BASE,

global_step,

mnist.train.num_examples / BATCH_SIZE,

LEARNING_RATE_DECAY

)

# 使用GradientDescentOptimizer优化算法优化损失函数。注意这里损失函数包含了交叉熵损失和L2正则化损失

train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step=global_step)

# 训练神经网络模型的时候，每过一遍数据，需要反向传播更新神经网络的参数，又更新每个参数的滑动平均值

with tf.control_dependencies([train_step, variable_averages_op]):

train_op = tf.no_op(name="train")

correct_prediction = tf.equal(tf.argmax(average_y, 1), tf.argmax(y_, 1))

accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

# 初始化会话，开始训练

with tf.Session() as sess:

tf.initialize_all_variables().run()

validate_feed = {x: mnist.validation.images, y_: mnist.validation.labels}

test_feed = {x: mnist.test.images, y_: mnist.test.labels}

for i in range(TRAINING_STEPS):

if i % 1000 == 0:

validate_acc = sess.run(accuracy, feed_dict=validate_feed)

print("经过了 %d 步训练，使用平均模型，验证数据准确度是 %g" % (i, validate_acc))

xs, ys = mnist.train.next_batch(BATCH_SIZE)

sess.run(train_op, feed_dict={x: xs, y_: ys})

test_acc = sess.run(accuracy, feed_dict=test_feed)

print("经过了 %d 步训练，使用平均模型，测试数据的准确度是 %g" % (TRAINING_STEPS, test_acc))

def main(argv=None):

# 导入数据，每一条格式为两个一维数组，size为10的数字标记和size为784的图片

mnist = input_data.read_data_sets("d:/mnist/data", one_hot=True)

print("训练数据大小：", mnist.train.num_examples)

print("验证数据大小：", mnist.validation.num_examples)

print("测试数据大小：", mnist.test.num_examples)

train(mnist)

if __name__ == '__main__':

tf.app.run()

分类: 技术，让世界更美好。标签:

流式计算框架比较

2018年3月9日 admin 评论已被关闭

SparkStreaming：适合可以容忍秒级别延迟，大吞吐量计算，社区完善，和spark集成度高 Stor […]

分类: 技术，让世界更美好。标签:

【知识管理】个人知识树【施工中】

2018年3月7日 admin 评论已被关闭

logic 语言 java Jvm 加载机制类的生命周期加载：加载二进制字节流验证：对class的字节流 […]

分类: 技术，让世界更美好。标签:

【hadoop】yarn知识小结【施工中】

2018年3月5日 admin 评论已被关闭

yarn是hadoop2以上采用的分布式计算框架，对比hadoop1的分布式计算，yarn拥有更强大的资源管理 […]

分类: 技术，让世界更美好。标签:

【hadoop】hdfs知识小结

2018年3月5日 admin 评论已被关闭

大数据生态圈，hadoop是整个生态的基础，而hdfs是其分布式文件系统，是学习大数据的起点。

1.概况

Hadoop分布式文件系统（HDFS）是一种分布式文件系统，设计用于在商品硬件上运行。它与现有的分布式文件系统有许多相似之处。但是，与其他分布式文件系统的差异很大。HDFS具有高度容错能力，旨在部署在低成本硬件上。HDFS提供对应用程序数据的高吞吐量访问，适用于具有大型数据集的应用程序。HDFS放宽了一些POSIX要求来启用对文件系统数据的流式访问。

分类: BigData 标签:

【zookeeper】zookeeper知识小结

2018年3月5日 admin 评论已被关闭

最近想整理下自己的大数据生态知识点，就先从zookeeper开始。说实话，我并没有使用zookeeper进行开发（如果把spark streamning 的kafka的offset存进zookeeper也算的话）。但是zookeeper作为大数据生态的中要的一员，自己负责搭建和维护大数据集群，多多少少都绕不过zookeeper。

2.zookeeper是什么？

我不喜欢用比喻，因为比喻虽然让人更容易解释新的知识和形象，但比喻也会损失一部分的信息不利于理解本质，所以这里就不用动物管理员那套说法了。

官方的说法是：分布式应用程序的分布式协调服务（A Distributed Coordination Service for Distributed Applications），zookeeper它为分布式应用程序提供同步、配置维护以及组和命名功能，应用程序通过zookeeper实现更高级的服务。

zookeeper的目的是为了减轻分布式服务需要重头做分布式服务的的责任（重复发明轮子）。

究其本质，zookeeper是一套通知机制 + 文件系统。

分类: BigData, 技术，让世界更美好。标签:

【Spark MLib】Spark MLib用于机器学习的基本类型

2018年1月15日 admin 评论已被关闭

1.Local Vector(本地向量)

本地向量由基于零的整型索引和双精度浮点型组成的数据结构，存储在单台机器上。本地向量分为dense vector（密集向量）和sparse vector（稀疏向量）。

dense vector:直接使用浮点数组表示向量。
sparse vector:通过整型索引和和其浮点数值表示。
(1.0, 0.0, 3.0)表示为dense vector为[1.0, 0.0, 3.0] ，表示为sparse vector为(3, [0, 2], [1.0, 3.0])，其中3代表向量的长度，0和2分别指索引位置。

分类: 技术，让世界更美好。标签:

星尘—程序猿的小站

【自然语言处理】中文分词

【自然语言处理】n元语法（n-gram）

阿里算法策略简介

MNIST

流式计算框架比较

【知识管理】个人知识树【施工中】

【hadoop】yarn知识小结【施工中】

【hadoop】hdfs知识小结

【zookeeper】zookeeper知识小结

【Spark MLib】Spark MLib用于机器学习的基本类型

版权声明

分类目录

Categories

Blogroll

Archives

Meta