IT笔记整理

NumPy 创建数组

ndarray 数组除了可以使用底层 ndarray 构造器来创建外，也可以通过以下几种方式来创建

下面是一个创建空数组的实例

import numpy as np 
x = np.empty([3,2], dtype = int) 
print (x)

import numpy as np
 
# 默认为浮点数
x = np.zeros(5) 
print(x)
 
# 设置类型为整数
y = np.zeros((5,), dtype = np.int) 
print(y)
 
# 自定义类型
z = np.zeros((2,2), dtype = [('x', 'i4'), ('y', 'i4')])  
print(z)

import numpy as np
 
# 默认为浮点数
x = np.ones(5) 
print(x)
 
# 自定义类型
x = np.ones([2,2], dtype = int)
print(x)

如果有想学习本课程的同学或者在学习的过程中遇到技术问题，可以加微：InitialHeart2021 进行互相学习和讨论

百万大数据架构师第一期超推荐P8
高级大数据开发13期
基于Flink+Hudi构建企业万亿级云上实时数据湖教程
Spark3+Clickhouse+Hadoop大数据实战课程
Flink+ClickHouse 玩转企业级实时大数据开发 
Spark+ES+ClickHouse 构建DMP用户画像
大数据实时分析利器：ClickHouse实战
大数据高薪训练营
大数据开发工程师
大数据高级开发工程师第一期
大数据精英班第二期
数据运维第一期
大数据精英班三期 
大数据运维第二期
大数据高级开发工程师
数据研发工程师第一期
企业级大数据资深研发工程师第一期P6
大数据架构师第一期P7
大数据训练营53期
大数据高级开发工程师第8期
Flink+ClickHouse构建亿级电商用户画像平台
基于Flink+ClickHouse构建亿级电商实时数据分析平台（PC、移动、小程序）
ClickHouse大数据分析技术与实战
大数据15期
大数据就业班202006期
【后厂理工学院】滴滴大数据资深开发工程师
大数据第十期
大数据第九期
大数据第五期直播 + 录播
2019年若泽大数据第三期重实战
2019年6月尚硅谷大数据线下班
优效学院高端大数据课程精英训练营二班
八斗学院大数据十三期
优效学院高端大数据课程精英训练营一班
光环国际光环国际大数据
山硅谷尚硅谷大数据就业班1911
大数据十一期
大数据十二期
大数据Hadoop高性能企业专家实战视频课程
基于Hadoop技术实现的离线电商分析平台
 [迪伦][CDH5&Hadoop高阶管理及调优课程]
Spark全面精讲（基于Spark2版本+含Spark调优+超多案例）
Spark企业级实战项目：道路交通实时流量监控预测系统
Spark企业级实战项目：知名手机厂商用户行为实时分析系统
Spark企业级项目实战：爱奇艺用户行为实时分析系统
Spark 2.0从入门到精通：Scala编程、大数据开发、上百个实战案例、内核源码深度剖析
Spark 2.0大型项目实战：移动电商app交互式数据分析平台（大数据高端课程）
深入浅出Spark机器学习实战（用户行为分析）
Spark企业级大数据项目实战
Spark进阶 大数据离线与实时项目实战
Spark Streaming技术社区网站广告实时点击分析系统
Spark2.x+协同过滤算法，开发企业级个性化推荐系统
Flink大数据项目实战
基于Flink流处理的动态实时电商实时分析系统
基于Flink流处理的动态实时亿级全端用户画像系统
Flink入门及实战（上、下）-2018年最新
新一代大数据计算引擎 Flink从入门到实战
Flink1.8实时数仓项目实战
Flink1.8实时电商运营项目实战
基于大数据体系构建数据仓库
基于Storm流计算天猫双十一作战室项目实战（Storm Kafka HBase Highchats）
大数据项目实战之Python金融应用编程(数据分析、定价与量化投资)
深入浅出大数据挖掘技术
基于大数据技术推荐系统算法案例实战教程
大数据DMP画像系统
NEXT学院-剑指大数据面试
Java互联网高级架构师【马士兵教育】课程合集
Java高级互联网架构师一班
Java高级互联网架构师二班
Java高级互联网架构师三班
Java高级互联网架构师四班 P8
Java高级互联网架构师五班
Java高级互联网架构师六班
Java高级互联网架构师七班
更多课程点击链接查看，持续更新中...
JAVA互联网架构师专题/分布式/高并发/微服务第四期
小马哥的 Java 项目实战营第一期
Java工程师高薪训练营第五期
架构实战营第一期
架构师训练营第一期
Java进阶训练营第一期
百万年薪架构师第五期P8
springboot2.0企业应用中台实战之权限统一管理与应用统一授权
BAT公司海量数据分页秒级查询落地方案实现
Spring Cloud / Alibaba 微服务架构实战
关于即时通讯架构的一切
蒋德钧Redis集群班
Java架构师训练营第1期
基于电商业务的企业级大中台从设计到实现(第一阶段)第一阶段 ~ 
基于电商业务的企业级大中台从设计到实现(第一阶段) 
基于电商业务的企业级大中台从设计到实现(第二阶段) 
基于电商业务的企业级大中台从设计到实现(第三阶段) 
基于电商业务的企业级大中台从设计到实现(第四阶段)
基于电商业务全链路数据中台落地方案（全渠道、全环节、全流程）
Java架构师直通车
Java全栈工程师
百万年薪架构师第二期P8
Java架构师第七期
Java资深研发工程师第一期P6
Java架构师第一期P7
从0开始用Java做智慧农业物联网
JavaEE在职加薪课
浅入深出ElasticSearch构建高性能搜索架构
Spring Boot框架开发详解
SpringCloud开发实战详解
剑指Java面试-Offer直通车
互联网Java工程师面试突击三季全
图灵学院java面试专属
从无到有构建大型电商微服务架构（第一阶段)
从无到有构建大型电商微服务架构（第二阶段）
从无到有构建大型电商微服务架构（第三阶段）
Socket网络编程进阶与实战
精通并发与netty视频教程
廖雪峰Java架构师第一期
享学架构师第一期
JAVA开发大型互联网企业架构专题第一期
高级软件架构师实战培训阶段三
高级软件架构师实战培训阶段二
高级软件架构师实战培训阶段一
深入大数据架构师之路，问鼎40万年薪
高端JAVA架构师课程精英训练营二班
Java架构师VIP课程一期
百万年薪架构师第一期
JAVA开发大型互联网企业架构专题第二期
Java互联网架构师二期
百万年薪架构第二期
JAVA开发大型互联网企业架构专题第三期
Java互联网架构师三期
人工智能精选
Paper年度会员
AlgoCasts算法视频：用心做好每一个算法视频
NLP自然语言处理训练营第八期高阶
机器学习高阶训练营第四期 高阶
京东NLP企业项目实战训练营第三期 高端
数据挖掘第二期
AI量化交易培养计划
数据分析实战训练营 
网易数据分析
动手学关系抽取-知识图谱基础篇
AI算法落地与项目部署实践
自然语言处理集训营第一期
机器学习训练营  高端
数据科学之企业级数据仓库
多传感器融合定位第一期
推荐系统算法工程师第二期
京东NLP企业项目实战训练营第一期
NLP自然语言处理训练营第五期高阶
搭建企业级知识图谱系统
光环人工智能线下班19期
京东商业数据分析师实战训练营
腾讯数据分析
推荐系统算法工程师第一期
首席AI架构师第一期
NLP自然语言处理训练营第七期  高阶
机器学习高阶训练营第一期高阶
语音识别从入门到精通第一期
语音信号处理第一期
语音算法：前沿与应用第一期
金融风控项目第一期超推荐
自然语言处理动手学Bert文本分类
自然语言处理之动手学NER
人工智能系列课程2020版
Python机器学习实训营
计算机视觉-物体检测实战
深度学习-行人重识别实战
深度学习经典论文与开源项目实战
深度学习模型部署与剪枝优化实例
2020超推荐2020 + 2019 + 2018打包
语音识别实战 第二期
无人机自主飞行实战入门
从零起步实战slam
智能问答系统实战
关键点检测实战
从零实战目标检测
带打kaggle比赛 第一期
视觉目标跟踪实战

import os

os.chdir('C:/Users/lsj/Desktop')

arr = np.random.rand(5, 5)
np.save('array_data.npy', arr)


arr_load = np.load('array_data.npy')
print(arr_load)

arr = np.random.rand(5, 5)
np.savetxt('arrat_data.txt', arr, delimiter=',')



import collections
import os
import sys
import numpy as np

start_token = 'G'
end_token = 'E'

def process_poems(file_name):
    # 诗集
    poems = []
    with open(file_name, 'r', encoding='utf-8') as f:
        for line in f.readlines():
            try:
                title, content = line.strip().split(':')
                content = content.replace(' ', '')
                if '_' in content or '(' in content or '（' in content or '《' in content or '[' in content or start_token in content or end_token in content:
                    continue
                if len(content) < 5 or len(content) > 79:
                    continue
                content = start_token + content + end_token
                poems.append(content)
            except ValueError as e:
                pass
    # 按诗的字数排序
    poems = sorted(poems, key=lambda l: len(line))

    # 统计每个字出现的次数
    all_words = []
    for poem in poems:
        all_words += [word for word in poem]
    # 这里根据包含了每个字对应的频率
    counter = collections.Counter(all_words)
    count_pairs = sorted(counter.items(), key=lambda x: -x[1])
    words, _ = zip(*count_pairs)

    # 取前多少个常用字
    words = words[:len(words)] + (' ',)
    # 每个字映射为一个数字ID
    word_int_map = dict(zip(words, range(len(words))))
    poems_vector = [list(map(lambda word: word_int_map.get(word, len(words)), poem)) for poem in poems]
    return poems_vector, word_int_map, words

def generate_batch(batch_size, poems_vec, word_to_int):
    n_chunk = len(poems_vec) // batch_size
    x_batches = []
    y_batches = []
    for i in range(n_chunk):
        start_index = i * batch_size
        end_index = start_index + batch_size

        batches = poems_vec[start_index: end_index]
        # 找到这个batch 的所有poem 中最长的poem的长度
        length = max(map(len, batches))
        # 填充一个这么大小的空batch，空的地方放空格对应的index标号
        x_data = np.full((batch_size, length), word_to_int[' '], np.int32)
        for row in range(batch_size):
            # 每一行就是一首诗，在原本的长度上把诗还原上去
            x_data[row, :len(batches[row])] = batches[row]
        y_data = np.copy(x_data)
        # y的话就是x向左边也就是前面移动一个
        y_data[: ,:-1] = x_data[: ,1:]
        """
            x_data             y_data
            [6,2,4,6,9]       [2,4,6,9,9]
            [1,4,2,8,5]       [4,2,8,5,5]
        """
        x_batches.append(x_data)
        y_batches.append(y_data)
    return x_batches, y_batches


import tensorflow as tf
import numpy as np

def rnn_model(model, input_data, output_data, vocab_size, run_size=128, num_layers=2, batch_size=64, learning_rate=0.01):
    """
    :param model: model class
    :param input_data: input data placeholder
    :param output_data: output data placeholder
    :param vocab_size:
    :param rnn_size:
    :param num_layers:
    :param batch_size:
    :param learning_rate:
    :return:
    """
    end_points = {}
    # 构建RNN基本单元RNNCell
    if model == 'rnn':
        cell_fun = tf.contrib.rnn.BasicRNNCell
    elif model == 'gru':
        cell_fun = tf.contrib.rnn.GRUCell
    elif model == 'lstm':
        cell_fun = tf.contrib.rnn.BasicLSTMCell

    cell = cell_fun(run_size, state_is_tuple=True)
    # 构建堆叠rnn，这里选用2层的rnn
    cell = tf.contrib.rnn.MultiRNNCell([cell] * num_layers, state_is_tuple=True)
    # 如果是训练模式，output_data不为None，则初始状态shape为[batch_size * rnn_size]
    # 如果是生成模式，output_data为None， 则初始状态shape为[1， rnn_size]
    if output_data is not None:
       initial_state = cell.zero_state(batch_size, tf.float32)
    else:
       initial_state = cell.zero_state(1, tf.float32)
    # 构建隐层
    with tf.device('/cpu:0'):
        embedding = tf.get_variable('embedding', initializer=tf.random_uniform([vocab_size+1, run_size], -1.0, 1.0))
        inputs = tf.nn.embedding_lookup(embedding, input_data)
    # [batch_size, ?, rnn_size] = [64, ?, 128]
    outputs, last_state = tf.nn.dynamic_rnn(cell, inputs, initial_state=initial_state)
    output = tf.reshape(outputs, [-1, run_size])

    weights = tf.Variable(tf.truncated_normal([run_size, vocab_size + 1]))
    bias = tf.Variable(tf.zeros(shape=[vocab_size + 1]))
    logits = tf.nn.bias_add(tf.matmul(output, weights), bias=bias)

    if output_data is not None:
        # output_data must be one-hot encode
        labels = tf.one_hot(tf.reshape(output_data, [-1]), depth=vocab_size+1)
        # shuould be [?， vocab_size + 1 ]

        loss = tf.nn.softmax_cross_entropy_with_logits(labels=labels, logits=logits)
        # loss shape should be [？, vocab_size + 1 ]
        total_loss = tf.reduce_mean(loss)
        train_op = tf.train.AdamOptimizer(learning_rate).minimize(total_loss)

        end_points['initial_state'] = initial_state
        end_points['output'] = output
        end_points['train_op'] = train_op
        end_points['total_loss'] = total_loss
        end_points['loss'] = loss
        end_points['last_state'] = last_state
    else:
        prediction = tf.nn.softmax(logits)
        end_points['initial_state'] = initial_state
        end_points['last_state'] = last_state
        end_points['prediction'] = prediction
    return end_points



import collections
import os
import sys
import numpy as np
import tensorflow as tf
from models.model import rnn_model
from dataset.poems import process_poems, generate_batch
import heapq

# main 函数的参数
tf.app.flags.DEFINE_integer('batch_size',64,'batch size.')
tf.app.flags.DEFINE_float('learning_rate', 0.01, 'learning rate')

# set this to 'main.py relative path
tf.app.flags.DEFINE_string('checkpoints_dir', os.path.abspath('./checkpoints/poems/'), 'checkpoints save path.')
tf.app.flags.DEFINE_string('file_path', os.path.abspath('./dataset/data/poems.txt'), 'file name of poems.')

tf.app.flags.DEFINE_string('model_prefix','poems','model save prefix.')
tf.app.flags.DEFINE_integer('epochs',50,'train how many epochs.')

FLAGS = tf.app.flags.FLAGS

start_token = 'G'
end_token = 'E'

def run_training():
    if not os.path.exists(os.path.dirname(FLAGS.checkpoints_dir)):
        os.mkdir(os.path.dirname(FLAGS.checkpoints_dir))
    if not os.path.exists(FLAGS.checkpoints_dir):
        os.mkdir(FLAGS.checkpoints_dir)

    # 处理数据集
    poems_vector, word_to_int, vocabularies = process_poems(FLAGS.file_path)
    # 生成batch
    batches_inputs, batches_outputs = generate_batch(FLAGS.batch_size, poems_vector, word_to_int)

    input_data = tf.placeholder(tf.int32, [FLAGS.batch_size, None])
    output_targets = tf.placeholder(tf.int32, [FLAGS.batch_size, None])

    end_points = rnn_model(model='lstm', input_data=input_data, output_data=output_targets, vocab_size=len(vocabularies),
                           run_size=128, num_layers = 2, batch_size = 64, learning_rate = FLAGS.learning_rate)

    saver = tf.train.Saver(tf.global_variables())
    init_op = tf.group(tf.global_variables_initializer(), tf.local_variables_initializer())

    with tf.Session() as sess:
        # sess = tf_debug.LocalCLIDebugWrapperSession(sess=sess)
        # sess.add_tensor_filter('has_inf_or_nan', tf.debug.has_inf_or_nan)
        sess.run(init_op)
        start_epoch = 0
        checkpoint = tf.train.latest_checkpoint(FLAGS.checkpoints_dir)
        if checkpoint:
            saver.restore(sess, checkpoint)
            print("[INFO] restore from the checkpoint {0}".format(checkpoint))
            start_epoch += int(checkpoint.split('-')[-1])
        print('[INFO] start training...')
        try:
            for epoch in range(start_epoch, FLAGS.epochs):
                n = 0
                n_chunk = len(poems_vector) // FLAGS.batch_size
                for batch in range(n_chunk):
                    loss, _, _ = sess.run([
                        end_points['total_loss'], end_points['last_state'], end_points['train_op']
                    ], feed_dict={input_data: batches_inputs[n], output_targets:batches_outputs[n]})
                    n += 1
                    print('[INFO] Epoch:%d, batch: %d, training loss: %.6f'%(epoch, batch, loss))
            if epoch % 6 == 0:
                # saver.save(sess, './model/', global_step = epoch)
                saver.save(sess, os.path.join(FLAGS.checkpoints_dir, FLAGS.model_prefix), global_step=epoch)
        except KeyboardInterrupt:
            # 如果Ctrl + C 中断，保存 checkpoint
            print('[INFO] Interrupt manually，try saving checkpoint for now ...')
            saver.save(sess, os.path.join(FLAGS.checkpoints_dir, FLAGS.model_prefix), global_step=epoch)
            print('[INFO] Last epoch were saved，next time will staert from epoch {}'.format(epoch))

def to_word(predict, vocabs):
    t = np.cumsum(predict)
    s = np.sum(predict)
    sample = int(np.searchsorted(t, np.random.rand(1)*s))
    if sample > len(vocabs):
        sample = len(vocabs) - 1
    return vocabs[sample]

def gen_poem(begin_word):
    batch_size = 1
    print('[INFO] loading corpus from %s'%(FLAGS.file_path))
    poems_vector,word_int_map, vocabularies = process_poems(FLAGS.file_path)
    input_data = tf.placeholder(tf.int32, [batch_size, None])
    end_points = rnn_model(model='lstm', input_data=input_data, output_data=None, vocab_size=len(vocabularies),
                           run_size=128, num_layers=2, batch_size=64, learning_rate=FLAGS.learning_rate)
    saver = tf.train.Saver(tf.global_variables())
    init_op = tf.group(tf.global_variables_initializer(), tf.local_variables_initializer())

    with tf.Session() as sess:
        sess.run(init_op)
        checkpoint = tf.train.latest_checkpoint(FLAGS.checkpoints_dir)
        # saver.restore(sess, checkpoint)
        saver.restore(sess, './checkpoints/poems/-24')

        x = np.array([list(map(word_int_map.get, start_token))])

        [predict, last_state ]= sess.run([end_points['prediction'], end_points['last_state']], feed_dict={input_data: x})

        # 如果指定开始的字
        if begin_word:
            word = begin_word
        # 如果不指定开始的字，就按根据start_token生成第一个字
        else:
            word = to_word(predict, vocabularies)
        poem = ''
        while word != end_token:
            print('runing   死循环？？')
            poem += word
            x = np.zeros((1, 1))
            # 比如：指定第一个字为“白”，则x就为[[36]]，即batch_size为1，并且poems_length为1，生下第一个字
            x[0, 0] = word_int_map[word]
            # 传入input_data，此时没有output_data即为生成模式，并且传入初始状态为训练结束的状态
            # state_shape 为[1, run_size]
            [predict, last_state] = sess.run([end_points['prediction'], end_points['last_state']], feed_dict={input_data:x, end_points['initial_state']: last_state})
            # 根据预测结果生成对应的字
            word = to_word(predict, vocabularies)
        return poem

def pretty_print_poem(poem):
    poem_sentences = poem.split('。')
    for s in poem_sentences:
        if s != '' and len(s) > 10:
            print(s + '。')

def main(is_train):
    if is_train:
        print('[INFO] train tang poem....')
        run_training()
    else:
        print('[INFO] write tang poem....')
        begin_word = input('输入起始字：')
        poem2 = gen_poem(begin_word)
        pretty_pretty_print_poem(poem2)

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





import argparse

def parse_args():
    parser = argparse.ArgumentParser(description='Intelligence Poem and Lyric Writer.')

    help_ = 'you can set this value in terminal --write value can be poem or lyric'
    parser.add_argument('-w', '--write', default='poem', choices=['poem', 'lyric'], help=help_)

    help_ = 'choose to train or generate'
    parser.add_argument('--train', dest='train', action='store_true', help=help_)
    parser.add_argument('--no-train', dest='train', action='store_false', help=help_)
    # parser.set_defaults('--no-train', dest='train', action='store_false', help=help_)

    # 第一步 训练模型：训练唐诗生成模型：直接在pyCharm中Run main
    # parser.set_defaults(train=True)

    # 第二步 验证模型：生成唐诗：将main()函数中的train参数改为False
    parser.set_defaults(train=False)

    args_ = parser.parse_args()
    return args_

if __name__ =='__main__':
    args = parse_args()
    if args.write == 'poem':
        from inference import tang_poems
        if args.train:
            tang_poems.main(True)
        else:
            tang_poems.main(False)
    elif args.write == 'lyric':
        from inference import song_lyrics
        print(args.train)
        if args.train:
            song_lyrics.main(True)
        else:
            song_lyrics.main(False)
    else:
        print('[INFO] write option can only be poem or lyric right now.')

如果有想学习本课程的同学或者在学习的过程中遇到技术问题，可以加微：InitialHeart2021 进行互相学习和讨论