Python画图示例（1） 一维数据集绘图
 
Python画图示例（2） 二维数据集绘图
 
Python画图示例（3） 其他绘图样式,散点图,直方图等
 
Python画图示例（4） 3D绘图
 
目录
 
 
 
1、用 Numpy ndarray 作为数据传入 ply
 
2.操纵坐标轴和增加网格及标签的函数
 
3.plt.xlim 和 plt.ylim 设置每个坐标轴的最小值和最大值
 
4. 添加标题和标签 plt.title, plt.xlabe, plt.ylabel 离散点, 线
 

 
 
1、用 Numpy ndarray 作为数据传入 ply
 
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt

np.random.seed(1000)
y = np.random.standard_normal(10)
x = range(len(y))

plt.plot(y)
plt.show()
 
 
2.操纵坐标轴和增加网格及标签的函数
 
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt

np.random.seed(1000)
y = np.random.standard_normal(10)
plt.plot(y.cumsum())
plt.grid(True) ##增加格点
plt.axis('tight') # 坐标轴适应数据量 axis 设置坐标轴
plt.show()
 
 
3.plt.xlim 和 plt.ylim 设置每个坐标轴的最小值和最大值
 
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt

np.random.seed(1000)
y = np.random.standard_normal(20)
plt.plot(y.cumsum())
plt.grid(True) ##增加格点
plt.xlim(-1,20)
plt.ylim(np.min(y.cumsum())- 1, np.max(y.cumsum()) + 1)

plt.show()
 
 
4. 添加标题和标签 plt.title, plt.xlabe, plt.ylabel 离散点, 线
 
 
 
 
 
 
 
 
 

KL散度
 
KL 散度是一种衡量两个概率分布的匹配程度的指标，两个分布差异越大，KL散度越大。
 
定义：
 
 
其中 p(x) 是真实分布，q(x)是目标分布（建模目标分布），如果两个分布完全匹配，那么
 
 
 
 
 第一组：数据集为采集100个人的年龄，为以下表格所示，我们使用KL散度去研究最符合的分布类型。
 
age
0
1
2
3
4
5
6
7
8
9
10
总数
count
3
6
7
11
13
18
15
11
7
5
4
100
尝试1：使用均匀分布建立模型
 
可视化为：黄色的为建立的目标均匀分布模型，与蓝色真实分布的对比。
 
 
 
 
尝试2：使用高斯分布建立模型
 
可视化为：（红色虚线是相同与拟合的一条正态分布曲线，蓝色条形图为概率密度）：
 
 
计算分析 ：
 
如何判断真实分布更接近均匀分布还是高斯分布，用肉眼看是很不准确的，用KL散度来衡量真实分布去匹配目标分布所损失的信息量。所以能够将模型量化去比较从而判断出接近哪种分布。
 
1、计算与均匀分布的KL散度：
 
import numpy as np
import math
count=np.array([3,6,7,11,13,18,15,11,7,5,4])
count_rate=count/100
balance_rate=1/11
sum=0
for i in range(11):
    sum+=count_rate[i]*math.log(count_rate[i]/balance_rate)
print(sum)
 
计算结果为：0.12899493763053263
 
 
 
2、计算与高斯分布的KL散度：
 

def gaosi(x):
    mu=5.03
    sigma=2.4349743325135895
    t1=1/(sigma*math.sqrt(2*math.pi))
    t2=((x-mu)**2)/(2*sigma*sigma)
    return math.exp(-1*t2)*t1

count=np.array([3,6,7,11,13,18,15,11,7,5,4])
count_rate=count/100

sum=0
for i in range(11):
    sum+=count_rate[i]*math.log(count_rate[i]/gaosi(i))
print(sum)
 
计算结果为：0.03997441345364968
 
 
 
结论：
 
在只考虑均匀分布模型与高斯分布模型的情况下，用本身去拟合目标模型时，匹配高斯分布所损失的信息量最少，计算发现该数据集的分布更符合高斯分布。

Python画图示例（1） 一维数据集绘图
 
Python画图示例（2） 二维数据集绘图
 
Python画图示例（3） 其他绘图样式,散点图,直方图等
 
Python画图示例（4） 3D绘图
 
目录
 
1.两个数据集绘图
 
2.添加图例 plt.legend(loc = 0)
 
3.使用2个 Y轴(左右)fig, ax1 = plt.subplots() ax2 = ax1.twinx()
 
4.使用两个子图(上下,左右)plt.subplot(211)
 
5.左右子图
 

1.两个数据集绘图
 
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt

np.random.seed(2000)
y = np.random.standard_normal((10, 2))
plt.figure(figsize=(7,5))
plt.plot(y, lw = 1.5)
plt.plot(y, 'ro')
plt.grid(True)
plt.axis('tight')
plt.xlabel('index')
plt.ylabel('value')
plt.title('A simple plot')
plt.show()
 
 
2.添加图例 plt.legend(loc = 0)
 
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt

np.random.seed(2000)
y = np.random.standard_normal((10, 2))
plt.figure(figsize=(7,5))
plt.plot(y[:,0], lw = 1.5,label = '1st')
plt.plot(y[:,1], lw = 1.5, label = '2st')
plt.plot(y, 'ro')
plt.grid(True)
plt.legend(loc = 0) #图例位置自动
plt.axis('tight')
plt.xlabel('index')
plt.ylabel('value')
plt.title('A simple plot')
plt.show()
 
 
3.使用2个 Y轴(左右)fig, ax1 = plt.subplots() ax2 = ax1.twinx()
 
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt

np.random.seed(2000)
y = np.random.standard_normal((10, 2))

fig, ax1 = plt.subplots() # 关键代码1 plt first data set using first (left) axis

plt.plot(y[:,0], lw = 1.5,label = '1st')

plt.plot(y[:,0], 'ro')
plt.grid(True)
plt.legend(loc = 0) #图例位置自动
plt.axis('tight')
plt.xlabel('index')
plt.ylabel('value')
plt.title('A simple plot')

ax2 = ax1.twinx()  #关键代码2  plt second data set using second(right) axis
plt.plot(y[:,1],'g', lw = 1.5, label = '2nd')
plt.plot(y[:,1], 'ro')
plt.legend(loc = 0)
plt.ylabel('value 2nd')
plt.show()
 
 
4.使用两个子图(上下,左右)plt.subplot(211)
 
通过使用 plt.subplots 函数,可以直接访问底层绘图对象,例如可以用它生成和第一个子图共享 x 轴的第二个子图.
 
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt

np.random.seed(2000)
y = np.random.standard_normal((10, 2))

plt.figure(figsize=(7,5))
plt.subplot(211)  #两行一列,第一个图
plt.plot(y[:,0], lw = 1.5,label = '1st')
plt.plot(y[:,0], 'ro')
plt.grid(True)
plt.legend(loc = 0) #图例位置自动
plt.axis('tight')
plt.ylabel('value')
plt.title('A simple plot')


plt.subplot(212) #两行一列.第二个图
plt.plot(y[:,1],'g', lw = 1.5, label = '2nd')
plt.plot(y[:,1], 'ro')
plt.grid(True)
plt.legend(loc = 0)
plt.xlabel('index')
plt.ylabel('value 2nd')
plt.axis('tight')
plt.show()
 
 
5.左右子图
 
有时候,选择两个不同的图标类型来可视化数据可能是必要的或者是理想的.利用子图方法:
 
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt

np.random.seed(2000)
y = np.random.standard_normal((10, 2))

plt.figure(figsize=(10,5))
plt.subplot(121)  #两行一列,第一个图
plt.plot(y[:,0], lw = 1.5,label = '1st')
plt.plot(y[:,0], 'ro')
plt.grid(True)
plt.legend(loc = 0) #图例位置自动
plt.axis('tight')
plt.xlabel('index')
plt.ylabel('value')
plt.title('1st Data Set')

plt.subplot(122)
plt.bar(np.arange(len(y)), y[:,1],width=0.5, color='g',label = '2nc')
plt.grid(True)
plt.legend(loc=0)
plt.axis('tight')
plt.xlabel('index')
plt.title('2nd Data Set')
plt.show()
 
 
 
 
 
 
 

使用一维数据构造简单卷积神经网络
 
觉得有用的话,欢迎一起讨论相互学习~
 
 
神经网络对于一维数据非常重要，时序数据集、信号处理数据集和一些文本嵌入数据集都是一维数据，会频繁的使用到神经网络。我们在此利用一组一维数据构造卷积层-最大池化层-全连接层的卷积神经网络。希望给大家使用CNN处理一维数据一些帮助。
 
参考代码
 
# Implementing Different Layers
# ---------------------------------------
#
# We will illustrate how to use different types
# of layers in TensorFlow
#
# The layers of interest are:
#  (1) Convolutional Layer卷积层
#  (2) Activation Layer激活层
#  (3) Max-Pool Layer池化层
#  (4) Fully Connected Layer 全连接层
#
# We will generate two different data sets for this
#  script, a 1-D data set (row of data) and
#  a 2-D data set (similar to picture)

import tensorflow as tf
import matplotlib.pyplot as plt
import csv
import os
import random
import numpy as np
import random
from tensorflow.python.framework import ops

ops.reset_default_graph()

# ---------------------------------------------------|
# -------------------1D-data-------------------------|
# ---------------------------------------------------|

# Create graph session 创建初始图结构
ops.reset_default_graph()
sess = tf.Session()

# parameters for the run运行参数
data_size = 25
conv_size = 5  # 卷积核宽度方向的大小
maxpool_size = 5  # 池化层核宽度方向上的大小
stride_size = 1  # 卷积核宽度方向上的步长

# ensure reproducibility 确保复现性
seed = 13
np.random.seed(seed)
tf.set_random_seed(seed)

# Generate 1D data 生成一维数据
data_1d = np.random.normal(size=data_size)

# Placeholder
x_input_1d = tf.placeholder(dtype=tf.float32, shape=[data_size])


# --------Convolution--------
def conv_layer_1d(input_1d, my_filter, stride):
    # TensorFlow's 'conv2d()' function only works with 4D arrays:
    # [batch, height, width, channels], we have 1 batch, and
    # width = 1, but height = the length of the input, and 1 channel.
    # So next we create the 4D array by inserting dimension 1's.
    # 关于数据维度的处理十分关键，因为tensorflow中卷积操作只支持四维的张量，
    # 所以要人为的把数据补充为4维数据[1,1,25,1]
    input_2d = tf.expand_dims(input_1d, 0)
    input_3d = tf.expand_dims(input_2d, 0)
    input_4d = tf.expand_dims(input_3d, 3)
    # Perform convolution with stride = 1, if we wanted to increase the stride,
    # to say '2', then strides=[1,1,2,1]
    convolution_output = tf.nn.conv2d(input_4d, filter=my_filter, strides=[1, 1, stride, 1], padding="VALID")
    # Get rid of extra dimensions 去掉多余的层数，只保留数字
    conv_output_1d = tf.squeeze(convolution_output)
    return (conv_output_1d)


# Create filter for convolution.
my_filter = tf.Variable(tf.random_normal(shape=[1, conv_size, 1, 1]))
# Create convolution layer
my_convolution_output = conv_layer_1d(x_input_1d, my_filter, stride=stride_size)


# --------Activation--------
def activation(input_1d):
    return (tf.nn.relu(input_1d))


# Create activation layer
my_activation_output = activation(my_convolution_output)


# --------Max Pool--------
def max_pool(input_1d, width, stride):
    # Just like 'conv2d()' above, max_pool() works with 4D arrays.
    # [batch_size=1, width=1, height=num_input, channels=1]
    # 因为在处理卷积层的结果时，使用squeeze函数对结果输出进行降维，所以此处要将最大池化层的维度提升为4维
    input_2d = tf.expand_dims(input_1d, 0)
    input_3d = tf.expand_dims(input_2d, 0)
    input_4d = tf.expand_dims(input_3d, 3)
    # Perform the max pooling with strides = [1,1,1,1]
    # If we wanted to increase the stride on our data dimension, say by
    # a factor of '2', we put strides = [1, 1, 2, 1]
    # We will also need to specify the width of the max-window ('width')
    pool_output = tf.nn.max_pool(input_4d, ksize=[1, 1, width, 1],
                                 strides=[1, 1, stride, 1],
                                 padding='VALID')
    # Get rid of extra dimensions
    pool_output_1d = tf.squeeze(pool_output)
    return (pool_output_1d)


my_maxpool_output = max_pool(my_activation_output, width=maxpool_size, stride=stride_size)


# --------Fully Connected--------
def fully_connected(input_layer, num_outputs):
    # First we find the needed shape of the multiplication weight matrix:
    # The dimension will be (length of input) by (num_outputs)
    weight_shape = tf.squeeze(tf.stack([tf.shape(input_layer), [num_outputs]]))
    # squeeze函数用于去掉维度为1的维度。保留数据。

    # Initialize such weight
    # 初始化weight
    weight = tf.random_normal(weight_shape, stddev=0.1)
    # Initialize the bias
    # 初始化bias
    bias = tf.random_normal(shape=[num_outputs])
    # Make the 1D input array into a 2D array for matrix multiplication
    # 将一维的数组添加一维成为2维数组
    input_layer_2d = tf.expand_dims(input_layer, 0)
    # Perform the matrix multiplication and add the bias
    full_output = tf.add(tf.matmul(input_layer_2d, weight), bias)
    # Get rid of extra dimensions
    # 去掉多余的维度只保留数据
    full_output_1d = tf.squeeze(full_output)
    return (full_output_1d)


my_full_output = fully_connected(my_maxpool_output, 5)

# Run graph
# Initialize Variables
init = tf.global_variables_initializer()
sess.run(init)

feed_dict = {x_input_1d: data_1d}

print('>>>> 1D Data <<<<')

# Convolution Output
print('Input = array of length %d'%(x_input_1d.shape.as_list()[0]))  # 25
print('Convolution w/ filter, length = %d, stride size = %d, results in an array of length %d:'%
      (conv_size, stride_size, my_convolution_output.shape.as_list()[0]))  # 21
print(sess.run(my_convolution_output, feed_dict=feed_dict))

# Activation Output
print('\nInput = above array of length %d'%(my_convolution_output.shape.as_list()[0]))  # 21
print('ReLU element wise returns an array of length %d:'%(my_activation_output.shape.as_list()[0]))  # 21
print(sess.run(my_activation_output, feed_dict=feed_dict))

# Max Pool Output
print('\nInput = above array of length %d'%(my_activation_output.shape.as_list()[0]))  # 21
print('MaxPool, window length = %d, stride size = %d, results in the array of length %d'%
      (maxpool_size, stride_size, my_maxpool_output.shape.as_list()[0]))  # 17
print(sess.run(my_maxpool_output, feed_dict=feed_dict))

# Fully Connected Output
print('\nInput = above array of length %d'%(my_maxpool_output.shape.as_list()[0]))  # 17
print('Fully connected layer on all 4 rows with %d outputs:'%
      (my_full_output.shape.as_list()[0]))  # 5
print(sess.run(my_full_output, feed_dict=feed_dict))

# >>>> 1D Data <<<<
# Input = array of length 25
# Convolution w/ filter, length = 5, stride size = 1, results in an array of length 21:
# [-2.63576341 -1.11550486 -0.95571411 -1.69670296 -0.35699379  0.62266493
#   4.43316031  2.01364899  1.33044648 -2.30629659 -0.82916248 -2.63594174
#   0.76669347 -2.46465087 -2.2855041   1.49780679  1.6960566   1.48557389
#  -2.79799461  1.18149185  1.42146575]
#
# Input = above array of length 21
# ReLU element wise returns an array of length 21:
# [ 0.          0.          0.          0.          0.          0.62266493
#   4.43316031  2.01364899  1.33044648  0.          0.          0.
#   0.76669347  0.          0.          1.49780679  1.6960566   1.48557389
#   0.          1.18149185  1.42146575]
#
# Input = above array of length 21
# MaxPool, window length = 5, stride size = 1, results in the array of length 17
# [ 0.          0.62266493  4.43316031  4.43316031  4.43316031  4.43316031
#   4.43316031  2.01364899  1.33044648  0.76669347  0.76669347  1.49780679
#   1.6960566   1.6960566   1.6960566   1.6960566   1.6960566 ]
#
# Input = above array of length 17
# Fully connected layer on all 4 rows with 5 outputs:
# [ 1.71536088 -0.72340977 -1.22485089 -2.5412786  -0.16338299]
 
 
 
参考文献
 TensorFlow机器学习实战指南