deepCNN learning

深度卷积神经网络（CNN）学习第一天

Python中面向对象的思想（类）

类与对象

1.类的定义

class 类名：   
    定义数据成员   
    定义成员函数

2.构造函数和析构函数

构造函数：def__init__(self,参数表)
析构函数：可省，用默认

class Circle:
    def __init__(self,r=10):
        self.__radius = r
    def Area(self):
        return 3.1416*self.__radius*self.__radius
    def peri(self):
        t = 2*3.1416*self.__radius
        print("周长为：{:.2f}".format(t))
cir1 = Circle(6)
cir2 = Circle()
print(cir1._Circle__radius)
print(cir2._Circle__radius)
print(cir1.Area())
cir1.peri()
## print({:.2f}.format(cir1.Area()))          #注意：format()格式化里面不能放函数，错误
## 可以用位置参数，索引，也可以可用字典当关键字参数传入值。

6
10
113.0976
周长为：37.70

3.私有成员和公有成员

1.基类或派生类中**受保护成员** ：一个_   _r 
2.私有成员：两个或多个_    __r,___r    
3.其他命名方式为公有成员

4.数据成员

1.类成员  定义在函数外  该类所有对象共享类成员  既可以类名访问，也可以对象名访问
2.对象成员  定义在函数外  只能对象访问

5.成员函数

1.对象函数  可以访问函数内的数据成员和类成员
2.类方法(函数)  修饰器 @classmethod 后定义  至少有一个cls对象做参数，表示该类自身
3.静态函数（方法）修饰器 @staticmethod   可以没有参数
(类方法和静态方法只能访问类成员)

#摄氏温度与华氏温度相互转换
class Temperature:
    @classmethod
    def form1(cls,t1):           #从摄氏温度到华氏温度的转化
        t1 = float(t1)
        t2 = (t1*9/5)+32
        return t2
    @staticmethod
    def form2(t3):
        t3 = float(t3)
        t2 = (t3-32)*5/9
        return t2

print ("1.从摄氏温度到华氏温度.")
print ("2.从华氏温度到摄氏温度.")
x = eval(input("请选择转换方向:"))
if x==1:
    t1 = eval(input("请输入摄氏温度："))
    t2 = Temperature.form1(t1)
    print("华氏温度为：{:.2f}".format(t2))
elif x == 2:
    t3 = eval(input("请输入华氏温度："))
    t2 = Temperature.form2(t3)
    print("摄氏温度为：{:.2f}".format(t2))
else:
    print("无此选项，只能选择1或2!")
    

1.从摄氏温度到华氏温度.
2.从华氏温度到摄氏温度.
请选择转换方向:2
请输入华氏温度：212
摄氏温度为：100.00

---

注意：

• 如果在类外调用函数，前面需要写类名，调用类数据成员格式：Class._Class+数据成员
• 如果

---

继承与多态

继承与派生

语法格式：     
class 派生类名（基类名）:   
定义新增数据成员（形参表里还是要带上基类）    
定义新增的成员函数   

**注意：派生类涉及到的访问属性由变量名格式决定（还要注意private和public的区别）

#引例
class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def output1(self):
        print("大家好，我叫{0},{1}岁".format(self.name,self.age))
class Student(Person):
    def __init__(self,name,age,stu_num):
        Person.__init__(self,name,age)        #重载函数时为了调用时不混淆，需要在前面加类名，传入的参数为当前对象即可
        self.stu_num = stu_num
    def output2(self):
        self.output1()
        print("我是学生，我的学号为：{}".format(self.stu_num))

p1 = Person('张三',25)
p2 = Student('李四',22,2020201131)
p1.output1()
p2.output2()

大家好，我叫张三,25岁
大家好，我叫李四,22岁
我是学生，我的学号为：2020201131

多态–函数重载

新的重载函数覆盖基类

4.4 Python 基础工具库

4.4.1NumPy

1.NumPy 数组的创建

N维数组对象ndarray,一系列同类型数据的集合，以0为下标进行集合的索引。   
创建数组的三种方法：

(1)使用Numpy内置功能函数
arange()快速创建一维数组
reshape()变形一维数组使之变成多维
(2)从Python列表转换
创建Python列表，并作为参数传入array中

import numpy as np
list = [4,5,6]
array = np.array(list)
print (array)
print(type(array))

[4 5 6]
<class 'numpy.ndarray'>

(3)使用特殊的库函数
np.random.random((3,4)) #创建3乘4的随机数组，参数表为行数和列数

2.NumPy中的数组索引与访问

(1)下标直接索引法

import numpy as np
list = [[4,5],[6,1]]
array = np.array(list)
print(array[0][1])         #下标索引第0行第1列的元素

5

(2)采用切片方式
内置函数slice(),设置start,stop及step参数，对NumPy数组进行切片。

#slice()
import numpy as np
a = np.arange(10)
s = slice(0,10,2)
print (a[s])

[0 2 4 6 8]

#各种奇形怪状的切片
import numpy as np
a = np.array([[1,2,3,4],[5,6,7,8],[9,8,6,5]])
b = a[:2,1:3]
print(b)

[[2 3]
 [6 7]]

注意：array（）中","是分隔符，前面是对行的筛选，后面是对列的筛选
切片中出现-1,-2等等表示从右向左的第几个列或行 （注意：遍历还是都是从左向右）
使用切片时第一个不能是逗号

此处写一下我自己调试后对切片的理解
就像矩阵一样，前半部分对行操作，你就把那几行用笔标出来，后半部分对列操作，挑选那几列，标出来，
最后相交的元素构成的行与列形成了新的数组，按行写[] [[],[],[]]

import numpy as np
a = np.array([[1,2,3,4],[5,6,7,8],[9,8,6,5]])
print(a[:2])
print(a[1])
print(a[:,-1:])

[[1 2 3 4]
 [5 6 7 8]]
[5 6 7 8]
[[4]
 [8]
 [5]]

NumPy中的数学运算

可以在数组上进行数学运算

import numpy as np
A = np.array([[1,1],[0,1]])
B = np.array([[2,0],[3,4]])      #注意array()的写法
print (A*B)

[[2 0]
 [0 4]]

4.4.2 Pandas

1.Series

带标签的一维数组，语法格式：s = pd.Series(data,index=index)  index 轴标签列表

import pandas as pd
s = pd.Series(np.random.randn(5),index=['a','b','c','d','e'])
print (s)

a   -0.171228
b   -0.677511
c   -0.822303
d   -0.485130
e   -1.277921
dtype: float64

注意维度问题

2.DataFrame

4.4.3 Matplotlib

---

Python 2D 绘图库，可视化工具包之一（折线，散点，直方图等）
导入库命令：import matplotlib.pyplot as plt

1.figure()函数

函数调用语法格式：
plt.figure(num=None,figsize=None,dpi=None,facecolor=None,edgecolor=None,frameon=True)    
num(图像编号（数字）或名称（字符串）)    figsize(指定宽和高，单位英寸)   dpi（绘图对象分辨率，    
缺省值80），facecolor(背景颜色),edgecolor（边框颜色），frameon(指定是否显示边框)       

2.plot()函数

调用语法格式：      
plot(x,y,format_string,**kwargs)    
x(横轴数据)  y(纵轴数据)  **kwargs (第二组数据或更多)      

3.subplot()函数

调用语法格式：
subplot(numRows,numCols,plotNum)    
多个图表绘制在同一窗口，整个绘图区域被分成numRows行和numCols列，按从左到右，从上到下的顺序以此编号，    
plotNum指定创建的图像对象所在区域。

#eg   np里面有很多通用函数
import numpy as np
import matplotlib.pyplot as plt
def f(t):
    return np.exp(-t)*np.cos(2*np.pi*t)
t1 = np.arange(0.0,5.0,0.1)
t2 = np.arange(0.0,5.0,0.02)
plt.figure(1)
plt.subplot(211)
plt.plot(t1,f(t1),'bo',t2,f(t2),'k')
plt.subplot(212)
plt.plot(t2,np.cos(2*np.pi*t2))

[<matplotlib.lines.Line2D at 0x1d0f6eee880>]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hmwXOwrm-1626127208109)(output_25_1.png)]

深度卷积神经网络（CNN）学习第二天

---

PyTorch 基础

PyToch 是 Facebook 在 Torch 基础上采用Python语言重写的一个深度学习框架，它还支持GPU计算，并且拥有丰富的API接口。可以快速生成深度神经网络模型的搭建和训练。

常见的深度学习框架简介

Caffe
TensorFlow
PyTorch
其他框架

PyTorch 中的Tensor

张量是几何与代数的基本代数中的基本概念之一，是数量、向量、矩阵的自然推广。零阶张量可以用一个数表示，即标量；一阶张量可以用一行数组表示，即为向量；二阶张量可以用一个矩阵表示；三阶张量可以用一个立体矩阵表示；更高阶的向量无法用图像直观表示出来。张量可以看成包含单一数据类型（只能包含一种数据类型）元素的多维矩阵

Tensor 的数据类型

1. 基本属性

torch.dtype 表示 Tensor在 Torch 中对应的数据类型，共9种：Torch.float32(torch.float),Torch.float64(torch.double),torch.float16(torch.half),
torch.uint8,torch.int8,torch.int16(torch.short),torch.int32(torch.int),torch.int64(torch.long),torch.bool。

torch.device 包含设备的类型（“cpu"或"cuda”）及该设备类型的可选设备序号，若无序号则输入这个指令最终只能表示
当前设备。

torch.layout代表torch.Tensor的内存布局，目前主要支持torch.strided(密集型张量)。每一个跨步
张量（Strided Tensor）都有一个与之关联的torch.Storage用于保存其数据。这些张量提供了一个存储的多维跨步视图。

2. 数据类型
   | 数据类型 | dtype | CPU Tensor | GPU Tensor |
   | :-: | :-: |:-: | :-: |
   |32位浮点型|torch.float32|torch.FloatTensor|torch.cuda.FloatTensor|
   |64位浮点型|torch.float64|torch.DoubleTensor|torch.cuda.DoubleTensor|
   |16位浮点型|torch.float16|torch.HalfTensor|torch.cuda.HalfTensor|
   |8位无符号整型|torch.uint8|torch.ByteTensor|torch.cuda.ByteTensor|
   |8位有符号整型|torch.int8|torch.CharTensor|torch.cuda.CharTensor|
   |16位整型|torch.int16|torch.ShortTensor|torch.cuda.ShortTensor|
   |32位整型|torch.int32|torch.IntTensor|torch.cuda.IntTensor|
   |64位整型|torch.int64|torch.LongTensor|torch.cuda.LongTensor|

import torch as t
a = t.FloatTensor(2,3)
b = t.tensor([1,2,3,4])
print(a)
print(b)

tensor([[0., 0., 0.],
        [0., 0., 0.]])
tensor([1, 2, 3, 4])

这篇主要是为了记录我学习神经网络的过程，并未以后复习做准备。笔记里面的每个点都不详细，但是我只是想记录每个点的精华部分，自己以后复习的时候起到一个提醒的作用，检验自己是否真正学会了，因为太详细的太长的我也看不下去。= _= "|