【建议收藏】数据挖掘基础、人工智能必会内容

 # 画出温度变化图

    
 import random
    
  
    
 # 准备x, y坐标的数据
    
 x = range(60)
    
 y_shanghai = [random.uniform(15, 18) for i in x]
    
 # 增加北京的温度数据
    
 y_beijing = [random.uniform(1, 3) for i in x]
    
  
    
 # 1）创建画布
    
 plt.figure(figsize=(20, 8), dpi=80)
    
  
    
 # 2）绘制折线图
    
 # plt.plot(x, y_shanghai)
    
 plt.plot(x, y_shanghai, label="上海")
    
 # 使用多次plot可以画多个折线
    
 plt.plot(x, y_beijing, color='r', linestyle='--', label="北京")
    
  
    
 # 显示图例
    
 plt.legend(loc="best")
    
  
    
 # 增加以下两行代码
    
 # 构造x轴刻度标签
    
 x_ticks_label = ["11点{}分".format(i) for i in x]
    
 # 构造y轴刻度
    
 y_ticks = range(40)
    
  
    
 # 修改x,y轴坐标的刻度显示
    
 plt.xticks(x[::5], x_ticks_label[::5])
    
 plt.yticks(y_ticks[::5])
    
  
    
 # 添加网格显示
    
 plt.grid(True, linestyle='--', alpha=0.5)
    
  
    
 # 添加x轴、y轴描述信息及标题
    
 plt.xlabel("时间")
    
 plt.ylabel("温度")
    
 plt.title("中午11点0分到12点之间的温度变化图示")
    
  
    
 # 3）显示图像
    
 plt.show()

 arr1 = np.array([[1, 2, 3, 2, 1, 4], [5, 6, 1, 2, 3, 1]])

    
  
    
 arr2 = np.array([[1], [3]])

 data[(data['p_change'] > 2) & (data['open'] > 15)]

    
  
    
 data.query("p_change > 2 & turnover > 15")

 import pandas as pd

    
 from mpl_finance import candlestick_ochl
    
 import matplotlib.pyplot as plt
    
 from matplotlib.pylab import date2num
    
  
    
 # 数据读取
    
 stock_day = pd.read_csv("./stock_day/stock_day.csv")
    
  
    
 # 按时间顺序排列数据
    
 stock_day = stock_day.sort_index()
    
  
    
 # 准备ax
    
 fig, axes = plt.subplots(nrows=1, ncols=1, figsize=(13, 8), dpi=100)
    
  
    
 # 准备quotes
    
 # 处理time字段
    
 # 将时间索引类型转换成Pandas默认的类型
    
 stock_day.index = pd.to_datetime(stock_day.index)
    
 # 将时间转换成日K线绘制要求的浮点型
    
 stock_day['time'] = date2num(stock_day.index)
    
 # 索引sequence
    
 day_k = stock_day[['time', 'open', 'close', 'high', 'low']]
    
  
    
 # 绘制k线图
    
 candlestick_ochl(axes, day_k.values[:30], width=0.4, colorup='r', colordown='g')
    
  
    
 # x刻度设置为日期
    
 axes.xaxis_date()
    
  
    
 # 添加网格
    
 plt.grid(linestyle="--", alpha=0.5)
    
  
    
 # 显示图像
    
 plt.show()

 import talib

    
  
    
 def init(context):
    
     # 在context中保存全局变量
    
     # 设置股票池
    
     context.stocks = index_components("000300.XSHG")
    
     # 设置周期
    
     context.short = 12
    
     context.long = 26
    
     context.signal = 9
    
     context.observe = 100
    
  
    
 # before_trading此函数会在每天策略交易开始前被调用，当天只会被调用一次
    
 def before_trading(context):
    
     pass
    
  
    
  
    
 # 你选择的证券的数据更新将会触发此段逻辑，例如日或分钟历史数据切片或者是实时数据切片更新
    
 def handle_bar(context, bar_dict):
    
     # 开始编写你的主要的算法逻辑
    
     for stock in context.stocks:
    
     # print(stock)
    
     # 获取历史收盘价
    
     price = history_bars(stock, context.observe, "1d", "close")
    
  
    
     # 计算MACD指标
    
     dif, dea, bar = talib.MACD(price, context.short, context.long, context.signal)
    
     # print(dif)
    
     #     双均线策略：
    
 #         卖出：
    
 #             昨天 快线 > 慢线 并且 今天 快线 < 慢线
    
     if dif[-2] > dea[-2] and dif[-1] < dea[-1]:
    
         if context.portfolio.positions[stock].quantity > 0:
    
             order_target_percent(stock, 0)
    
 #         买入：
    
 #             昨天 快线 < 慢线 并且 今天 快线 > 慢线
    
     if dif[-2] < dea[-2] and dif[-1] > dea[-1]:
    
         order_target_percent(stock, 0.1)
    
  
    
 # after_trading函数会在每天交易结束后被调用，当天只会被调用一次
    
 def after_trading(context):
    
     pass

 # 获取这两个因子数据

    
  
    
 q = query(fundamentals.eod_derivative_indicator.pb_ratio,
    
  
    
          fundamentals.eod_derivative_indicator.market_cap)
    
  
    
  
    
  
    
 # 获取的是某一天的横截面数据
    
  
    
 factor = get_fundamentals(q, entry_date="2018-01-03")[:, 0, :]
    
  
    
  
    
  
    
 # 先对pb_ratio进行去极值标准化处理
    
  
    
 factor['pb_ratio'] = mad(factor['pb_ratio'])
    
  
    
 factor['pb_ratio'] = stand(factor['pb_ratio'])
    
  
    
  
    
  
    
 # 确定回归的数据
    
  
    
 # x：市值
    
  
    
 # y : 因子数据
    
  
    
 x = factor['market_cap'].reshape(-1, 1)
    
  
    
 y = factor['pb_ratio']
    
  
    
  
    
  
    
 # 建立回归方程并预测
    
  
    
 lr = LinearRegression()
    
  
    
 lr.fit(x, y)
    
  
    
 y_predict = lr.predict(x)
    
  
    
  
    
  
    
 # 去除线性的关系，留下误差作为该因子的值
    
  
    
 factor['pb_ratio'] = y - y_predict

 import scipy.stats as st

    
 import pandas as pd
    
 import numpy as np
    
 # 1、获取因子暴露度
    
 # 1）获取财务数据
    
 stocks = industry("C39")
    
 q = query(fundamentals.eod_derivative_indicator.pe_ratio).filter(
    
 fundamentals.stockcode.in_(stocks))
    
 fund = get_fundamentals(q, entry_date="20170105")[:, 0, :]
    
 def med_method(factor):
    
   # 1、找到MAD值
    
   med = np.median(factor)
    
   distance = abs(factor - med)
    
   MAD = np.median(distance)
    
   # 2、求出MAD_e
    
   MAD_e = 1.4826 * MAD
    
   # 3、求出正常值范围的边界
    
   up_scale = med + 3 * MAD_e
    
   down_scale = med - 3 * MAD_e
    
   # 4、替换
    
   factor = np.where(factor > up_scale, up_scale, factor)
    
   factor = np.where(factor < down_scale, down_scale, factor)
    
   return factor
    
  
    
 # 自实现标准化
    
 # (x - mean) / std
    
 def stand_method(factor):
    
   mean = np.mean(factor)
    
   std = np.std(factor)
    
   factor = (factor - mean) / std
    
   return factor
    
  
    
 # 2）处理缺失值
    
 fund = fund.dropna()
    
 # 3）去极值、标准化
    
 fund["pe_ratio"] = med_method(fund["pe_ratio"])
    
 fund["pe_ratio"] = stand_method(fund["pe_ratio"])
    
 # 2、获取该因子的收益率
    
 # 1）获取历史交易数据
    
 price = get_price(list(fund.index), start_date="20170105", end_date="20170106", fields="close").T
    
 # 2）处理缺失值
    
 price = price.dropna()
    
 # 3）进行收益率计算
    
 return_rate = price.iloc[:, 1] / price.iloc[:, 0] - 1
    
 # 合并处理
    
 data = pd.concat([fund["pe_ratio"], return_rate], axis=1)
    
 # 3、进行相关系数计算
    
 st.spearmanr(data["pe_ratio"], data[0])

 # 可以自己import我们平台支持的第三方python模块，比如pandas、numpy等。

    
 import pandas as pd
    
 # 在这个方法中编写任何的初始化逻辑。context对象将会在你的算法策略的任何方法之间做传递。
    
 def init(context):
    
     # 1、定义选股的数量
    
     context.stocks_num = 20
    
     # 2、定义分组的组数
    
     context.groups_num = 10
    
     # 3、定义月定时器
    
     scheduler.run_monthly(score_select, tradingday=1)
    
  
    
 # 实现打分法选股策略
    
 def score_select(context, bar_dict):
    
     # 1、获取因子数据
    
     q = query(fundamentals.eod_derivative_indicator.market_cap,
    
     fundamentals.eod_derivative_indicator.pe_ratio,
    
     fundamentals.eod_derivative_indicator.pb_ratio,
    
     fundamentals.financial_indicator.return_on_invested_capital,
    
     fundamentals.financial_indicator.inc_revenue,
    
     fundamentals.financial_indicator.inc_profit_before_tax)
    
  
    
     fund = get_fundamentals(q)
    
     factor_data = fund.T
    
     # print(factor_data)
    
     # 不需要进行去极值、标准化、市值中性化（打分法选股只需知道排名）
    
     # 处理缺失值
    
     factor_data = factor_data.dropna()
    
  
    
     # 2、进行打分，得出股票列表
    
     select_stocks(context, factor_data)
    
  
    
     # 3、每月调仓
    
     rebalance(context)
    
  
    
  
    
 def select_stocks(context, factor_data):
    
     # 分组打分
    
     for factor in factor_data.columns:
    
     # 根据因子方向进行不同处理
    
     # 越小越好：市值、市盈率、市净率
    
     if factor in ["market_cap", "pe_ratio", "pb_ratio"]:
    
         sorted_factor = factor_data.sort_values(by=factor)[factor]
    
         # print("sorted_factor:\n", sorted_factor)
    
         # print("sorted_factor类型：\n", type(sorted_factor))
    
     # 越大越好：ROIC、inc_revenue营业总收入和inc_profit_before_tax利润增长率
    
     else:
    
         sorted_factor = factor_data.sort_values(by=factor, ascending=False)[factor]
    
         # print("sorted_factor:\n", sorted_factor)
    
  
    
     # 分组打分
    
     # 将sorted_factor转换成dataframe方便我们打分
    
     sorted_factor = pd.DataFrame(sorted_factor)
    
     sorted_factor[factor+"_score"] = 0
    
     # print(sorted_factor)
    
     # 计算每组的股票数量
    
     stock_count = len(sorted_factor) // context.groups_num
    
  
    
     for i in range(context.groups_num):
    
         if i == context.groups_num - 1:
    
             sorted_factor[factor+"_score"][i*stock_count:] = i+1
    
         else:
    
             sorted_factor[factor+"_score"][i*stock_count:(i+1)*stock_count] = i+1
    
     # 合并所有因子的分数
    
     factor_data = pd.concat([factor_data, sorted_factor[factor+"_score"]], axis=1)
    
     # print("合并后的表：\n", factor_data)
    
     # 分数加和
    
     sum_score = factor_data.iloc[:, 6:].sum(1).sort_values()
    
     # 选股结果
    
     context.stocks = sum_score[:context.stocks_num].index
    
     # print(sum_score)
    
     # print(context.stocks)
    
  
    
 def rebalance(context):
    
     # 卖出
    
     for stock in context.portfolio.positions.keys():
    
     if context.portfolio.positions[stock].quantity > 0:
    
         if stock not in context.stocks:
    
             order_target_percent(stock, 0)
    
     # 买入
    
     for stock in context.stocks:
    
     order_target_percent(stock, 1.0/context.stocks_num)
    
  
    
  
    
 # before_trading此函数会在每天策略交易开始前被调用，当天只会被调用一次
    
 def before_trading(context):
    
     pass
    
  
    
  
    
 # 你选择的证券的数据更新将会触发此段逻辑，例如日或分钟历史数据切片或者是实时数据切片更新
    
 def handle_bar(context, bar_dict):
    
     pass
    
  
    
 # after_trading函数会在每天交易结束后被调用，当天只会被调用一次
    
 def after_trading(context):
    
     pass

 # 用tensorflow自实现一个线性回归案例

    
  
    
 # 定义一些常用的命令行参数
    
 # 训练步数
    
 tf.app.flags.DEFINE_integer("max_step", 0, "训练模型的步数")
    
 # 定义模型的路径
    
 tf.app.flags.DEFINE_string("model_dir", " ", "模型保存的路径+模型名字")
    
  
    
 FLAGS = tf.app.flags.FLAGS
    
  
    
 class MyLinearRegression(object):
    
     """
    
     自实现线性回归
    
     """
    
     def __init__(self):
    
     pass
    
  
    
     def inputs(self):
    
     """
    
     获取特征值目标值数据数据
    
     :return:
    
     """
    
     x_data = tf.random_normal([100, 1], mean=1.0, stddev=1.0, name="x_data")
    
     y_true = tf.matmul(x_data, [[0.7]]) + 0.8
    
  
    
     return x_data, y_true
    
  
    
     def inference(self, feature):
    
     """
    
     根据输入数据建立模型
    
     :param feature:
    
     :param label:
    
     :return:
    
     """
    
     with tf.variable_scope("linea_model"):
    
         # 2、建立回归模型，分析别人的数据的特征数量--->权重数量， 偏置b
    
         # 由于有梯度下降算法优化，所以一开始给随机的参数，权重和偏置
    
         # 被优化的参数，必须得使用变量op去定义
    
         # 变量初始化权重和偏置
    
         # weight 2维[1, 1]    bias [1]
    
         # 变量op当中会有trainable参数决定是否训练
    
         self.weight = tf.Variable(tf.random_normal([1, 1], mean=0.0, stddev=1.0),
    
                              name="weights")
    
  
    
         self.bias = tf.Variable(0.0, name='biases')
    
  
    
         # 建立回归公式去得出预测结果
    
         y_predict = tf.matmul(feature, self.weight) + self.bias
    
  
    
     return y_predict
    
  
    
     def loss(self, y_true, y_predict):
    
     """
    
     目标值和真实值计算损失
    
     :return: loss
    
     """
    
     # 3、求出我们模型跟真实数据之间的损失
    
     # 均方误差公式
    
     loss = tf.reduce_mean(tf.square(y_true - y_predict))
    
  
    
     return loss
    
  
    
     def merge_summary(self, loss):
    
  
    
     # 1、收集张量的值
    
     tf.summary.scalar("losses", loss)
    
  
    
     tf.summary.histogram("w", self.weight)
    
     tf.summary.histogram('b', self.bias)
    
  
    
     # 2、合并变量
    
     merged = tf.summary.merge_all()
    
  
    
     return merged
    
  
    
     def sgd_op(self, loss):
    
     """
    
     获取训练OP
    
     :return:
    
     """
    
     # 4、使用梯度下降优化器优化
    
     # 填充学习率：0 ~ 1    学习率是非常小，
    
     # 学习率大小决定你到达损失一个步数多少
    
     # 最小化损失
    
     train_op = tf.train.GradientDescentOptimizer(0.1).minimize(loss)
    
  
    
     return train_op
    
  
    
     def train(self):
    
     """
    
     训练模型
    
     :param loss:
    
     :return:
    
     """
    
  
    
     g = tf.get_default_graph()
    
  
    
     with g.as_default():
    
  
    
         x_data, y_true = self.inputs()
    
  
    
         y_predict = self.inference(x_data)
    
  
    
         loss = self.loss(y_true, y_predict)
    
  
    
         train_op = self.sgd_op(loss)
    
  
    
         # 收集观察的结果值
    
         merged = self.merge_summary(loss)
    
  
    
         saver = tf.train.Saver()
    
  
    
         with tf.Session() as sess:
    
  
    
             sess.run(tf.global_variables_initializer())
    
  
    
             # 在没训练，模型的参数值
    
             print("初始化的权重：%f, 偏置：%f" % (self.weight.eval(), self.bias.eval()))
    
  
    
             # 加载模型
    
             checkpoint = tf.train.latest_checkpoint("./tmp/model/")
    
             # print(checkpoint)
    
             if checkpoint:
    
                 print('Restoring', checkpoint)
    
                 saver.restore(sess, checkpoint)
    
             # 开启训练
    
             # 训练的步数（依据模型大小而定）
    
             for i in range(FLAGS.max_step):
    
  
    
                 sess.run(train_op)
    
  
    
                 # 生成事件文件，观察图结构
    
                 file_writer = tf.summary.FileWriter("./tmp/summary/", graph=sess.graph)
    
  
    
                 print("训练第%d步之后的损失:%f, 权重：%f, 偏置：%f" % (
    
                     i,
    
                     loss.eval(),
    
                     self.weight.eval(),
    
                     self.bias.eval()))
    
  
    
                 # 运行收集变量的结果
    
                 summary = sess.run(merged)
    
  
    
                 # 添加到文件
    
                 file_writer.add_summary(summary, i)
    
  
    
                 if i % 100 == 0:
    
                     # 保存的是会话当中的变量op值，其他op定义的值不保存
    
                     saver.save(sess, FLAGS.model_dir)
    
  
    
  
    
 if __name__ == '__main__':
    
     lr = MyLinearRegression()
    
     lr.train()

 import tensorflow as tf

    
 import os
    
 from tensorflow.examples.tutorials.mnist import input_data
    
  
    
  
    
 # 1、利用数据，在训练的时候实时提供数据
    
 # mnist手写数字数据在运行时候实时提供给给占位符
    
  
    
 tf.app.flags.DEFINE_integer("is_train", 1, "指定是否是训练模型，还是拿数据去预测")
    
 FLAGS = tf.app.flags.FLAGS
    
  
    
  
    
 def full_connected_mnist():
    
     """
    
     单层全连接神经网络识别手写数字图片
    
     特征值：[None, 784]
    
     目标值：one_hot编码 [None, 10]
    
     :return:
    
     """
    
     mnist = input_data.read_data_sets("./mnist_data/", one_hot=True)
    
     # 1、准备数据
    
     # x [None, 784] y_true [None. 10]
    
     with tf.variable_scope("mnist_data"):
    
     x = tf.placeholder(tf.float32, [None, 784])
    
     y_true = tf.placeholder(tf.int32, [None, 10])
    
  
    
     # 2、全连接层神经网络计算
    
     # 类别：10个类别  全连接层：10个神经元
    
     # 参数w: [784, 10]   b:[10]
    
     # 全连接层神经网络的计算公式：[None, 784] * [784, 10] + [10] = [None, 10]
    
     # 随机初始化权重偏置参数，这些是优化的参数，必须使用变量op去定义
    
     with tf.variable_scope("fc_model"):
    
     weight = tf.Variable(tf.random_normal([784, 10]), name="w")
    
     bias = tf.Variable(tf.random_normal([10]), name="b")
    
     # fc层的计算
    
     # y_predict [None, 10]输出结果，提供给softmax使用
    
     y_predict = tf.matmul(x, weight) + bias
    
  
    
     # 3、softmax回归以及交叉熵损失计算
    
     with tf.variable_scope("softmax_crossentropy"):
    
     # labels:真实值 [None, 10]  one_hot
    
     # logits:全脸层的输出[None,10]
    
     # 返回每个样本的损失组成的列表
    
     loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_true, logits=y_predict))
    
  
    
     # 4、梯度下降损失优化
    
     with tf.variable_scope("optimizer"):
    
     # 学习率
    
     train_op = tf.train.GradientDescentOptimizer(0.1).minimize(loss)
    
  
    
     # 5、得出每次训练的准确率（通过真实值和预测值进行位置比较，每个样本都比较）
    
     with tf.variable_scope("accuracy"):
    
     equal_list = tf.equal(tf.argmax(y_true, 1), tf.argmax(y_predict, 1))
    
     accuracy = tf.reduce_mean(tf.cast(equal_list, tf.float32))
    
  
    
     # （2）收集要显示的变量
    
     # 先收集损失和准确率
    
     tf.summary.scalar("losses", loss)
    
     tf.summary.scalar("acc", accuracy)
    
     # 收集权重和偏置
    
     tf.summary.histogram("weightes", weight)
    
     tf.summary.histogram("biaes", bias)
    
  
    
     # 初始化变量op
    
     init_op = tf.global_variables_initializer()
    
  
    
     # （3）合并所有变量op
    
     merged = tf.summary.merge_all()
    
  
    
     # 创建模型保存和加载
    
     saver = tf.train.Saver()
    
  
    
     # 开启会话去训练
    
     with tf.Session() as sess:
    
     # 初始化变量
    
     sess.run(init_op)
    
  
    
     # （1）创建一个events文件实例
    
     file_writer = tf.summary.FileWriter("./tmp/summary/", graph=sess.graph)
    
  
    
     # 加载模型
    
     if os.path.exists("./tmp/modelckpt/checkpoint"):
    
         saver.restore(sess, "./tmp/modelckpt/fc_nn_model")
    
  
    
     if FLAGS.is_train == 1:
    
         # 循环步数去训练
    
         for i in range(3000):
    
             # 获取数据，实时提供
    
             # 每步提供50个样本训练
    
             mnist_x, mnist_y = mnist.train.next_batch(50)
    
             # 运行训练op
    
             sess.run(train_op, feed_dict={x: mnist_x, y_true: mnist_y})
    
             print("训练第%d步的准确率为：%f, 损失为：%f " % (i+1,
    
                                  sess.run(accuracy, feed_dict={x: mnist_x, y_true: mnist_y}),
    
                                  sess.run(loss, feed_dict={x: mnist_x, y_true: mnist_y})
    
                                  )
    
               )
    
  
    
             # 运行合变量op，写入事件文件当中
    
             summary = sess.run(merged, feed_dict={x: mnist_x, y_true: mnist_y})
    
             file_writer.add_summary(summary, i)
    
             if i % 100 == 0:
    
                 saver.save(sess, "./tmp/modelckpt/fc_nn_model")
    
  
    
     else:
    
         # 如果不是训练，我们就去进行预测测试集数据
    
         for i in range(100):
    
             # 每次拿一个样本预测
    
             mnist_x, mnist_y = mnist.test.next_batch(1)
    
             print("第%d个样本的真实值为：%d, 模型预测结果为：%d" % (
    
                                                   i+1,
    
                                                   tf.argmax(sess.run(y_true, feed_dict={x: mnist_x, y_true: mnist_y}), 1).eval(),
    
                                                   tf.argmax(sess.run(y_predict, feed_dict={x: mnist_x, y_true: mnist_y}), 1).eval()
    
                                                   )
    
                                                   )
    
  
    
     return None
    
  
    
  
    
 if __name__ == "__main__":
    
     full_connected_mnist()