TensorFlow2 Part2：基础知识回顾

最新推荐文章于 2024-04-08 16:09:19 发布
最新推荐文章于 2024-04-08 16:09:19 发布
阅读量411 收藏
点赞数 1
分类专栏： 机器学习 文章标签： TensorFlow 人工智能 AI 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44353473/article/details/99703460
版权
  1. python面向对象编程回顾

  • 基础概念：

    • 面向对象的编程简称OOP，它把对象作为程序的基本单元，一个对象包含了数据和操作数据的函数。
    • 面向对象的设计思想是抽象出Class，根据Class(类)创建Instance(实例对象)，这也是面向对象的最重要的概念。类是抽象出来的模板，而实例是根据模板创建出来的一个个具体的“对象”，每个对象都有相同的方法，但是各自的数据可能不同。
    • python中所有的数据类型都可以看作是类，同时也可以自定义一个Class
    • 面向对象的抽象程度又比函数要高，因为一个Class既包含数据，又包含操作数据的方法。
    • 面向对象的程序设计把计算机程序视为一组对象的集合，而每个对象都可以接收其他对象发过来的消息，并处理这些消息，计算机程序的执行就是一系列消息在各个对象之间传递。
    • 数据封装、继承和多态是面向对象的三大特点

  • 类的定义：

//定义类的一般形式

class Student(object):
	<statement 1>
	...
	<statement n >
//class声明这是一个类，类名一般都用大写字母开头，括号里面表示该类从哪里继承来的（父类），如果没有
合适的继承类，就使用object类，这是所有类最终都会继承的类。缩进语句块里面用来声明该类的各种数据和
functions

//实例代码
>>> class Student(object):
... Readline internal error
Traceback (most recent call last):
...
    ^
IndentationError: expected an indented block	//报错？缩进用个Tab不行吗？
>>> class Student(object):
...  pass										//要一个空格缩进？
...
  • 创建类的实例
>>> Student()							//通过类名+()就创建出了一个类实例对象
<__main__.Student object at 0x0000024713B0AF60>
>>> instance = Student()				
>>> instance							//可以发现它是一个Student 类的 object
<__main__.Student object at 0x0000024713B0AE10>		
>>> Student								//但Student才并且仍是Student类
<class '__main__.Student'>
  • 属性
>>> instance.name = 'yo'		//此时我们就可以给实例变量自由的添加属性
>>> instance.name				//但是添加的属性不会对类产生任何影响
'yo'			
//但是我们可以在创建类的时候，提前定义好一些该类的每一个实例对象都该拥有的属性。
//通过定义一个特殊的__init__方法，在创建实例的时候，把name，age等属性绑上去：
>>> class Student(object):
...  def __init__(self,name,age):
...   self.name = name
...   self.age = age			//我python的缩进是不是弄错了。。
...
						
//进入虚拟环境再用python缩进就正常了，代码好看多了。			
>>> class Student(object):
...     def __init__(self,name,age): //__init__方法的第一个参数永远是self，表示创建的实例本身
...             self.name = name	 //下面的就表示类自身（Student）的一些属性
...             self.age = age
...

>>> instance = Student()			//重新定义的类如果还不传参数就会报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: __init__() missing 2 required positional arguments: 'name' and 'age'

>>> instance = Student(name='ocean',age=19）	//实例化的时候self不需要传入
>>> instance = Student('ocean',19)				//传入参数的方法和用函数一样，有多种方式
>>> instance.name
'ocean'
>>> instance.age
19
>>> instance.score = 99.9			//此时，除了必须的，同样可以添加“个性化属性"

>>> class Student(object):
...     def __init__(self):	// __init__() 特殊方法（构造方法），该方法在类实例化时会自动调用
...             print(666)
...
>>> yo = Student()
666

>>> class Student(object):
...     def __init__(self):
...             print(self)		//一直不知道这个self表示的是什么，不如看看。
...
>>> yo = Student()
<__main__.Student object at 0x000001E1E2C9F188>
>>> Student						//可以看出，self表示的是类实例化后的yo，而不是Student类
<class '__main__.Student'>

OMG，我居然也可以 ，温柔。 --19.8.17

  • 数据封装
//在Student类的内部定义访问数据的函数，这样，就把“数据”给封装起来了。
//这些封装数据的函数是和Student类本身是关联起来的，我们称之为类的方法：

>>> class Student(object):
...     def __init__(self,name,age):
...             self.name = name
...             self.age = age
...     def print(self,score):			//封装数据的函数，self是必要的一个参数！
...             print("name:%s age:%s"%(self.name,self.age))
...             print("score = %s"%(score))
...
>>> instance = Student('ocean',19)
>>> instance.print(99.9)
name:ocean age:19
score = 99.9

//事实上，封装做的就是在类的内部定义函数，从而能够在类的内部对数据进行
处理，我们在外部只需要传入必要的参数，类在内部加工数据，传出我们想要的
结果，而不需要再外部设置函数如此以来使得类变得powerful
  • 继承
//在定义一个class的时候，我们可以从现有的某个已经存在了的类继承，被继承的类被称为父类或者基类（还
是很形象的），产生新的class被称为子类。（之前一直用的object被称为根类）

//上代码

>>> class Animal():
...     def printf(self):
...             print("This is a Animal")
...
>>> ins0 = Animal()
>>> ins0.printf()
This is a Animal

>>> class Dog(Animal):				//定义一个Dog类，继承自Animal类
...     pass
...
>>> ins1 = Dog()
>>> ins1.printf()							//调用继承自父类方法，看来只是原封不动的搬了过来
This is a Animal

>>> class Cat(Animal):				//定义一个 Cat 类，继承自Animal类
...     def printf(self):			//在子类中重写printf()方法
...             print("This is a cat.")
...
>>> ins2 = Cat()
>>> ins2.printf()			//调用继承自父类方法，可以发现子类重写的方法成功的将原方法覆盖掉
This is a cat.
  • 调用父类构造函数
//上代码
>>> class Student():
...     def __init__(self,age):
...             self.age = age
...             print(age)
...
>>> yo = Student(19)
19

>>> class Colleage_stu(Student):
...     def __init__(self,age,score):
...             print(age)
...             print(score)
...
>>> ocean = Colleage_stu(19,99)		//成功的覆盖掉了构造方法（__init__）
19
99

>>> class Colleage_stu(Student):
...     def __init__(self,age,score):
...             Student.__init__(self,age)		//继承Student类的self和age方法
...             self.score = score				//添加

自己的方法score
...             print(score)
...
>>> ocean = Colleage_stu(19,99)					//成功习得自己的方法score
19
99

>>> class Colleage_stu(Student):
...     def __init__(self,age,score):
...             print(score)
...             Student.__init__(self,age)
...             print(age)
...
>>> ocean = Colleage_stu(19,99)					//基本上可以为所欲为
99
19
19

>>> class Colleage_stu(Student):
...     def __init__(self,age,score):
...             Student.__init__(self,age,score)	//只要不缺心眼的继承一个父类没有的属性
...             print(score)
...
>>> ocean = Colleage_stu(19,99)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in __init__
TypeError: __init__() takes 2 positional arguments but 3 were given
  • 多继承
//所谓多继承，就是继承自多个父类白，啧啧啧~

在这里插入图片描述

>>> class Teacher():
...     def __init__(self,class):		//敲了好几遍才意识到这个class还不能用。讲究~
  File "<stdin>", line 2
    def __init__(self,class):
                          ^
SyntaxError: invalid syntax
>>> class Teacher():
...     def __init__(self,grade):			//换了grade就ok了
...             print(grade)
...
>>> class Student():
...     def __init__(self,age):
...             print(age)
...
>>> stu = Student(19)
19
>>> tec = Teacher(10)						//验证了一下没毛病

>>> class School(Teacher,Student):
...     def __init__(self,grade,age,name):
...             print(name)
...             Student.__init__(self,age)
...             print(age*10)
...             Teacher.__init__(self,grade)
...             print(grade*10)
...
>>> Tsinghua = School(10,19,"ocean")			//还是只要别继承父类没有的属性就可以为所欲为
ocean
19
190
10
100
  • 多态
//上代码
>>> type(Cat)
<class 'type'>
>>> type(ins2)
<class '__main__.Cat'>			//ins2是Cat类型的数据
>>> type(ins0)
<class '__main__.Animal'>		//ins0是Animal类型的数据

>>> isinstance(ins2,Cat)			//ins2属于Cat类，of course
True
>>> isinstance(ins0,Animal)			//ins0属于Animal类，of course
True
>>> isinstance(ins2,Animal)			//ins2同样属于Animal类！它继承自父类。
True								//这就是所谓的多态
  • 多态的好处
>>> def run_twice(animal):	//此函数接受一个Animal类型的变量
...     animal.printf()
...     animal.printf()
...
>>> run_twice(Animal())			//运行成功，但是为什么定义的时候接受的类名是小写？
This is a Animal
This is a Animal

>>> def run_twice(Animal):		//大写是可以的
...     Animal.printf()
...     Animal.printf()
...
>>> run_twice(Animal())
This is a Animal
This is a Animal

>>> run_twice(Dog())		//我们定义的时候没有定义Dog类，但是他是继承自Animal的，具有多态
This is a Animal
This is a Animal
>>> run_twice(Cat())
This is a cat.
This is a cat.
//由于Animal类型有run()方法，因此，传入的任意类型，只要是Animal类或者子类，就会自动调用实际类型的
run()方法，这就是多态的意思：
//对于一个变量，我们只需要知道它的父类，而不需要确切的知道子类的内部结果，就可以通过调用父类的方法
来调用子类的相对应的方法。
//这就是多态真正的威力：调用方只管调用，不管细节，而当我们新增一种Animal的子类时，只要确保run()方
法编写正确，不用管原来的代码是如何调用的。

Questions：
在这里插入图片描述

>>> class Animal():
...     def printf(self):
...             print("This is a animal.")
...
>>> class Dog(Animal):
...     pass
...
>>> class Cat(Animal):
...     def printf(self):
...             print("This is a cat.")
...
>>> def run(Cat):
...     Cat.printf()
...
>>> run(Cat())
This is a cat.
>>> run(Animal())		
This is a animal.
>>> run(Dog())			//我都凌乱了，run函数定义的是Cat类，怎么会和Dog类还有父类产生关系？
This is a animal.
>>> ins0 = Animal()
>>> ins2 = Cat()
>>> isinstance(ins0,Cat)
False
  1. python super()函数回顾
  • super() 函数是用于调用父类(超类)的一个方法。（多继承问题）
  1. 对实例类进行调用
头 号 玩 家
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
利用Tensorflow2构建CNN并用于图像分类
AIHUBEI的博客
06-17 2566
利用Tensorflow2构建CNN并用于图像分类 本文将使用自下而上的方法，从讨论CNN的基本板块构建开始。然后将深入研究CNN的体系结构，并探索如何在TensorFlow中实现CNN。本文包含以下内容： 一维和二维的卷积运算 卷积神经网络结构的构建 使用Tensorflow构建深度卷积神经网络 利用数据扩充技术提高模型泛化性能 实现一个基于人脸图像的CNN分类器来预测个人性别 from IPython.display import Image %matplotlib inline
一文上手TensorFlow2.0（一）
TensorFlowNews
08-15 1600
目录： Tensorflow2.0介绍 Tensorflow常见基本概念 从1.x 到2.0的变化 Tensorflow2.0的架构 Tensorflow2.0的安装(CPU和GPU) Tensorflow2.0的使用 使用 GPU 加速 从现在开始我们就正式进入TensorFlow2.0的学习了，在这一系列文章里我们将重点介绍TensorFlow的基...
tensorflow2.0知识之模型保存
最新发布
微微一笑满城空
04-08 570
文件夹以清晰的目录结构存储了模型的计算图结构、权重参数以及模型的输入输出签名信息。这种封装使得模型可以在不依赖原始训练代码的情况下被加载并执行推断，极大地简化了模型部署的过程。是 TensorFlow 推荐的模型持久化和部署的标准格式，它包含了模型的所有必要信息，使得模型可以在没有原始代码的情况下被加载并进行推断。需要注意的是，这种方式依然会保存模型的所有信息，即“网络结构、权重、配置、优化器状态”四个信息，所以可以接着训练。保存的 TensorFlow 模型是以。文件夹传输至目标位置即可。
tensorflow2打印对应的tensor数组值
小姑仔的博客
02-22 2848
tensorflow之中经常性的用到相应的tensor数组，查了一下网上对于打印tensor数组的说法，基本上都是这样一个程序 import tensorflow as tf ones=tf.Variable(tf.ones([3,3])) # 方法1 InteractiveSession + initializer inter_sess=tf.InteractiveSession() ones.initializer.run() print(inter_sess.run(ones)) # 方法
（泰迪云）tensorflow2实战
weixin_43901260的博客
02-19 1074
一、tensorflow2简单运用 #%%tensorflow2简单运用 import tensorflow as tf #tf.__version__ a = tf.constant([1.0,2]) b = tf.constant([3.0,4]) #确保a和b都是浮点型数据 result = a+b #print(type(result.numpy())) #print(result) #print(tf.reduce_mean(a)) #打印a的均值 #print(tf.reduce_m
TensorFlow 2.1 print
weixin_42272768的博客
03-23 524
正常的情况下，TensorFlow2.1的急切执行是打开的。这个时候，使用print函数是可以打印出Tensor变量的内容的。 但是如果使用了如下的语句： import tensorflow.compat.v1 as tf tf.disable_eager_execution() 这个时候，使用print语句就不会打印出Tensor中的内容。需要重新启动IDE才可以恢复。 ...
计算机基础知识.part2
11-28
计算机基础知识.part 2计算机基础知识.part2
Java2核心技术I卷.基础知识7th.part1.rar
11-07
Java2核心技术I卷.基础知识7th.part1.rar （解压需5个文件part1，part2，目前一次只能上传70M，不得不分卷，希望大家谅解下）
ISO_16750-2：2012_Part 2：Electrical loads .pdf
09-05
ISO_16750-2：2012_Part 2：Electrical loads 标准内容高清可复制，非扫描版。 道路车辆—电气和电子设备的环境条件和测试—第 2 部分：电气负载 ISO 16750-2:2012 适用于道路车辆的电气和电子系统/组件。 它描述...
Course 2 - TensorFlow Lite - Part2_tensorflow_
10-03
This repository contains the examples and exercises that accompany Course 2 - Device-based Models with TensorFlow Lite of the TensorFlow for Data and Deployment Specialization at Coursera. (Part 2)
Delphi_7 开发基础教程 .part2
02-12
Delphi_7 开发基础教程 .part2
Tensorflow--杂记--2
blue_dam_LRH的博客
04-30 180
***** 在Python中的使用 在函数中： 例： x_data = numpy.linspace(-1,1,100) #-1-1之间产生100个元素的等差序列 x_data.shape() #求x_data序列形状 print(x_data.shape) 结果：（100，） 若：print（*x_data.shap...
tensorflow2.0模型的保存与读取
irony_202的博客
12-26 454
https://blog.51cto.com/u_15483653/4926726
tensorflow2实现图像分类：以猫狗数据集为案例（下）
Leo的博客
03-30 5019
上节实现完的精确度和loss绘制图如下。从图中可以看出，训练精度和验证精度相差很大，模型在验证集上仅达到70%左右的精度。 本节研究其问题，并尝试提高模型的整体性能。 过拟合 在上面的图中，训练精度随着时间线性增加，而验证精度在训练过程中停滞在70%左右。此外，训练和验证准确性之间的差异是显而易见的——这是过拟合的标志。 当训练样本数量较少时，模型有时会从训练样本中的...
目标检测_利用tensorflow2官方案例-自定义训练目标进行人眼识别
桜
05-31 1676
我的数据集： 说明：我的数据集一共1035张，并非通过手动标记得到，因此不包含xml文件 包含：图片文件，train.csv,test.csv。（图片位置，标记位置，目标名称等） 说明：数据集本人通过制作而成，只供学习使用，不得私自滥用。 链接：https://pan.baidu.com/s/18FdxUHiLnD1B52Jpt4QC6g 提取码：zw6b 效果展示： 单眼模型效果 双眼模型效果 工程目录： ...
Tensorflow2.0模型构建与训练
CICI❤️的博客
03-29 415
模型构建 class Encoder(layers.Layer): def __init__(self, latent_dim=32, intermediate_dim=64, name="encoder", **kwargs): super(Encoder, self).__init__(name=name, **kwargs) ''' w_init = tf.random_normal_initializer() self.w =
Tensorflow2教程-文本卷积
知行_那片天
03-30 9688
Tensorflow 2.0 教程持续更新 ：https://blog.csdn.net/qq_31456593/article/details/88606284 完整tensorflow2.0教程代码请看tensorflow2.0：中文教程tensorflow2_tutorials_chinese(欢迎star) 入门教程： TensorFlow 2.0 教程- Keras 快速入门 Tenso...
tensorflow2.0 升级到最新版本tensorflow2.2,出现的问题：DLL load failed: 找不到指定的模块
weixin_44871341的博客
07-11 625
由于之前已经安装好了tensorflow2.0 gpu 版本。之后，tensorflow2.2 又出现了，于是我就通过以下方式更新了： pip install --upgrade tensorflow-gpu 之后一些列操作都是自动完成的。 然而等到安装完成后，出现了 DLL load failed: 找不到指定的模块 的提示，在网上找了许多的资料，后来发现，后来下载了 就好了。 ...
part_A(:,1:2) 用python怎么写
06-09
在Python中，如果 `part_A` 是一个二维数组或矩阵，您可以使用以下方式来选择第1和第2列： ```python part_A[:, 0:2] ``` 其中， `:` 表示选择所有行， `0:2` 表示选择第0列和第1列（Python中索引从0开始）。这将...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值