创建张量
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))
# <class 'tensorflow.python.framework.ops.EagerTensor'>表示其是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) 打印出张量的所有内容
# <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.Tensor: shape=(), dtype=int32, numpy=12>, <tf.Tensor: shape=(), dtype=int32, numpy=0>)
# (<tf.Tensor: shape=(), dtype=int32, numpy=23>, <tf.Tensor: shape=(), dtype=int32, numpy=1>)
# (<tf.Tensor: shape=(), dtype=int32, numpy=10>, <tf.Tensor: shape=(), dtype=int32, numpy=1>)
# (<tf.Tensor: shape=(), dtype=int32, numpy=17>, <tf.Tensor: shape=(), dtype=i
'''
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]]
# <class 'numpy.ndarray'>
# <class 'numpy.matrix'>
'''
矩阵对象的属性：
.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)) # <class 'numpy.ndarray'> 转化为了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
# <class 'numpy.ndarray'>
# <class 'numpy.ndarray'>
# 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)]
扫一扫
698
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
