TensorFlow2.0基础学习笔记

创建张量

import tensorflow as tf

print("Tensorflow version:", tf.__version__)  # 检查版本号
print("Eager execution is:", tf.executing_eagerly())  # 检查是否在Eager模式下

'''
Tensor表示张量，其实就是多维数组。
'''
'''
python中的列表list
Numpy中的数组对象ndarray
TensorFlow中的张量（Tensor）
'''
# 区别
'''
python列表（list）:
    ·元素可以使用不同的数据类型，可以嵌套
    ·在内存中不连续存放，是一个动态的指针数组
    ·读写效率低，占用内存空间大
    ·不适合做数值计算
    
Numpy数组(ndarray):
    ·元素数据类型相同
    ·每个元素在内存中占用的空间相同
    存储在一个连续的内存区域内
    ·存储空间小，读取和写入速度快
    ·在cpu中运算，不能够主动检测利用gpu进行运算
TensorFlow张量(Tensor):
    ·可以高速运行于gpu和Tpu之上
    ·支持cpu、嵌入式、单机多卡和多机多卡等多种计算环境
    ·高速的实现神经网络和深度学习中的复杂算法
'''
# 创建Tensor对象
    # tf.constant()函数：创建张量
    # tf.constant(value,dtype,shape)
        # value:数字\python列表\numpy数组
        # dtype:元素的数据类型
        # shape:张量的形状
    # tf.convert_to_tensor()函数
'''
    判断是否是张量：
        is_tensor()函数
        isinstance()函数
'''
# 参数为PYthon列表
import tensorflow as tf
print(tf.constant([[1,2],[3,4]]))
# 张量的.numpy()方法
a = tf.constant([[1,2],[3,4]])
print(a.numpy())
print(type(a))
# 表示其是eager模式下的张量

# 创建张量（tensor）
'''
tf.constant(张量内容,dtype=数据类型)
'''
import tensorflow as tf

a = tf.constant([1, 5], dtype=tf.int64)
print(a)
print(a.dtype)  # 数据类型
print(a.shape)  #
# tf.Tensor([1 5], shape=(2,), dtype=int64) 打印出张量的所有内容
#   数据类型
# (2,)  2表示有两个元素，一个逗号隔开表示一维数组

# convert 转换

'''
将numpy的数据类型转换为Tensor的数据类型
tf.convert_to_tensor(数据名，dtype=数据类型（可选）)

'''
import tensorflow as tf
import numpy as np

a = np.arange(0, 5)
b = tf.convert_to_tensor(a, dtype=tf.int64)
print(a)
print(b)
# [0 1 2 3 4]
# tf.Tensor([0 1 2 3 4], shape=(5,), dtype=int64)

'''
创建全为0的张量
tf.zeros(维度)

创建全为1的张量
tf.ones(维度)

创建全为指定值的张量
tf.fill(维度，指定值)

维度：
    一维 直接写个数
    二维  用[行，列]
    多维 用[n,m,j,k.....]
    
'''
print("******************")
a = tf.zeros([2, 3])  # 二维数组
b = tf.ones(4)  # 一维数组
c = tf.fill([2, 2], 9)  # 二维数组
print(a)
print(b)
print(c)


'''
生成正态分布的随机数，默认均值为0，标准差为1
tf.random.normal(维度,mean=均值，stddev=标准差)

生成截断式正态分布的随机数（truncated 截断）
tf.random.truncated_normal(维度，mean=均值，stddev=标准差)

在tf.truncated_normal中如果随机生成数据的取值在（）

'''
d = tf.random.normal([2,2],mean=0.5,stddev=1)
print(d)

e = tf.random.truncated_normal([2,2],mean=0.5,stddev=1)
print(e)
# tf.Tensor(
# [[ 0.8248359  0.9195403]
#  [-0.9171852  0.9591876]], shape=(2, 2), dtype=float32)
# tf.Tensor(
# [[-1.4231092   0.9822493 ]
#  [ 0.93558526  1.1987464 ]], shape=(2, 2), dtype=float32)

'''
生成均匀分布随机数
tf.random.uniform(维度，minval=最小值，max=最大值)

'''
f = tf.random.uniform([2,2],minval=0,maxval=1)
print(f)
# tf.Tensor(
# [[0.4069723  0.3565172 ]
#  [0.7605829  0.19685042]], shape=(2, 2), dtype=float32)

'''
常用函数
强制tensor转换为该数据类型（用tf.cast强制类型转换）
tf.cast(张量名，dtype=数据类型)

计算张量维度上的最小值
tf.reduce_min(张量名)

计算张量维度上元素的最大值
tf.reduce_max(张量名)

'''
x1 = tf.constant([1.,2.,3.],dtype = tf.float64)
print(x1)

x2 = tf.cast(x1,tf.int32)
print(x2)

print(tf.reduce_min(x2))
print(tf.reduce_max(x2))
# tf.Tensor([1. 2. 3.], shape=(3,), dtype=float64)
# tf.Tensor([1 2 3], shape=(3,), dtype=int32)
# tf.Tensor(1, shape=(), dtype=int32)
# tf.Tensor(3, shape=(), dtype=int32)

'''
axis
在一个二维张量或数组中，可以通过调整axis等于0或1控制执行维度

axsi=0代表跨行（经度，down）,而axis=1代表跨列（维度，across）
如果不指定axis,则所有元素参与计算

计算张量沿着指定维度的平均值
tf.reduce_mean(张量名，axis=操作轴)

计算张量沿着指定维度的和
tf,reduce_sum(张量名，axis=操作轴)

'''
x = tf.constant([[1,2,3],
                 [2,3,4]])
print(x)
print(tf.reduce_mean(x))
print(tf.reduce_sum(x,axis=1))

# tf.Tensor(
# [[1 2 3]
#  [2 3 4]], shape=(2, 3), dtype=int32)
# tf.Tensor(2, shape=(), dtype=int32)
# tf.Tensor([6 9], shape=(2,), dtype=int32)

'''
tf.Variable
tf.Variable()将变量标记为“可训练”，被标记的变量会在反向传播中记录梯度信息。
神经网络训练中，常用该函数标记待训练的变量

tf.Variable(初始值)
'''
#w = tf.Variable(tf.random.normal([2,2],mean=0,stddev=1))

'''
tensorflow中的数学运算

对应元素的四则运算：tf.add,tf.subtract,tf.multiply,tf.divide
平方、次方与开方：tf.square,tf.pow,tf.aqrt
矩阵乘：tf.matmul

实现两个张量的对应元素相加
tf.add(张量1，张量2）
实现两个元素的对应元素相减
tf.subtract(张量1，张量2）
实现两个张量的对应元素相乘
tf.multiply(张量1，张量2）
实现两个张量的对应元素相除
tf.divide(张量1，张量2)

！！！只有维度相同的张量才可以做四则运算

'''
a = tf.ones([1,3])
b = tf.fill([1,3],3.)

print(a)
print(b)

print(tf.add(a,b))
print(tf.subtract(a,b))
print(tf.multiply(a,b))
print(tf.divide(b,a))
print("--------------------")

# tf.Tensor([[1. 1. 1.]], shape=(1, 3), dtype=float32)
# tf.Tensor([[3. 3. 3.]], shape=(1, 3), dtype=float32)
# tf.Tensor([[4. 4. 4.]], shape=(1, 3), dtype=float32)
# tf.Tensor([[-2. -2. -2.]], shape=(1, 3), dtype=float32)
# tf.Tensor([[3. 3. 3.]], shape=(1, 3), dtype=float32)
# tf.Tensor([[3. 3. 3.]], shape=(1, 3), dtype=float32)
'''
计算某个张量的平方
tf.square(张量名)

计算某个张量的n次方
tf.pow(张量名，n次方数)

计算某个张量的开方
tf.sqrt(张量名)
'''
a = tf.fill([1,2],3.)
print(a)
print(tf.pow(a,3))
print(tf.square(a))
print(tf.sqrt(a))
# tf.Tensor([[3. 3.]], shape=(1, 2), dtype=float32)
# tf.Tensor([[27. 27.]], shape=(1, 2), dtype=float32)
# tf.Tensor([[9. 9.]], shape=(1, 2), dtype=float32)
# tf.Tensor([[1.7320508 1.7320508]], shape=(1, 2), dtype=float32)
'''
矩阵乘tf.matmul

实现两个矩阵的相乘
tf.matmul(矩阵1，矩阵2)
'''
a = tf.ones([3,2])
b = tf.fill([2,3],3.)
print(tf.matmul(a,b))
# tf.Tensor(
# [[6. 6. 6.]
#  [6. 6. 6.]
#  [6. 6. 6.]], shape=(3, 3), dtype=float32)
'''
常用函数 tf.Dataset.from_tensor_slices

切分传入张量的第一维度，生成输入特征标签对，构建数据集
data = tf.Dataset.from_tensor_slices((输入特征，标签))

（Numpy和Tensor格式都可用该语句读入数据）
'''
features = tf.constant([12,23,10,17])
labels = tf.constant([0,1,1,0])
dataset = tf.data.Dataset.from_tensor_slices((features,labels))
for element in dataset:
    print(element)
# (, )
# (, )
# (, )
# (, 
'''
tf.GradientTape 实现对指定参数的求导运算
with结构记录计算过程，gradient求出张量的梯度

with tf.GradientTape() as tape:
    若干个计算过程
grad = tape.gradient(函数，对谁求导）

'''
with tf.GradientTape() as tape:
    w = tf.Variable(tf.constant(3.0))
    loss = tf.pow(w,2)
grad =tape.gradient(loss,w)
print(grad)
# tf.Tensor(6.0, shape=(), dtype=float32)

'''
enumerate是python的内建函数，他可遍历每个元素（如：列表，元组，或字符串）
enumerate(列表名)

'''
seq = ['one','two','three']
for i,element in enumerate(seq):
    print(i,element)
# 0 one
# 1 two
# 2 three
'''
tf.one_hot
tf.one_hot() 函数将待转换数据，转换为one_hot的形式输出。

tf.one_hot(带转换数据，depth=分类)

'''
classes = 3
labels = tf.constant([1,0,2])# 输入的元素值最小为0，最大为2
output = tf.one_hot(labels,depth=classes)
print(output)
# tf.Tensor(
# [[0. 1. 0.]
#  [1. 0. 0.]
#  [0. 0. 1.]], shape=(3, 3), dtype=float32)

创建数组 数组运算

# 生成ndarray(多维数组)的方法
# 1、将列表转换成ndarray
import numpy as np
list1 = [3.14,2.17,0,1,2]
nd1 = np.array(list1)
print(nd1)
print(type(nd1))
# 2、嵌套列表转成多维数组
import numpy as np
list2 = [[3.14,2.17,0,1,2],[1,2,3,4,5]]
nd2 = np.array(list2)
print(nd2)
print(type(nd2))
# 3、利用random模块生成多维数组
'''random 模块里的函数：
        random(生成0~1之间的随机数)
        uniform（生成均匀分布随机数）
        rando（生成标准正态的随机数）
        normal （生成正态分布）
        shuffle（随机打乱顺序）
        seed （设置随机数种子）
        '''
import numpy as np
nd3 = np.random.random([3,3])   # 生成三行三列的0~1之间的随机数
print(nd3)
print(type(nd3))


print('**************************')
# 生成一个随机种子，对生成的随机数打乱
import numpy as np
np.random.seed(123)   # 设置随机数种子序号123 给数列管理器序号123得到哟个数列
nd5_1 = np.random.randn(2,3)        # 生成两行三列得的随机种子
print(nd5_1)
np.random.shuffle(nd5_1)
print("随机打乱后的数据：",nd5_1)
print(type(nd5_1))

# 创建特定形状的多维数组
'''
np.zeros
np.ones
np.diag
np.eye
'''
import numpy as np
# 生成全是0的3x3的矩阵
nd6 = np.zeros([3,3])
# 生成全是1的3x3的矩阵
nd7 = np.ones([3,3])
# 生成3阶单位矩阵
nd8 = np.eye(3)
# 生成3阶对角矩阵
nd9 = np.diag([1,2,3])
print(nd9)

# 利用arange函数生成ndarray
import numpy as np
print(np.arange(10))
print(np.arange(1,10))
print(np.arange(1,4,0.5))
print(np.arange(9,-1,-1))


# 创建数组并且改变数组形状
'''
np.reshape(shape) 不改变当前数组形状，按照shape创建新的数组
np.resize(shape) 改变当前数组，按照shape创建数组
'''

import numpy as np

b = np.arange(12)
print(b.reshape(3, 4))
print(b)
# b = np.arange(12).reshape(3,4)


t = np.arange(24).reshape(2, 3, 4)
print(t)
# [[[ 0  1  2  3]
#   [ 4  5  6  7]
#   [ 8  9 10 11]]
#
#  [[12 13 14 15]
#   [16 17 18 19]
#   [20 21 22 23]]]

# np.reshape(shape) shape = -1 根据数组中的元素个数、以及其他维度的取值，来自动
# 出这个维度的取值
print(b.reshape(-1, 1))
# [[ 0]
#  [ 1]
#  [ 2]
#  [ 3]
#  [ 4]
#  [ 5]
#  [ 6]
#  [ 7]
#  [ 8]
#  [ 9]
#  [10]
#  [11]]

# 一维数组跟多维数组相加，可以将一维数组扩展至多维数组
a = np.array([0, 1, 2, 3])
b = np.array([[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]])
print(a + b)
# [[ 0  2  4  6]
#  [ 4  6  8 10]
#  [ 8 10 12 14]]
# 当两个数组中的数据类型不同时，精度低的数据类型会自动转换为精度高的数据类型，然后进行计算

# 矩阵转置：np.transpose()
# 矩阵求逆：np.linalg.inv()
'''
总结：numpy对数组的常用操作
        对数组元素的切片
        改变数组的形状
        数组之间的常用运算
        
'''
# 数组元素的运算
'''
numpy.sum() 计算所有元素的和
numpy.prod() 计算所有元素的乘积
numpy.diff() 计算数组的相邻元素之间的差
np.sqrt() 计算各元素的平方根
np.exp() 计算各元素的指数值
np.abs() 取各元素的绝对值
'''
# 求和函数sum():对数组中的所有元素求和

a = np.arange(4)
print(a)
print(np.sum(a))

b = np.arange(12).reshape(3, 4)
print(b)
print(np.sum(b))
# 6
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]
# 66

'''
轴（axes）：数组中的每个维度被称为一个轴
秩（rank）:轴的格式
'''
print(np.sum(b, axis=0))
# [12 15 18 21]

print(np.sum(b, axis=1))
# [ 6 22 38]

# sqrt() 函数 求平方根
d = np.logspace(1, 4, 4, base=2)  # logspace函数生成等比数列
print(d)
print(np.sqrt(d))
# [ 2.  4.  8. 16.]
# [1.41421356 2.         2.82842712 4.        ]
'''
数组的堆叠运算
np.stack(数组1，数组2，....axis)
'''
x = np.array([1, 2, 3])
y = np.array([4, 5, 6])

print(np.stack((x, y), axis=0))
print(np.stack((x, y), axis=1))
# [[1 2 3]
#  [4 5 6]]
# [[1 4]
#  [2 5]
#  [3 6]]

创建矩阵 矩阵运算

'''
创建矩阵
矩阵---numpy.matrix
matrix(字符串/列表/元组/数组)
mat(字符串/列表/元组/数组)
'''
a = np.mat('1 2 3; 4 5 6')
print(a)
b = np.mat([[1,2,3],[4,5,6]])
print(b)

# [[1 2 3]

#  [4 5 6]]

# [[1 2 3]

#  [4 5 6]]

a = np.array([[1,2,3],[4,5,6]])
print(a)
m = np.mat(a)
print(m)

print(type(a))
print(type(m))

# [[1 2 3]

#  [4 5 6]]

# [[1 2 3]

#  [4 5 6]]

# 

# 

'''
矩阵对象的属性：
    .ndim 矩阵的维数
    .shape 矩阵的形状
    .size 矩阵的元个数
    .dtype 元素的数据类型
'''
print(m.ndim)
print(m.shape)
print(m.size)
print(m.dtype)

# 2

# (2, 3)

# 6

# int32

'''矩阵运算
矩阵的转置：.T
矩阵求逆：.I
'''
n = np.mat([[1,2],[-1,-3]])
print(n)
print(n.T)
print(n.I)

# [[ 1  2]

#  [-1 -3]]

# [[ 1 -1]

#  [ 2 -3]]

# [[ 3.  2.]

#  [-1. -1.]]

# 随机数

'''
随机数模块---numpy.random
np.random.rand()    元素在[0,1)之间均匀分布的数组
np.random.uniform(low,hige,size)    元素在[low,hige)区间均匀分布的数组
np.random.randn(d0,d1,d2,...,dn)    产生标准正态分布的数组（标准差时1，均值时0的正态分布）
np.random.normal(loc,scale,size)    产生正态分布的数组loc 均值；scale标准差

伪随机数：由随机种子，根据一定的算法生成的
随机种子：指定随机数生成时所用算法开始的整数值
    如果使用相同的seed()值，则每次生成的随机数都是相同的
    如果不设置这个值，则系统根据时间来自己选择这个值，此时每次生成的随机数因时间差异而不同
    
'''

# 打乱顺序的函数 np.random.shuffle(序列）

# 多维数组只打乱第一维

b = np.arange(12).reshape(4,3)
print(b)
c = np.random.shuffle(b)
print(c)

数字图像基本概念

一个字节由8个二进制位组成
图像压缩：适当降低图像质量来减小它所占用的空间
         不同的图像压缩算法，对应不同的图像格式

像素(Pixel)：是图像中的一个最小单位

图像的离散化：
    连续图像：人眼直接感受到的图像
    数字图像：把连续的图像数字化、离散化之后的图像。它是对连续图像的一种近似

色彩深度/位深度：位图中每个像素点要用多少二进制位来表示

位图(bitmap)：
    通过记录每一个像素的颜色值，来存储和表达图像

    图像格式：
        BMP格式(是windows系统的标准位图格式)：需要保存每个像素的颜色信息，占用存储空间大，不支持文件压缩，不适用网页

        JPEG：有损压缩
              压缩率高，所占空间小
              适合于色彩丰富、细节清晰细腻的大图像
              不适合所含颜色较少，具有大块颜色相近的区域，或亮度差异十分明显的简单图片
              每次编辑都会降低图像质量，不适合需要进行多次编辑的情况
        PNG(Portable Network Graphics ,PNG)：无损压缩
                                             适合于有规律渐变色彩的图像

        ,GIF,TIFF
    色彩模式：记录图像颜色的方式
        二值图像(Binary Image):每个像素只有2种可能的取值，使用1位二进制来表示，位深度为 0代表黑色，1代表白色

        灰度图像(Gray Image)：每个像素使用1个字节表示，位深度位8，可以表示256种级别的灰度。0表示黑色，255表示白色
        RGB图像(彩色图像)：每个像素都有红(R)、绿(G)、蓝(B)三个分量（称为通道）
                         1个像素点使用3个字节（每个分量1个字节），位深度为24位（3*8）
                         可以表示256*256*256种颜色
                         称为24位真彩色
        RGBA图像：RGB图像+8位透明度信息Alpha（称为Alpha通道或者A通道）
                 32位真彩色图像：1个像素点使用4个字节，位深度为32位
        256色彩色图像：每个像素用8位二进制表示，是调色板中的索引值
        CMYK、
        YCbCr、
        HSI

python图像处理库

import PIL.Image
from PIL import Image
import matplotlib.pyplot as plt

img = Image.open('lena.tiff')
img.save('test.tiff')
img.save('lena.jpg')
img.save('lena.bmp')

img1 = Image.open('lena.tiff')
img2 = Image.open('lena.bmp')
img3 = Image.open('lena.jpg')

print("image1:", img1.format)
print("image2:", img2.format)
print("image3:", img3.format)

print("size:", img1.size)
print("size:", img2.size)
print("size:", img3.size)

print("mode:", img1.mode)
print("mode2:", img2.mode)
print("mode3:", img3.mode)

# imshow() 函数负责对图像进行处理 并显示其格式
plt.figure(figsize=(5, 5))
plt.imshow(img)
plt.show()

# 分别显示不同格式的图像
# 设置画布尺寸

img1 = Image.open('lena.tiff')
img2 = Image.open('lena.bmp')
img3 = Image.open('lena.jpg')

plt.figure(figsize=(15, 5))

# 将画布划分为1行3列
plt.subplot(131)
# 不显示坐标轴
plt.axis("off")
# 显示img图像（对图像进行处理并显示其格式）
plt.imshow(img1)
# 子图标题位置显示子图格式
plt.title(img1.format)

plt.subplot(132)
plt.axis("off")
plt.imshow(img2)
plt.title(img2.format)

plt.subplot(133)
plt.axis("off")
plt.imshow(img3)
plt.title(img3.format)

plt.show()

# 转换图像的色彩模式
# 图像对像.convert(色彩模式)
img_gray = img.convert("L")  # 将图像转换成灰度图像
print("mode=", img_gray.mode)  # 输出图像模式

plt.figure(figsize=(5, 5))
plt.imshow(img_gray)
plt.show()

# 将转换的灰度图像保存在工作目录
img_gray.save("lena_gray.bmp")

# 颜色通道的分离与合并
'''
分离：图像对象.split()
合并：Image.merge(色彩模式，图像列表)
'''
# 打开RGB图像
img = Image.open("lena.tiff")
# 使用.split()分为三个颜色通道分别存储在不同的对象中
img_r, img_g, img_b = img.split()

plt.figure(figsize=(10, 10))

plt.subplot(221)
plt.axis('off')
# cmap=gray表示各个通道的图像是以灰度图像的形式显示的
plt.imshow(img_r, cmap="gray")
plt.title("R", fontsize=20)

plt.subplot(222)
plt.axis("off")
plt.imshow(img_b, cmap="gray")
plt.title("G", fontsize=20)

plt.subplot(223)
plt.axis("off")
plt.imshow(img_g, cmap="gray")
plt.title("B", fontsize=20)

# 使用Image.merage(色彩模式，图像列表)合并各颜色通道,得到RGB彩色图像并显示在子图中
img_rgb = Image.merge("RGB", [img_r, img_g, img_b])
plt.subplot(224)
plt.axis("off")
plt.imshow(img_rgb)
plt.title("RGB", fontsize=20)

plt.show()

# 转化为数组
'''
np.array()

'''
import numpy as np

arr_img = np.array(img)
print("shape:", arr_img.shape, "\n")
print(arr_img)

# 将灰度图像lena_gray.bmp转化为数组
img_gray = Image.open("lena.bmp")
arr_img_gray = np.array(img_gray)
print("\nshape:", arr_img_gray.shape)
print(arr_img_gray)

# 255-arr_img_gray反向
arr_img_new = 255 - arr_img_gray
plt.figure(figsize=(10, 5))

plt.subplot(121)
plt.axis("off")
plt.imshow(arr_img_gray, cmap="gray")

plt.subplot(122)
plt.axis("off")
plt.imshow(arr_img_new, cmap="gray")

plt.show()

# 对图像的缩放、旋转和镜像
# 缩放图像
# 图像对像.resize((width,height))
# 图像对象.thumbnail((width,height))
plt.figure(figsize=(5, 5))
img_small = img.resize((64, 64))

plt.imshow(img_small)
plt.show()
img_small.save("lena_s.jpg")

# 旋转、镜像
# 图像对象.trandpose(旋转方式)
import matplotlib.pyplot as plt
from PIL import Image

plt.rcParams["font.sans-serif"] = "Simhei"
img = Image.open("lena.tiff")

plt.figure(figsize=(10, 10))

# 划分子图区域，并显示图像
plt.subplot(221)
plt.axis("off")
plt.imshow(img)
plt.title("原图", fontsize=20)

plt.subplot(222)
plt.axis("off")
img_flr = img.transpose(Image.FLIP_LEFT_RIGHT)
plt.imshow(img_flr)
plt.title("左右翻转：", fontsize=20)

plt.subplot(223)
plt.axis("off")
img_flr = img.transpose(Image.ROTATE_90)
plt.imshow(img_flr)
plt.title("逆时针旋转90度：", fontsize=20)

plt.subplot(224)
plt.axis("off")
img_flr = img.transpose(Image.TRANSPOSE)
plt.imshow(img_flr)
plt.title("转置：", fontsize=20)

plt.show()

# 裁剪
# .crop()
import matplotlib.pyplot as plt
from PIL import Image

img = Image.open("lena.tiff")

plt.figure(figsize=(10, 5))

plt.subplot(121)  # 绘制子图区域
plt.imshow(img)  # 显示原图

plt.subplot(122)
img_region=img.crop((100,100,600,500))
plt.imshow(img_region)

plt.show()

Matplotlib

# import matplotlib.pyplot as plt

'''
Figure 对象
    figure(num,figsize,dpi,facecolor,edgecolor,frameon)
    

    num:图形编号或名称（数字/字符串）
    figsize:绘图对象的宽和高，单位为英寸
    dpi:绘图对象的分辨率，缺省值为80
    facecolor:背景颜色
    edgecolor:边框颜色
    frameon:是否显示边框 

Figure 对象---划分子图  
    subplot(行数，列数，子图序号)
'''

# import matplotlib.pyplot as plt

#

# plt.figure(figsize=(3,2),facecolor='green')

# plt.plot()  # plot() 绘制空白图形

# plt.show()  # 显示出来

#

# import matplotlib.pyplot as plt

# fig = plt.figure()

# plt.subplot(221)

# plt.subplot(222)

# plt.subplot(223)

# plt.show()

'''
设置中文字体
plt.rcParams["font.sans-serif"] = "SimHei"
    rcParams:run configuration Params即运行配置参数
    ["font.sans-serif"] :字体
    "SimHei"：中文黑体
添加标题
    添加全局标题
        suptitle(标题文字)
    添加子标题
        title(标题文字)
        
tight_layout()函数 调整间隔
    检查坐标轴标签、刻度标签、子图标题，自动调整子图，使之自动填充整个绘图区域
    并消除子图之间的重叠
    tight_layout(rect=[left,bottom,right,top])
    
'''
import matplotlib.pyplot as plt

plt.rcParams["font.family"] = "SimHei"

fig = plt.figure(facecolor="lightgrey")

plt.subplot(221)
plt.title('子标题1')
plt.subplot(222)
plt.title('子标题2', loc='left', color='b')
plt.subplot(223)
myfontdict = {
     'fontsize': 12, 'color': 'g', 'rotation': 30}
plt.title('子标题3', fontdict=myfontdict)
plt.subplot(224)
plt.title('子标题4', color='white', backgroundcolor='black')

plt.suptitle('全局标题', fontsize=20, color='red', backgroundcolor='yellow')
plt.tight_layout(rect=[0, 0, 1, 0.9])  # 自动调整间隔使子图充满整个画布
plt.show()

# 散点图的绘制（scatter）:数据点在直角坐标系中的分布图

'''
scatter(x,y,scale,color,marker,label)
text(x,y,s,fontsize,color)

增加均匀分布的点
增加图例 在scatter函数中的label属性中添加图例内容即可
        legend(loc,fontsize)显示图例 loc图例显示位置 fontsize字的大小
'''
import matplotlib.pyplot as plt  # 导入绘图库
import numpy as np  # 导入numpy库

plt.rcParams['font.sans-serif'] = 'SimHei'  # 设置中文黑体为默认字体
plt.rcParams['axes.unicode_minus'] = False  # 正常显示负号

n = 1024  # 随机点个数
x1 = np.random.normal(0, 1, n)  # 生成数据点x坐标
y1 = np.random.normal(0, 1, n)  # 生成数据点y坐标
x2 = np.random.uniform(-4, 4, (1, n))
y2 = np.random.uniform(-4, 4, (1, n))

plt.scatter(x1, y1, color='blue', marker='*', label='正态分布')  # 绘制数据点
plt.scatter(x2, y2, color='yellow', marker='o', label='均匀分布')

plt.legend()  # legend() 函数显示字体
plt.title('标准正态分布', fontsize=20)  # 设置标题

# plt.text(2.5, 2.5, '均 值：0\n标准差：1')  # 显示文本

plt.xlim(-4, 4)  # x轴范围
plt.ylim(-4, 4)  # y轴范围

plt.xlabel('横坐标x', fontsize=14)  # 设置x轴标签文本
plt.ylabel('纵坐标y', fontsize=14)  # 设置y轴标签文本

plt.show()  # 显示绘图

# 绘制折线图(在散点图的基础上将相邻的点用线段连接起来

'''
plot 绘制
plot(x,y,color,marker,label,linewidth,markersize)函数 绘制折线图
'''
import matplotlib.pyplot as plt
import numpy as np

plt.rcParams['font.sans-serif'] = 'SimHei'  # 转成在中文字体

n = 24  # 生成24个点
y1 = np.random.randint(27, 37, n)  # 生成随机数列
y2 = np.random.randint(40, 60, n)  # 生成随机数列

plt.plot(y1, label='温度')  # 绘制折线图   将上面产生的随机数作为y坐标
plt.plot(y2, label='湿度')  # 绘制折线图   将上面产生的随机数作为y坐标

plt.xlim(0, 23)  # 设置坐标轴范围
plt.ylim(20, 70)  # 设置坐标轴范围
plt.xlabel('小时', fontsize=12)
plt.ylabel('测量值', fontsize=12)

plt.title('24小时温度湿度统计')  # 设置标题

plt.legend()
plt.show()

# 绘制柱形图

'''
使用bar函数绘制柱形图
bar(left,height,width,facecolor,edgecolor,label)
facecolor 填充色
edgecolor 边缘颜色
'''
import numpy as np
import matplotlib.pyplot as plt  # 导入库

plt.rcParams['font.sans-serif'] = 'SimHei'
plt.rcParams['axes.unicode_minus'] = False  # 设置rc参数

y1 = [32, 25, 16, 30, 24, 45, 40, 33, 28, 17, 24, 20]
y2 = [-23, -35, -26, -35, -45, -43, -35, -32, -23, -17, -22, -28]

plt.bar(range(len(y1)), y1, width=0.8, facecolor='green', edgecolor='white', label='统计量1')  # 绘制柱形条纹
plt.bar(range(len(y2)), y2, width=0.8, facecolor='red', edgecolor='white', label='统计量2')

plt.title("柱状图", fontsize=20)  # 显示标题

plt.legend()  # 显示图例
plt.show()  # 显示整个绘图

'''
matplotlib官网有图和源程序
'''

鸢尾花数据集 手写图像minist数据集

鸢尾花数据集

# 鸢尾花数数据集
# 下载数据集（鸢尾花数据集不是tensorflow和keras中集成的内部数据集）
'''
get_file() 函数————下载数据集

csv文件是一种字符分割的文件，以纯文本的形式存储表格数据可以使用记事本打开也可以

在指定网络中下载数据集用：
        tf.keras.utils.get_file(fname,origin,cache_dir)
        fname :下载后的文件名
        origin :文件的URL地址
        cache_dir:下载后文件的存储位置
'''
# 下载鸢尾花数据集 iris
import tensorflow as tf

TRAIN_URL = "http://download.tensorflow.org/data/iris_training.csv"
train_path = tf.keras.utils.get_file("iris_training.csv", TRAIN_URL)
fname_list = TRAIN_URL.split('/')
print(fname_list[-1])

# Pandas 访问csv文件
'''
Pandas 库（Panel Data & Data Analysis）
    用于数据统计和分析
    可以高效、方便地操作大型数据集
    # 导入Pandas库
    import pandas as pd
    # 读取csv数据集文件
    pd.read_csv(filepath_or_buffle,header,names)
    names参数：自定义标题，代替header=0参数指定的列标题 names参数的值时一个列表
    # 访问数据
    head()函数：参数为空时，默认读取二维数据列表中的前五行数据
    tail(n)函数：读取后n行数据
    使用切片    df_iris[10:16] 表示读取10~15行数据
    # 显示统计信息
    describe()方法：显示二维数据的统计信息(总数、平均值、标准差、最大值、最小值、25%、50%、75%     numpy
    dataframe中也有显示数据集属性的方法：  .ndim维数   .shape形状    .size元素个数        pandas
       
    
'''
import pandas as pd
import numpy as np

COLUMN_NAMES = ['Sepallength', 'SepalWidth', 'PetaLength', 'PetalWidth', 'Spacies']
df_iris = pd.read_csv(train_path, header=0, names=COLUMN_NAMES)

# print(train_path)
print(df_iris.head(8))  # 读取前8行数据
print(df_iris.tail(8))  # 读取后8行数据
print(df_iris[10:16])  # 读取10~15行数据
print(df_iris.describe())
print(type(df_iris))  # class 'pandas.core.frame.DataFrame'> dataframe是二维表格类型
print(df_iris.ndim)
print(df_iris.shape)
print(df_iris.size)
'''转化为Numpy数组'''
iris = np.array(df_iris)
print(type(iris))  #  转化为了numpy数组对象

# 色彩映射
'''
plt.scatter(x,y,c,cmap)
将参数c指定为一个列表或数组，所绘制图形的颜色，可以随这个列表中的元素值而变换，变换所对应得颜色由参数cmap中指定得颜色所提供
'''
import matplotlib.pyplot as plt

plt.scatter(iris[:, 2], iris[:, 3], c=iris[:, 4], cmap='brg')
plt.show()

# 完整程序
import tensorflow as tf
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

# 下载数据集文件
TRAIN_URL = "http://download.tensorflow.org/data/iris_training.csv"
train_path = tf.keras.utils.get_file("iris_training.csv", TRAIN_URL)

# 定义类标题列表 读取数据集文件
COLUMN_NAMES = ['Sepallength', 'SepalWidth', 'PetaLength', 'PetalWidth', 'Spacies']
df_iris = pd.read_csv(train_path, header=0, names=COLUMN_NAMES)

# 将pandas二维数据表转换成numpy二维数组
iris = np.array(df_iris)

# 绘制散点图
plt.scatter(iris[:, 2], iris[:, 3], c=iris[:, 4], cmap='brg')
# 添加散点图的名称 颜色说明
plt.title("Anderson's Iris Data Set\n(Bule->Setosa | Red->Versicolor |Green->Virginica)")
# 设置坐标轴标签 标签直接从列标题列表中得到
plt.xlabel(COLUMN_NAMES[2])
plt.ylabel(COLUMN_NAMES[3])
plt.show()

# 设置画布尺寸
fig = plt.figure('Iris Data', figsize=(15, 15))

# 设置整个绘图的标题
fig.suptitle("Anderson's Iris Data Set\n(Blue->Setosa | Red->Versicolor | Green->virginica")

# for循环绘制子图
for i in range(4):
    for j in range(4):
        #  所绘制子图的行数，列数及子图序号
        plt.subplot(4, 4, 4 * i + (j + 1))  # subplot(行数，列数，子图序号)
        if (i==j):
            plt.text(0.3,0.4,COLUMN_NAMES[i],fontsize=15)
        else:
            plt.scatter(iris[:, j], iris[:, i], c=iris[:, 4], cmap='brg')
        if (i==0):
            plt.title(COLUMN_NAMES[j])
        else:
            plt.ylabel(COLUMN_NAMES[i])

# 调整子图间距
plt.tight_layout(rect=[0, 0, 1, 0.93])
# 显示绘图
plt.show()

手写数字图像数据集MINIST

# 下载MINIST数据集
import tensorflow as tf

mnist = tf.keras.datasets.mnist
(train_x, train_y), (test_x, test_y) = mnist.load_data()

# 分别输出训练集，和测试集的长度
print("Training set:", len(train_x))
print("Testing set:", len(test_x))
# Training set: 60000
# Testing set: 10000
# 输出数据的形状
print("Training set:", train_x.shape, train_x.dtype)
print("Training set:", train_y.shape, train_y.dtype)
# Training set: (60000, 28, 28) uint8
# Training set: (60000,) uint8
# uint8 表示8位无符号整数

# 显示图片
import matplotlib.pyplot as plt
import numpy as np

plt.axis("off")
plt.imshow(train_x[0], cmap="gray")
plt.show()
print(train_y[0])  # 输出标签 显示5

# 随机显示4幅手写数字图片
# 导入需要的库
import tensorflow as tf
import matplotlib.pyplot as plt
import numpy as np

# 加载数据集
mnist = tf.keras.datasets.mnist
(train_x, train_y), (test_x, test_y) = mnist.load_data()

# 绘图
for i in range(4):
    num = np.random.randint(1, 60000)

    plt.subplot(1, 4, i + 1)
    plt.axis("off")
    plt.imshow(train_x[num], cmap="gray")
    plt.title(train_y[num])

plt.show()

numpy实现一元线性回归

'''
numpy实现一元线性回归步骤：
    1.加载数据
    2.设置超参数
    3.设置模型参数初值
    4.训练模型



'''

import numpy as np
import matplotlib.pyplot as plt

# 设置中文字体
plt.rcParams['font.sans-serif'] = ['SimHei']

# 1.加载数据
x = np.array([137.97, 104.50, 100.00, 124.32, 79.20, 99.00, 124.00, 114.00,
                 106.69, 138.05, 53.75, 46.91, 68.00, 63.02, 81.26, 86.21])
y = np.array([145.00, 110.00, 93.00, 116.00, 65.32, 104.00, 118.00, 91.00,
                  62.00, 133.00, 51.00, 45.00, 78.50, 69.65, 75.69, 95.31])

# 2.设置超参数
learn_rate = 0.0001  # 设置学习率
iter = 10 # 设置迭代次数 循环次数设置为100次

disply_step = 1  # 显示间隔    每隔10次显示一次

# 3.设置模型初值
np.random.seed(612)
w = np.random.randn()  # 作为W的初值
b = np.random.randn()

# 4.训练模型
mse = []

for i in range(0, iter + 1):

    # 计算梯度
    dL_dw = np.mean(x * (w * x + b - y))  # 偏导数求梯度
    dL_db = np.mean(w * x + b - y)
    # 使用梯度的结果更新模型的参数
    w = w - learn_rate * dL_dw  # 更新权值
    b = b - learn_rate * dL_db
    # 使用更新后的模型参数计算房价的估计值和均方误差
    pred = w * x + b  # 计算房价的估计值
    Loss = np.mean(np.square(y - pred)) / 2  # 计算均方误差作为损失值
    mse.append(Loss)  # 追加到列表中

    # plt.plot(x,pred)

    if i % disply_step == 0:
        print("i:%i,Loss:%f,w:%f,b:%f" % (i, mse[i],w,b))  # 每隔50次迭代显示一次当前的迭代次数和损失值

# 结果可视化
plt.figure(figsize=(12, 4))

plt.subplot(1, 2, 1)
plt.plot(mse)  # 子图一中绘制损失的变化曲线
plt.xlabel("Iteration", fontsize=14)
plt.ylabel("Loss", fontsize=14)

plt.subplot(1, 2, 2)
pred = pred.reshape(-1)
plt.plot(y, color="red", marker="o", label="销售记录")  # 子图二中绘制样本数据
plt.plot(pred, color="blue", marker=".", label="预测房价")  # 绘制模型的预测数据
plt.xlabel("Sample", fontsize=14)
plt.ylabel("Price", fontsize=14)

plt.legend()
plt.show()

import numpy as np
import matplotlib.pyplot as plt

# 设置中文字体
plt.rcParams['font.sans-serif'] = ['SimHei']

# 加载数据
x = np.array([137.97, 104.50, 100.00, 124.32, 79.20, 99.00, 124.00, 114.00,
              106.69, 138.05, 53.75, 46.91, 68.00, 63.02, 81.26, 86.21])
y = np.array([145.00, 110.00, 93.00, 116.00, 65.32, 104.00, 118.00, 91.00,
              62.00, 133.00, 51.00, 45.00, 78.50, 69.65, 75.69, 95.31])

# 设置超参数
learn_rate = 0.0001  # 设置学习率
iter = 10  # 设置迭代次数 循环次数设置为100次

disply_step = 1  # 显示间隔    每隔10次显示一次

# 设置模型初值
np.random.seed(612)
w = np.random.randn()  # 作为W的初值
b = np.random.randn()

# 训练模型
mse = []
for i in range(0, iter + 1):

    # 放在前面可以看到使用初始值时的损失值
    pred = w * x + b  # 计算房价的估计值
    Loss = np.mean(np.square(y - pred)) / 2  # 计算均方误差作为损失值
    mse.append(Loss)  # 追加到列表中

    # 计算梯度
    dL_dw = np.mean(x * (w * x + b - y))  # 计算偏导数
    dL_db = np.mean(w * x + b - y)
    # 使用梯度的结果更新模型的参数
    w = w - learn_rate * dL_dw  # 更新权值
    b = b - learn_rate * dL_db


    # plt.plot(x,pred)

    if i % disply_step == 0:
        print("i:%i,Loss:%f,w:%f,b:%f" % (i, mse[i], w, b))  # 每隔50次迭代显示一次当前的迭代次数和损失值

# 结果可视化
plt.figure(figsize=(12, 4))

plt.subplot(1, 2, 1)
plt.plot(mse)  # 子图一中绘制损失的变化曲线
plt.xlabel("Iteration", fontsize=14)
plt.ylabel("Loss", fontsize=14)

plt.subplot(1, 2, 2)
pred = pred.reshape(-1)
plt.plot(y, color="red", marker="o", label="销售记录")  # 子图二中绘制样本数据
plt.plot(pred, color="blue", marker=".", label="预测房价")  # 绘制模型的预测数据
plt.xlabel("Sample", fontsize=14)
plt.ylabel("Price", fontsize=14)

plt.legend()
plt.show()

numpy实现多元线性回归

'''
# Numpy实现多元线性回归步骤：
                1.加载数据
                2.数据处理(对样本属性进行归一化，并转换为模型需要的二维数组)
                3.设置超参数
                4，设置模型参数的初始值
                5.训练模型
'''


import numpy as np
import matplotlib.pyplot as plt

# 设置中文字体
plt.rcParams['font.sans-serif'] = ['SimHei']

# 1.加载数据
area = np.array([137.97, 104.50, 100.00, 124.32, 79.20, 99.00, 124.00, 114.00,
                 106.69, 138.05, 53.75, 46.91, 68.00, 63.02, 81.26, 86.21])
room = np.array([3, 2, 3, 1, 2, 3, 2, 2, 3, 1, 1, 1, 1, 2, 2, 2])
price = np.array([145.00, 110.00, 93.00, 116.00, 65.32, 104.00, 118.00, 91.00,
                  62.00, 133.00, 51.00, 45.00, 78.50, 69.65, 75.69, 95.31])
# 样本数量
num = len(area)

# 2.数据处理(对样本属性进行归一化，并转换为模型需要的二维数组)
# 创建值全为1的一维数组
x0 = np.ones(num)

# 对商品房面积和房间数进行归一化处理
x1 = (area - area.min()) / (area.max() - area.min())
x2 = (room - room.min()) / (room.max() - room.min())

# 将x0,x1,x2堆叠为形状为（16，3）的二维数组
X = np.stack((x0, x1, x2), axis=1)
# 将房价转化为（16，1）的二维数组
Y = price.reshape(-1, 1)

# 3.设置超参数
learn_rate = 0.01  # 设置学习率
iter = 50  # 设置迭代次数 循环次数设置为500次

disply_step = 10  # 显示间隔    每隔50次显示一次

# 4.设置模型参数的初始值
np.random.seed(612)
W = np.random.randn(3, 1)  # 随机生成形状为（3，1）的数组作为W的初值

# 5.训练模型
mse = []

for i in range(0, iter + 1):

    PRED = np.matmul(X, W)  # 线性模型表达式   计算房价的估计值
    Loss = np.mean(np.square(Y - PRED)) / 2  # 损失函数的表达式     计算均方误差作为损失值
    mse.append(Loss)  # 追加到列表中

    dL_dW = np.matmul(np.transpose(X), np.matmul(X, W) - Y)  # 计算梯度     计算偏导数
    W = W - learn_rate * dL_dW  # 更新模型     更新权值

    if i % disply_step == 0:
        print("i:%i,Loss:%f" % (i, mse[i]))  # 每隔50次迭代显示一次当前的迭代次数和损失值

# 结果可视化
plt.figure(figsize=(12, 4))

plt.subplot(1, 2, 1)
plt.plot(mse)  # 子图一中绘制损失的变化曲线
plt.xlabel("Iteration", fontsize=14)
plt.ylabel("Loss", fontsize=14)

plt.subplot(1, 2, 2)
PRED = PRED.reshape(-1)
plt.plot(price, color="red", marker="o", label="销售记录")  # 子图二中绘制样本数据
plt.plot(PRED, color="blue", marker=".", label="预测房价")  # 绘制模型的预测数据
plt.xlabel("Sample", fontsize=14)
plt.ylabel("Price", fontsize=14)

plt.legend()
plt.show()

TensorFlow实现多元线性回归

# TensorFlow实现多元线性回归


import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf

# 设置中文字体
plt.rcParams['font.sans-serif'] = ['SimHei']

# 1.加载数据
area = np.array([137.97, 104.50, 100.00, 124.32, 79.20, 99.00, 124.00, 114.00,
              106.69, 138.05, 53.75, 46.91, 68.00, 63.02, 81.26, 86.21])
room = np.array([3, 2, 3, 1, 2, 3, 2, 2, 3, 1, 1, 1, 1, 2, 2, 2])
price = np.array([145.00, 110.00, 93.00, 116.00, 65.32, 104.00, 118.00, 91.00,
              62.00, 133.00, 51.00, 45.00, 78.50, 69.65, 75.69, 95.31])

num = len(area)
# 2.数据处理(对样本属性进行归一化，并转换为模型需要的二维数组)
# 创建值全为1的一维数组
x0 = np.ones(num)

# 对商品房面积和房间数进行归一化处理
x1 = (area - area.min()) / (area.max() - area.min())
x2 = (room - room.min()) / (room.max() - room.min())

# 将x0,x1,x2堆叠为形状为（16，3）的二维数组
X = np.stack((x0, x1, x2), axis=1)
# 将房价转化为（16，1）的二维数组
Y = price.reshape(-1, 1)

# 3.设置超参数
learn_rate = 0.3  # 设置学习率
iter = 50  # 设置迭代次数 循环次数设置为100次

disply_step = 50  # 显示间隔    每隔10次显示一次

# 4.设置模型参数初始值
np.random.seed(621)
W = tf.Variable(np.random.randn(3, 1))  # 为了能被梯度带自动监视，将w,b封装为Variable对象
b = tf.Variable(np.random.randn())

# 5.训练模型
mse = []

for i in range(0, iter + 1):
    with tf.GradientTape() as tape:
        PRED = tf.matmul(X, W)  # 线性模型表达式   计算房价的估计值
        Loss = tf.reduce_mean(tf.square(Y - PRED)) / 2  # 损失函数的表达式     计算均方误差作为损失值
    mse.append(Loss)  # 追加到列表中

    dL_dW = tape.gradient(Loss,W)  # 计算梯度     计算偏导数
    W.assign_sub(learn_rate*dL_dW)  # 更新模型     更新权值

    if i % disply_step == 0:
        print("i:%i,Loss:%f" % (i, Loss))

TensorFlow实现梯度下降法

# TensorFlow实现梯度下降法

import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf

# 设置中文字体
plt.rcParams['font.sans-serif'] = ['SimHei']

# 1.加载数据
x = np.array([137.97, 104.50, 100.00, 124.32, 79.20, 99.00, 124.00, 114.00,
              106.69, 138.05, 53.75, 46.91, 68.00, 63.02, 81.26, 86.21])
y = np.array([145.00, 110.00, 93.00, 116.00, 65.32, 104.00, 118.00, 91.00,
              62.00, 133.00, 51.00, 45.00, 78.50, 69.65, 75.69, 95.31])

# 2.设置超参数
learn_rate = 0.0001  # 设置学习率
iter = 10  # 设置迭代次数 循环次数设置为100次

disply_step = 1  # 显示间隔    每隔10次显示一次

# 3.设置模型参数初始值
np.random.seed(621)
w = tf.Variable(np.random.randn())  # 为了能被梯度带自动监视，将w,b封装为Variable对象
b = tf.Variable(np.random.randn())

# 4.训练模型
mse = []

for i in range(0, iter + 1):
    with tf.GradientTape() as tape:
        pred = w * x + b  # 线性模型表达式
        Loss = 0.5 * tf.reduce_mean(tf.square(y - pred))  # 损失函数的表达式
    mse.append(Loss)

    dL_dw, dL_db = tape.gradient(Loss, [w, b])  # 手动计算梯度带的代码换成使用梯度带对象的gradient方法来自动获取梯度

    w.assign_sub(learn_rate * dL_dw)  # 使用迭代公式更新模型参数 给Variable对象赋值需要使用他的assign方法  使用assign_sub方法实现减法运算
    b.assign_sub(learn_rate * dL_db)  # 使用迭代公式更新模型参数 给Variable对象赋值需要使用他的assign方法  使用assign_sub方法实现减法运算

    if i % disply_step == 0:
        print("i:%i,Loss:%f,w:%f,b:%f" % (i,Loss,w.numpy(),b.numpy()))

实现一元逻辑回归

# 逻辑回归
# 分类器：能够自动对输入的数据进行分类
#        输入：特征，输出：离散值
'''
手写数字图片————》手写数字识别
向量的形式送入分类器
28x28=784
minist手写数字数据集中每一张图片都是28x28的灰度图片 会以一个包含784各像素的一维向量的形式送入分类器中
经过分类器计算之后输出0~9十个离散的值

实现分类器：
    准备训练样本
    训练分类器
    对样本分类

  单位阶跃函数（unit-step function）

'''
# sigmoid()函数
import tensorflow as tf

print("TensorFlow version:", tf.__version__)

import numpy as np

x = np.array([1., 2., 3., 4.])

w = tf.Variable(1.)
b = tf.Variable(1.)

print(1 / (1 + tf.exp(w * x + b)))  # exp是求e得多少次方
# tf.Tensor([0.11920292 0.04742587 0.01798621 0.00669285], shape=(4,), dtype=float32)
# 结果也是一个形状位4的一维张量

# 交叉熵损失函数
y = np.array([0, 0, 1, 1])
pred = np.array([0.1, 0.2, 0.8, 0.49])
print(1 - y)  # 1-y做广播运算 结果是一维数组
print(1 - pred)

f = -tf.reduce_sum(y * tf.math.log(pred) + (1 - y) * tf.math.log(1 - pred))  # math.log()函数实现以e为底得对数运算
'''每一个样本得交叉熵损失  求和 得到所有得样本得交叉熵损失
.reduce_sum()求和
。reduce_mean() 平均交叉熵损失
'''
print(f)  # tf.Tensor(1.2649975061637104, shape=(), dtype=float64)

# 实现一元线性回归
# 1.加载数据
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

x = np.array([137.97, 104.50, 100.00, 126.32, 79.20, 99.00, 124.00, 114.000,
              106.69, 140.05, 53.75, 46.91, 68.00, 63.02, 81.26, 86.21])
y = np.array([1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0])

plt.scatter(x, y)
# 2.数据处理
x_train = x - np.mean(x)  # 对数据进行中心化
y_train = y

plt.scatter(x_train, y_train)
# 3.设置超参数和显示间隔
learn_rate = 0.005
iter = 5

disply_step = 1
# 4.设置模型变量得初始值
np.random.seed((612))
w = tf.Variable(np.random.randn())
b = tf.Variable(np.random.randn())

# 5.训练模型
cross_train = []  # 存放训练集得交叉熵损失
acc_train = []  # 存放分类集的分类准确率

for i in range(0, iter + 1):

    with tf.GradientTape() as tape:
        # 计算sigmoid函数
        pred_train = 1 / (1 + tf.exp(-(w * x_train + b)))
        # 交叉熵损失函数
        Loss_train = -tf.reduce_mean(y_train * tf.math.log(pred_train) + (1 + y_train) * tf.math.log(1 - pred_train))
        # 计算准确率 不需要进行求导运算 可以移到with语句外面
        Accuracy_train = tf.reduce_mean(tf.cast(tf.equal(tf.where(pred_train < 0.5, 0, 1), y_train), tf.float32))
    # 记录每一次迭代的交叉熵损失 和 准确率
    cross_train.append(Loss_train)
    acc_train.append(Accuracy_train)
    # 获得损失函数对w和b的偏导数
    dL_dw, dL_db = tape.gradient(Loss_train, [w, b])
    # 更新模型参数
    w.assign_sub(learn_rate * dL_dw)
    b.assign_sub((learn_rate * dL_db))
    # 输出训练过程和结果
    if i % disply_step == 0:
        print("i:%i,Train Loss:%f,Accuracy:%f" % (i, Loss_train, Accuracy_train))

波士顿房价预测01

import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf

# 1.加载数据集
boston_housing = tf.keras.datasets.boston_housing
(train_x, train_y), (test_x, test_y) = boston_housing.load_data()

print(train_x.shape, train_y.shape)  # (404, 13) (404,) 表示：404条样本，13条属性

print(test_x.shape, test_y.shape)  # (102, 13) (102,)

# 2.数据处理
x_train = train_x[:, 5]  # 取出所有训练样本中的房间数
y_train = train_y  # 房价
print(x_train.shape, y_train.shape)  # (404,) (404,) 房间数，和房价都是一维数组

x_test = test_x[:, 5]  # 测试集的房间数
y_test = test_y  # 测试集上的房价
print(x_test.shape, y_test.shape)

# 3.设置超参数
learn_rate = 0.04  # 学习率设为0。04
iter = 2000  # 迭代次数设为2000
disply_step = 200  # 显示间隔设为200

# 4.设置模型参数初始值
np.random.seed(612)
w = tf.Variable(np.random.randn())
b = tf.Variable(np.random.randn())
print(w.numpy().dtype, b.numpy().dtype)  # float32 float32

# 5.训练模型
mse_train = []  # 用来记录训练集上的损失   mse:mean square error
mse_test = []  # 用来记录测试集上的损失

for i in range(0, iter + 1):

    with tf.GradientTape() as tape:
        # 把他们放在GradientTape的with语句中实现对wb的监视
        pred_train = w * x_train + b # 计算训练集上的预测值
        loss_train = 0.5 * tf.reduce_mean(tf.square(y_train - pred_train)) # 计算训练集上的均方误差

        pred_test = w * x_test + b
        loss_test = 0.5 * tf.reduce_mean(tf.square(y_test - pred_test))

    mse_train.append(loss_train) # 把训练误差记录在列表中
    mse_test.append(loss_test)

    dL_dw, dL_db = tape.gradient(loss_train, [w, b]) # 使用训练集中的数据计算损失函数对w b的梯度
    w.assign_sub(learn_rate * dL_dw) # 使用算出的梯度更新w b
    b.assign_sub(learn_rate * dL_db)

    if i % disply_step == 0:
        print("i:%i, Train Loss:%f, Test Loss:%f" %(i,loss_train,loss_test))

'''使用训练集上的数据更新模型参数，测试集没有参与
但在每一步迭代中都使用当前的模型参数w b 计算测试集上的误差，并将其记录在mse_test列表中'''

# 6.可视化输出
plt.figure(figsize=(15,10))

plt.subplot(221)
plt.scatter(x_train,y_train,color="blue",label="data") # 绘制散点图
plt.plot(x_train,pred_train,color="red",label="model")  # 绘制模型直线
plt.legend(loc="upper left")

plt.subplot(222)
plt.plot(mse_train,color="blue",linewidth=3,label="train loss")
plt.plot(mse_test,color="red",linewidth=1.5,label="test lost")
plt.legend(loc="upper right")

plt.subplot(223)
plt.plot(y_train,color="blue",marker="o",label="true_price")
plt.plot(pred_train,color="red",marker=".",label="predict")
plt.legend()

plt.subplot(224)
plt.plot(y_test,color="blue",marker="o",label="true_price")
plt.plot(pred_test,color="red",marker=".",label="predict")
plt.legend()

plt.show()

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gjxaYeqF-1605190599122)(TensorFlow.assets/波士顿房价预测01.png)]

波士顿房价预测02

# 二维数组归一化---循环语句实现
import numpy as np

x = np.array([[3., 10., 500],
              [2., 20., 200],
              [1., 30., 300],
              [5., 50., 100]])

print(x.shape)
print(len(x))
print(x.shape[0], x.shape[1])

for i in range(x.shape[1]):
    # 对第i列归一化
    x[:, i] = (x[:, i] - x[:, i].min()) / (x[:, i].max() - x[:, i].min())

print(x)  # 循环完成之后所有的列都被归一化

# 二维数组归一化————广播运算
x = np.array([[3., 10., 500],
              [2., 20., 200],
              [1., 30., 300],
              [5., 50., 100]])

print(x.min(axis=0))  # 每一列的最小值
print(x.max(axis=0))  # 每一列的最大值
print(x.max(axis=0) - x.min(axis=0))  # 最大值减去最小值

print(x - x.min(axis=0))  # x-x.min(axis=0) 进行广播运算

print((x - x.min(axis=0)) / (x.max(axis=0) - x.min(axis=0)))  # 广播运算 实现对数组的归一化处理
'''
不用进行循环运算，代码简洁，效率更高
'''

# 波士顿房价归一化处理
# 1.导入需要的库 加载数据集
import matplotlib.pyplot as plt
import tensorflow as tf
import numpy as np

boston_housing = tf.keras.datasets.boston_housing
(train_x, train_y), (test_x, test_y) = boston_housing.load_data()

print(train_x.shape, train_y.shape)
print(test_x.shape, test_y.shape)
# 训练集和测试集中样本的数量（创建全一数组时需要使用）
num_train = len(train_x)
num_test = len(test_x)

# 2.数据处理
# 对训练样本的所有属性进行归一化
x_train = (train_x - train_x.min(axis=0)) / (train_x.max(axis=0) - train_x.min(axis=0))
y_train = train_y  # 标签y不需要归一化，但是也进行重新赋值

# 对测试样本的所有属性进行归一化
x_test = (test_x - test_x.min(axis=0)) / (test_x.max(axis=0) - test_x.min(axis=0))
y_test = test_y  # 标签y不需要归一化，但是也进行重新赋值

# 生成多元回归需要的二元数组的形式
x0_train = np.ones(num_train).reshape(-1, 1)
x0_test = np.ones(num_test).reshape(-1, 1)

X_train = tf.cast(tf.concat([x0_train, x_train], axis=1), tf.float32)  # .concat() 是tensorflow的数组堆叠函数
X_test = tf.cast(tf.concat([x0_test, x_test], axis=1), tf.float32)  # .cast() 是tensorflow的类型转换函数 指定为32位浮点数

print(X_train.shape, X_test.shape)  # (404, 14) (102, 14) 404个元素  13个属性归一化+堆叠的全为1的属性

Y_train = tf.constant(y_train.reshape(-1, 1), tf.float32)  # 把房价转换成列向量
Y_test = tf.constant(y_test.reshape(-1, 1), tf.float32)

print(Y_train.shape, Y_test.shape)

# 3.设置超参数
learn_rate = 0.01
iter = 3000
display_step = 100

# 4.设置模型变量的初始值
np.random.seed(612)
W = tf.Variable(np.random.randn(14, 1), dtype=tf.float32)

# 5.训练模型
mse_train = []
mse_test = []

for i in range(0, iter + 1):

    with tf.GradientTape() as tape:
        # 计算训练集的预测房价和损失
        PRED_train = tf.matmul(X_train, W)
        Loss_train = 0.5 * tf.reduce_mean(tf.square(Y_train - PRED_train))
        # 计算测试集的预测房价和损失
        PRED_test = tf.matmul(X_test, W)
        Loss_test = 0.5 * tf.reduce_mean(tf.square(Y_test - PRED_test))
    # 记录每一次迭代之后使用更新后的参数（模型在训练集上的损失，和在测试集上的损失值）
    mse_train.append(Loss_train)
    mse_test.append(Loss_test)
    # 使用训练集中的样本更新模型参数
    dL_dW = tape.gradient(Loss_train, W)
    W.assign_sub(learn_rate * dL_dW)

    if i % display_step == 0:
        # 输出训练集和测试集上的损失
        print("i:%i, Train Loss:%f, Test Loss:%f" % (i, Loss_train, Loss_test))

# 可视化输出
plt.figure(figsize=(20,4))

plt.subplot(131)
plt.ylabel("MSE")
plt.plot(mse_train,color="blue",linewidth=3)# mse:mean square error 均方误差
plt.plot(mse_test,color="red",linewidth=1.5)

plt.subplot(132)
plt.plot(y_train,color="blue",marker="o",label="true_price") # .polt() 绘制线图
plt.plot(PRED_train,color="red",marker=".",label="predict")
plt.legend(loc="upper right")  # .legend() 显示图中标签
plt.ylabel("Price")

plt.subplot(133)
plt.plot(y_test,color="blue",marker="o",label="true_price")
plt.plot(PRED_test,color="red",marker=".",label="predict")
plt.legend()
plt.ylabel("Price")

plt.show()

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TEurexsc-1605190599128)(TensorFlow.assets/波士顿房价预测02.png)]

波士顿房价可视化

'''
keras:
  是一个高层的神经网络和深度学习库
  可以快速搭建神经网络模型，非常易于调试和扩展
  Tensorflow的官方API
  内置了一些常用的公共数据库，可以通过Keras.datasets模块加载和访问

在机器学习中通常将数据集划分为：训练数据集和测验数据集
'''
# 加载和使用kears中的内置数据集
# 加载数据集
'''
tensorflow.keras.datasets.boston_housing
tensorflow.keras 意思：是keras API 在tensorflow中的实现
'''
import tensorflow as tf

boston_housing = tf.keras.datasets.boston_housing

(train_x, train_y), (test_x, test_y) = boston_housing.load_data(test_split=0)  # 使用这个数据集中的load_data方法加载数据集
'''train_x和train_y接受训练数据集的数据
可以使用test_split=0.2 改变测试数据集在数据集中所占的比例'''
print('Training set:', len(train_x))
print('Testing set:', len(test_x))

print(type(train_x))
print(type(train_y))

print('Dim of train_x:', train_x.ndim)
print('Shape of train_x:', train_x.shape)
# Training set: 506
# Testing set: 0
# 
# 
# Dim of train_x: 2
# Shape of train_x: (506, 13)

print(train_x[:5])  # train_x中的前五行数据

# 绘制散点图（平均房间数与房价之间的关系）
import matplotlib.pyplot as plt
import numpy as np
import tensorflow as tf

boston_housing = tf.keras.datasets.boston_housing
(train_x, train_y), (_, _) = boston_housing.load_data(test_split=0)

plt.figure(figsize=(5, 5))  # 设置绘图尺寸
plt.scatter(train_x[0:,5], train_y)  # 绘制散点图
plt.xlabel('RM')  # 设置x轴标签文本
plt.ylabel("Price($1000's)")  # 设置y轴标签文本
plt.title("5.RM-Price")  # 设置标题
plt.show()  # 显示绘图

# 波士顿房价数据集可视化
import matplotlib.pyplot as plt
import numpy as np
import tensorflow as tf

# 加载数据集
boston_housing = tf.keras.datasets.boston_housing
(train_x,train_y),(_,_) = boston_housing.load_data(test_split=0)

# 设置运行时参数
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus']=False

# 定义属性标题列表
titles = ["CRIM","ZN","INDUS","CHAS","NOX","RM","AGE",
          "DIS","RAD","TAX","PTRATIO","B-1000","LSTAT","MEDV"]

# 设置画布尺寸
plt.figure(figsize=(12,12)) # 设置画布尺寸

# 执行循环体 分别绘制13个子图
for i in range(13):
    plt.subplot(4,4,(i+1))
    plt.scatter(train_x[:,i],train_y)
    plt.xlabel(titles[i])   # 子图x轴标签
    plt.ylabel("Price($1000's)")    # 子图y轴标签
    plt.title(str(i+1)+'.'+titles[i]+" - Price")    # 子图标题

plt.tight_layout(rect=[0, 0, 1, 0.9])  # 调整子图间隔
plt.suptitle("各个属性与房价的关系",x=0.5,y=1.02,fontsize=20) # 设置全局标题
plt.show()

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-H4fHodMv-1605190599130)(TensorFlow.assets/波士顿房价可视化01.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YJ2UMwpu-1605190599133)(TensorFlow.assets/波士顿房价可视化02.png)]

梯度下降法求多元线性回归

import numpy as np
import matplotlib.pyplot as plt

# 设置中文字体
plt.rcParams['font.sans-serif'] = ['SimHei']

# 1.加载数据
area = np.array([137.97, 104.50, 100.00, 124.32, 79.20, 99.00, 124.00, 114.00,
                 106.69, 138.05, 53.75, 46.91, 68.00, 63.02, 81.26, 86.21])
room = np.array([3, 2, 3, 1, 2, 3, 2, 2, 3, 1, 1, 1, 1, 2, 2, 2])
price = np.array([145.00, 110.00, 93.00, 116.00, 65.32, 104.00, 118.00, 91.00,
                  62.00, 133.00, 51.00, 45.00, 78.50, 69.65, 75.69, 95.31])
# 样本数量
num = len(area)

# 2.数据处理
# 创建值全为1的一维数组
x0 = np.ones(num)

# 对商品房面积和房间数进行归一化处理
x1 = (area - area.min()) / (area.max() - area.min())
x2 = (room - room.min()) / (room.max() - room.min())

# 将x0,x1,x2堆叠为形状为（16，3）的二维数组
X = np.stack((x0, x1, x2), axis=1)
# 将房价转化为（16，1）的二维数组
Y = price.reshape(-1, 1)

# 3.设置超参数
learn_rate = 0.001  # 设置学习率
iter = 6000  # 设置迭代次数 循环次数设置为500次

disply_step = 30  # 显示间隔    每隔50次显示一次

# 设置模型参数的初始值
np.random.seed(612)
W = np.random.randn(3, 1)  # 随机生成形状为（3，1）的数组作为W的初值

# 4.训练模型
mse = []
for i in range(0, iter + 1):
    dL_dW = np.matmul(np.transpose(X), np.matmul(X, W) - Y)  # 计算偏导数
    W = W - learn_rate * dL_dW  # 更新权值

    PRED = np.matmul(X, W)  # 计算房价的估计值
    Loss = np.mean(np.square(Y - PRED)) / 2  # 计算均方误差作为损失值
    mse.append(Loss)  # 追加到列表中

    if i % disply_step == 0:
        print("i:%i,Loss:%f" % (i, mse[i]))  # 每隔50次迭代显示一次当前的迭代次数和损失值

# 5.结果可视化
plt.figure(figsize=(12, 4))

plt.subplot(1, 2, 1)
plt.plot(mse)  # 子图一中绘制损失的变化曲线
plt.xlabel("Iteration", fontsize=14)
plt.ylabel("Loss", fontsize=14)

plt.subplot(1, 2, 2)
PRED = PRED.reshape(-1)
plt.plot(price, color="red", marker="o", label="销售记录")  # 子图二中绘制样本数据
plt.plot(PRED, color="blue", marker=".", label="预测房价")  # 绘制模型的预测数据
plt.xlabel("Sample", fontsize=14)
plt.ylabel("Price", fontsize=14)

plt.legend()
plt.show()

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-itTKgmVS-1605190599141)(TensorFlow.assets/梯度下降法.png)]