精华内容
下载资源
问答
  • 计算图前文曾多提到计算图,关于什么是计算图,有很多种说法。既然它被称为图,便具有图的基本元素:点和线。如下图:点:节点,用来储存变量。比如输入X,隐含层h,输出y线(箭头):操作(算符),用来确定两个节点...

    (好久不更~)前文中,参照tensorflow的方式实现了简单的自动求导。接下来要在自动求导的基底(模板)上搭建简单的bp神经网络。

    计算图

    前文曾多次提到计算图,关于什么是计算图,有很多种说法。既然它被称为图,便具有图的基本元素:点和线。如下图:

    点:节点,用来储存变量。比如输入X,隐含层h,输出y

    线(箭头):操作(算符),用来确定两个节点之间的联系,或者说由前一个节点经过这个操作后可以得到后面的节点。

    可以利用上一篇构造复合函数的方式来理解它。构造函数f(x),需要自变量x和一个映射f,这里的x是节点,映射f是操作。如果另y=f(x),那么y就是新的节点,映射f的箭头是从x指向y。多个不同的映射可以组成一个大网络,储存更复杂的信息。

    计算图的好处在于,它是微分链式法则的直观体现,每个节点的梯度都可以看做上一个节点的梯度与本层导数的乘积。因此,计算图网络结构建立的同时,每个节点的梯度也是确定了的。

    全连接层

    说到全连接层,就不得不提一下BP神经网络。神经网络是模方大脑神经元的连接方式,通过建立神经元之间的相互联系来对某个问题进行建模的方法。BP神经网络是在众多神经网络中一枝独秀,利用梯度下降方法,可以最快最准的接近局部最优值(缺点当然是容易陷入局部最优,因此也出现了很多改进算法)。

    从最简单的线性回归说起。我们有两组数据,自变量:x,目标:t。对目标t的估计值为:

    估计值和目标之间的均方误差为:

    可以做出loss关于a0和a1的三维曲面:

    可以看到他是一个二次函数形式,必然存在最小值。我们对a0和a1分别求偏导:

    最小二乘法是利用这两个偏导数等于0求出取到最值时的a0和a1:

    而梯度下降法则是将a0和a1按照上面算出的导数,以某个速率向最值点靠近(以他们的导数乘某个常数为速率,以梯度的负数为方向,做爬坡运动)

    对于线性回归问题来说,loss是个抛物线,必然存在最值点:

    但是对于更复杂的问题来说,就不一定了,loss不一定是抛物线,可能存在多个极值点,这样的话最小二乘法便不再好用,但是梯度下降却可以尽最大可能搜索最优值(虽然不容易跳出局部最优,但还是比最小二乘法要好吧)

    但是随着问题复杂度的提升,自变量和因变量之间也不再是简单的线性关系,这时就要加入一个激活函数,但是光加入激活函数只能表示一些简单的非线性模型,对于更加复杂的非线性模型也无能为力。

    所以现在的问题是如何利用简单的方程表示出复杂的方程。这一点在高等数学中其实已经学到了。对于一个复杂的函数,我们总可以把他展开成级数的形式,而且我们还可以证明,展开的级数就是泰勒级数,这个展开也叫做泰勒展开。

    我们可以利用最简单的幂函数的叠加来趋近一个极其复杂的函数。那在这个问题上,也可以利用无数个简单的非线性函数的叠加来拟合一个极其复杂的非线性函数,所以就有了下图:

    把n个线性关系叠加起来再通过激活函数计算得到最终的估计值:

    损失值loss(均方差)为:

    要继续利用梯度下降法,就需要计算loss关于每个w的导数:

    这样就建立了梯度下降与链式法则之间联系,和上一文《简单实现自动求导》一模一样。

    这里可以体现出计算图的好处。我们不需要再手动计算这些复杂的梯度值到底是多少,在计算图建立的同时,它就已经帮我们算好了。我们只需要给他一个学习的指令,他就可以按照我们要求的训练方式学习。

    全连接层,顾名思义,重在“全连接”,他将所有的输入都和输出相连,如下图的两层神经网络,一个输入,一个隐含层,一个输出。

    在黑框中可以看到,所有的输入X都和所有隐含层的节点相连,所有隐含层的节点都和输出y相连。

    或许会问,难道还有不全连接的神经网络吗。当然有,先不说一些复杂的结果,最基本的卷积神经网络CNN就不是全连接的,它利用卷积核扫描图像,而卷积核一般都是比图像小的多的方形如3×3,5×5。

    两层的神经网络理论上可以拟合任意的非线性函数。在梯度计算方面与之前稍有不同:先看第一层,第j个输出为:

    要计算w的该变量,就需要计算前面那个链式表达式,它其中的一项:

    所以:

    对于很多层的网络:

    我们给定一个变量δ,它实际上是每一层神经网络的梯度,下式为输出层的梯度:

    那么权重改变量:

    而上一层的梯度:

    权重改变量:

    因此,在网络训练过程中,先计算每一层的梯度和权重改变量,算完之后再对每一层的权重梯度下降。值得注意的是:不可以每计算一层的权重改变量,就对该层的权重做出改变。这样会影响后面的计算。

    写到这儿,需要的理论知识已经有了。接下来就是如何搭建静态图:

    上一文有提到,我搭建的计算图中只有两个基本变量:Variable和placeholder。

    placeholder作为需要传入数据的变量,Variable则作为需要训练的变量(这里用不到不需要训练的变量,不然应该再给一个Constant更完整,我这里其实简化了很多操作^_^)

    与之前相同的是,Variable包括value和grad两个变量。

    不同的是,Variable包含了last,next,root和target四个指针(可以这么叫吧)。last指向前一个节点,next指向后一个节点,root指向输入的placeholder(就是起始节点),target指向目标的placeholder(要计算loss,就必须要计算输出和目标之间的差距),一条路径上的每个节点的root和target都相同(这是为了方便对每个节点求值的时候都能从placeholder开始)。

    placeholder在图中只起到占位的作用,它用来确定计算内存与复杂度,需要在后续求值的时候传入数据。每个节点都有root指针,可以确保在求该节点值的时候,从它的root开始,先传入数据,然后利用next指针指向下一个节点,计算下一个节点的值和导数。

    值得一提的是,这里我没有使用一个全局变量来储存整个图结构,而是用上述的四个指针将整个计算图建立起来。类似于{root,next1(last1),next2(last2)。。。target}。

    如果不使用root指针,还有两个方法:

    1.储存整个网络的图结构,这也是一般计算图的方案,这样就可以从图的起始节点开始算起。

    2.要求一个节点的值,就要先知道上一个节点的值,然后带入上一个节点的激活函数才能得到这个节点的值。同理要知道前一个节点的值,就要求上上个节点的值,以此类推。而当上上一个节点是placeholder时,上上个节点值就是传入的数据,然后再计算上个节点的值。这不正是递归算法嘛,先往回走,走到初值时,再往前走。那用一个root指针岂不是取代了往回走的过程,我直接告诉它该从哪里开始往前走即可。

    下面放入代码:

    先说明一下整个代码的结构:

    mytensor文件夹中包含五个py文件,__init__用于从tensor文件夹外部调用内部的文件。mytensor(这里不是指文件夹,而是mytensor文件夹内的py文件)用来定义基类Varibale,placeholder,一些基本函数,还有不同的Loss。nn用于定义不同的神经网络。train用于定义不同的训练方式。cnn_func包含卷积中的一些操作(这里不会提到)。

    代码文件mytensor.py

    # -*- coding: utf-8 -*-

    import numpy as np

    #Variable基类

    class Variable:

    def __init__(self, value=None):

    self.value = value

    self.grad = None

    self.next = None

    self.last = None

    self.root = None

    self.target = None

    self.eval_func = Line

    if isinstance(value, np.ndarray):

    self.size = value.shape

    else:

    self.size = None

    def __add__(self, other):

    res = Variable()

    res.root = self.root

    self.next, other.next = res, res

    res.last = self

    res.func = lambda x: x + other.value

    res.func_grad = lambda x: 1

    return res

    def func(self, X):

    return 1

    def func_grad(self, X):

    return 1

    def run(self, feed_dict, need_grad=False):

    #喂入数据

    root = self.root#找到root

    root.value = feed_dict[root]#给root喂入数据

    target = self.target#找到target

    if target is not None:

    target.value = feed_dict[target]#给target喂入数据

    #求值过程

    while root.next is not self.next:

    root.next.value = root.next.func(root.value)

    if need_grad:#如果需要求导

    root.next.grad = root.grad * root.next.func_grad(root.value)

    root = root.next

    return root.value

    __add__函数用来定义两个Variable的相加算法。这里Variable多出了eval_func变量,虽然这里用不到,但后续有类继承它时才会用到。

    run方法便是在求该节点值得时候会用到,与之前所说相同,先找到节点的root,然后从root开始一步一步往前传,如果需要自动求导的话,need_grad传入True即可。

    定义完基类,接下来就是继承基类的子类了,首先是placeholder:

    ###############占位#####################

    class placeholder(Variable):

    def __init__(self, size):

    super().__init__(self)

    self.size = size

    self.root = self

    self.grad = 1

    然后定义一些全连接层中可能用到的激活函数:

    class relu(Variable):

    def __init__(self, X):

    super().__init__()

    X.next = self

    self.last = X

    self.root = X.root

    def func(self, X):

    return np.maximum(0, X)

    def func_grad(self, X):

    res = np.zeros(X.shape)

    res[X >= 0] = 1

    return res

    class Line(Variable):

    def __init__(self, X):

    super().__init__(self)

    self.last = X

    self.root = X.root

    def func(self, X):

    return X

    def func_grad(self, X):

    return np.ones(X.shape)

    class softmax(Variable):

    def __init__(self, X):

    super().__init__(self)

    X.next = self

    self.last = X

    self.root = X.root

    def func(self, X):

    return np.exp(X) / np.sum(np.exp(X), axis = 1).reshape(X.shape[0], 1)

    def func_grad(self, X):

    return np.ones(X.shape)

    class sigmoid(Variable):

    def __init__(self, X):

    super().__init__(self)

    X.next = self

    self.last = X

    self.root = X.root

    def func(self, X):

    return 1 / (1 + np.exp(-X))

    def func_grad(self, X):

    return self.func(X) * (1 - self.func(X))

    class square(Variable):

    def __init__(self, X):

    super().__init__(self)

    X.next = self

    self.last = X

    self.root = X.root

    def func(self, X):

    return np.square(X)

    def func_grad(self, X):

    return 2 * X

    写法与上一文自动求导中定义初等函数的方法完全一致(多了一个next指针)。

    然后定义损失函数:

    class MeanSquareLoss(Variable):

    def __init__(self, yhat, y):

    super().__init__(self)

    self.target = y

    self.last = yhat

    self.root = yhat.root

    yhat.next = self

    def func(self, yhat):

    return np.mean(np.square(yhat - self.target.value)) / 2

    def func_grad(self, yhat, grad):

    return (self.target.value - yhat) * grad

    class SoftmaxCrossEntropy(Variable):

    def __init__(self, yhat, y):

    super().__init__(self)

    self.target = y

    self.last = yhat

    self.root = yhat.root

    yhat.next = self

    def func(self, yhat):

    return np.mean(-np.log(yhat) * self.target.value)

    def func_grad(self, yhat, grad):

    return (self.target.value - yhat)

    这里不定义损失函数也是可以的。但是还需要用定义初等函数的方法写一下mean函数(square函数我倒是写了)。然后在训练的时候,可以把loss = MeanSquareLoss(yhat,y)写为loss = mean(square(yhat - y))

    然后是Session。其实我这里写Session只是为了形式上好看点,失去了tensorflow中Session的意义。。

    ###############Session####################

    class Session:

    def run(self, operator, feed_dict, need_grad = False):

    return operator.run(feed_dict, need_grad)

    上述代码全部包含在mytensor.py中。

    在nn.py文件中,就开始构建真正的全连接层了:

    # -*- coding: utf-8 -*-

    #导入一些要用到的函数

    from mytensor.mytensor import Variable

    import mytensor.mytensor as mt

    import numpy as np

    #全连接层

    class FullConnection(Variable):

    def __init__(self, X, W, b=None, eval_func=None, need_trans=False):

    super().__init__(self)

    X.next = self

    self.last = X

    self.root = X.root

    self.W = W

    if b == None:

    self.b = Variable(np.zeros(W.size[1]))

    else:

    self.b = b

    self.eval_func = eval_func

    self.need_trans = need_trans

    def func(self, X):

    if self.need_trans:

    N = X.shape[0]

    D = np.prod(X.shape[1:])

    X = np.reshape(X, (N, D))

    h = X.dot(self.W.value) + self.b.value

    if self.eval_func is None:

    self.eval_func = mt.Line

    h = self.eval_func(self.W).func(h)

    self.value = h

    return h

    def func_grad(self, dout, first=False):

    if first:

    grad = self.eval_func(self.W).func_grad(self.value)

    return grad

    else:

    dw = self.last.value.T.dot(dout)

    db = np.sum(dout, axis = 0)

    grad = self.last.eval_func(self.W).func_grad(self.last.value)

    dout = np.reshape(dout.dot(self.W.value.T), self.last.value.shape) * grad

    return dout, dw, db

    可以看到全连接层的构造和之前的基本函数大的框架是一致的。构造函数中要有父类的构造函数,然后重写func和func_grad。

    不同之处在于,全连接层的变量更多,有权重W,偏置b,激活函数eval_func。need_trans是针对卷积操作时判断是否需要把输入的矩阵转化为一个长链的布尔值。

    func函数用来计算节点的值,就是基本的f(Xw+b)。

    而func_grad输入上一层的梯度值,计算本层的梯度值以及权重和偏置的改变量,并返回。

    不管是全连接层还是CNN,RNN。网络构造都是这个模式。构造函数中储存所有的变量。func中是前传操作,func_grad中利用上一层的梯度,计算本层的权重,偏置该变量和本层的梯度。

    这样便可以将不同的网络结构统一起来,让后续工作简单化。

    现在可以说是万事俱备只欠东风了。该定义的都定义了,该搭建的也都搭建好了,我们已经可以搭建出任意层数的神经网络,并且定义它的loss值。可以认为:前传过程已经没有任何问题了。但是现在需要个一个东西让他们跑起来——训练。

    train.py中只定义了GradientDecent训练方式:

    # -*- coding: utf-8 -*-

    #训练方式

    from mytensor.mytensor import Variable

    #梯度下降法

    class GradientDescentOptimizer(Variable):

    def __init__(self, alpha, loss):

    super().__init__()

    self.alpha = alpha

    self.loss = loss

    def run(self, feed_dict, end=False):

    now = self.loss

    now.run(feed_dict)

    dnow = now.last

    now.grad = [now.func_grad(dnow.value, dnow.func_grad(None, True))]

    while dnow is not now.root:

    dnow.grad = dnow.func_grad(now.grad[0])

    now, dnow = dnow, dnow.last

    root = self.loss.root

    while root.next is not self.loss:

    try:

    root.next.W.value += self.alpha * root.next.grad[1]

    root.next.b.value += self.alpha * root.next.grad[2]

    except:

    pass

    root = root.next

    它和别的类不同,没有func和func_grad。但它却重写了run方法。毕竟它是优化器,与之前的节点都不同(其实这里不需要继承父类)。

    这里首先要计算完每一层的梯度,每一层权重和偏置的改变量,然后才可以对权重和偏置做出改变,否则会影响每一层梯度的计算。本质上这些计算得是并行的,但是由于本层的梯度必须要利用前一层的梯度,拥有串行的性质。这就导致了我们必须得写两个循环。

    使用try-except是因为,卷积中池化层没有权重和偏置,为了程序的统一才用这个方法。

    这样所有的方法都已经写好,如果从mytensor文件夹外调用的就需要__init__.py了。

    __init__.py中定义了接口的调用方式

    # -*- coding: utf-8 -*-

    from .nn import FullConnection

    from .nn import Conv2D

    from .nn import MaxPool

    from .train import GradientDescentOptimizer

    from .mytensor import Variable, placeholder

    from .mytensor import matmul

    from .mytensor import exp, sin, cos, log

    from .mytensor import square, relu, softmax, sigmoid, Line

    from .mytensor import MeanSquareLoss, SoftmaxCrossEntropy

    from .mytensor import Session

    用mnist数据集测试:

    # -*- coding: utf-8 -*-

    '''mnist测试'''

    import numpy as np

    import mytensor as mt

    from sklearn.preprocessing import StandardScaler

    from sklearn.preprocessing import LabelBinarizer

    from sklearn import metrics

    data = np.load("mnist.npz")

    def DataStandard(X):

    return StandardScaler().fit_transform(X)

    def DataTrans(y):

    return LabelBinarizer().fit_transform(y)

    X_train, y_train, X_val, y_val, X_test, y_test = data['X'], data['y'], data['X_val'], data['y_val'], data['X_test'], data['y_test']

    X_train, X_val, X_test = DataStandard(X_train), DataStandard(X_val), DataStandard(X_test)

    y_train, y_val, y_test = DataTrans(y_train), DataTrans(y_val), DataTrans(y_test)

    BATCH_SIZE = 128

    #权重和偏置

    W1 = mt.Variable(np.random.uniform(-0.01, 0.01, (784, 128)))

    b1 = mt.Variable(np.random.uniform(-0.01, 0.01, (128)))

    W2 = mt.Variable(np.random.uniform(-0.01, 0.01, (128, 10)))

    b2 = mt.Variable(np.random.uniform(-0.01, 0.01, (10)))

    #占位符

    xs = mt.placeholder((None, 784))

    ys = mt.placeholder((None, 10))

    #两层神经网络

    h1 = mt.nn.FullConnection(xs, W1, b1, mt.relu)

    h2 = mt.nn.FullConnection(h1, W2, b2, mt.softmax)

    #定义loss和train

    loss = mt.SoftmaxCrossEntropy(h2, ys)

    train = mt.train.GradientDescentOptimizer(1e-4, loss)

    sess = mt.Session()

    start = 0

    for i in range(10000):

    end = start + BATCH_SIZE

    if end >= X_train.shape[0]:

    end = X_train.shape[0] - 1

    X_batch = X_train[start: end]

    y_batch = y_train[start: end]

    start = end

    if start == X_train.shape[0] - 1:

    start = 0

    sess.run(train, {xs: X_batch, ys: y_batch})

    if (i % 100 == 0):

    los = sess.run(loss, {xs: X_val, ys: y_val})

    output = sess.run(h2, {xs: X_val})

    y_pred = np.argmax(output, axis = 1)

    acc = metrics.accuracy_score(y_pred, np.argmax(y_val, axis = 1))

    print("times : {}, loss : {}, accuracy : {}".format(i, los, acc))

    los = sess.run(loss, {xs: X_test, ys: y_test})

    output = sess.run(h2, {xs: X_test})

    y_pred = np.argmax(output, axis = 1)

    acc = metrics.accuracy_score(y_pred, np.argmax(y_test, axis = 1))

    print("test data: loss : {}, accuracy : {}".format(los, acc))

    。。。

    最后得到93%正确率。其实这在全连接层还算是可以接受的结果。如果利用卷积池化来处理的话,准确率必然会大大提高。

    后记:数模又双叒叕参与奖了,怀着悲愤的心情才抽出时间写下此文。

    展开全文
  • 二次函数y=ax^2的图像的画法用描点法画二次函数y=ax^2的图像时,应在顶点的左、右两侧对称地选取自变量x的值,然后计算出对应的y值,这样的对应值选取越密集,描出的图像越准确。用描点法画出二次函数y=x^2的图像...

    在平面直角坐标系中作出二次函数y=x的平方的图像,可以看出,二次函数的图像是一条永无止境的抛物线。

    如果所画图形准确无误,那么二次函数将是由一般式平移得到的。

    二次函数y=ax^2的图像的画法

    用描点法画二次函数y=ax^2的图像时,应在顶点的左、右两侧对称地选取自变量x的值,然后计算出对应的y值,这样的对应值选取越密集,描出的图像越准确。

    用描点法画出二次函数y=x^2的图像,它是一条关于y轴对称的曲线,这样的曲线叫做抛物线。

    因为抛物线y=x^2关于y轴对称,所以y轴是这条抛物线的对称轴,对称轴与抛物线的交点是抛物线的顶点,从图上看,抛物线y=x2的顶点是图象的最低点.因为抛物线y=x2有最低点.所以函数y=x2有最小值,它的最小值就是最低点的纵坐标。

    基本图像

    当a>0时,y=ax^2的图像

    5842405_1

    当a<0时,y=ax^2的图像

    5842405_2

    二次函数y=ax^2;,y=a(x-h)^2;,y=a(x-h)^2+k,y=ax^2+bx+c(各式中,a≠0)的图象形状相同,只是位置不同,它们的顶点坐标及对称轴如下表:

    解析式

    y=ax^2;

    y=ax^2+K

    y=a(x-h)^2;

    y=a(x-h)^2+k

    y=ax^2+bx+c

    顶点坐标

    (0,0)

    (0,K)

    (h,0)

    (h,k)

    (-b/2a,4ac-b^2/4a)

    对称轴

    x=0

    x=0

    x=h

    x=h

    x=-b/2a

    当h>0时,y=a(x-h)^2;的图象可由抛物线y=ax^2;向右平行移动h个单位得到,

    当h<0时,则向左平行移动|h|个单位得到.

    当h>0,k>0时,将抛物线y=ax^2;向右平行移动h个单位,再向上移动k个单位,就可以得到y=a(x-h)^2+k的图象;

    当h>0,k<0时,将抛物线y=ax^2;向右平行移动h个单位,再向下移动|k|个单位可得到y=a(x-h)^2-k的图象;

    当h<0,k>0时,将抛物线向左平行移动|h|个单位,再向上移动k个单位可得到y=a(x+h)²+k的图象;

    当h<0,k<0时,将抛物线向左平行移动|h|个单位,再向下移动|k|个单位可得到y=a(x-h)²+k的图象;在向上或向下.向左或向右平移抛物线时,可以简记为“上加下减,左加右减”。

    因此,研究抛物线 y=ax^2+bx+c(a≠0)的图象,通过配方,将一般式化为y=a(x-h)^2;+k的形式,可确定其顶点坐标、对称轴,抛物线的大体位置就很清楚了.这给画图象提供了方便.

    展开全文
  • 课题二次函数知识点总汇教学目标介绍一些些能加快速度的计算公式教学内容3求抛物线的顶点、对称轴的方法(1)公式法:abacabxacbxaxy442222,∴顶点是),(abacab4422,对称轴是直线abx2...

    二次函数知识点总汇

    教学目标

    介绍一些些能加快速度的计算公式

    教学内容

    3

    求抛物线的顶点、对称轴的方法(

    1

    )公式法:

    a

    b

    ac

    a

    b

    x

    a

    c

    bx

    ax

    y

    4

    4

    2

    2

    2

    2

    ,∴顶点是

    )

    (

    a

    b

    ac

    a

    b

    4

    4

    2

    2

    对称轴是直线

    a

    b

    x

    2

    .

    (

    2

    )配方法:运用配方的方法,将抛物线的解析式化为

    k

    h

    x

    a

    y

    2

    的形式,得到顶点为

    (

    h

    ,

    k

    )

    ,对称轴是直线

    h

    x

    .

    (

    3

    )运用抛物线的对称性:由于抛物线是以对称轴为轴的轴对称图形,所以对称轴的连线的垂直平分线是抛物线的对称轴,对称轴与

    抛物线的交点是顶点

    .

    用配方法求得的顶点,再用公式法或对称性进行验证,才能做到万无一失

    .

    9.

    抛物线

    c

    bx

    ax

    y

    2

    中,

    c

    b

    a

    ,

    ,

    的作用

    (

    1

    )

    a

    决定开口方向及开口大小,这与

    2

    ax

    y

    中的

    a

    完全一样

    .

    (

    2

    )

    b

    a

    共同决定抛物线对称轴的位置

    .

    由于抛物线

    c

    bx

    ax

    y

    2

    的对称轴是直线

    a

    b

    x

    2

    ,故:①

    0

    b

    时,对称轴为

    y

    轴;②

    0

    a

    b

    (即

    a

    b

    同号)时,对称轴在

    y

    轴左侧;③

    0

    a

    b

    (即

    a

    b

    号)时,对称轴在

    y

    轴右侧

    .

    (

    3

    )

    c

    的大小决定抛物线

    c

    bx

    ax

    y

    2

    y

    轴交点的位置

    .

    0

    x

    时,

    c

    y

    ,∴抛物线

    c

    bx

    ax

    y

    2

    y

    轴有且只有一个交点(

    0

    c

    )

    0

    c

    ,抛物线经过原点

    ;

    0

    c

    ,

    y

    轴交于正半轴;③

    0

    c

    ,

    y

    轴交于负半轴

    .

    以上三点中,当结论和条件互换时,仍成立

    .

    如抛物线的对称轴在

    y

    轴右侧,则

    0

    a

    b

    .

    11.

    用待定系数法求二次函数的解析式

    (

    1

    )一般式:

    c

    bx

    ax

    y

    2

    .

    已知图像上三点或三对

    x

    y

    的值,通常选择一般式

    .

    (

    2

    )顶点式:

    k

    h

    x

    a

    y

    2

    .

    已知图像的顶点或对称轴,通常选择顶点式

    .

    (

    3

    )交点式:已知图像与

    x

    轴的交点坐标

    1

    x

    2

    x

    ,通常选用交点式:

    

    2

    1

    x

    x

    x

    x

    a

    y

    .

    12.

    直线与抛物线的交点

    (

    1

    )

    y

    轴与抛物线

    c

    bx

    ax

    y

    2

    得交点为

    (0,

    c

    ).

    展开全文
  • 其中一种常见的形式为:二次函数拟合。方法获取实验数据x, y利用np.polyfit(x, y, 2)进行二次拟合得到拟合出的系数,进行后续的数据处理实例已知一组二次曲线型数据,要求拟合出该曲线,并且返回最大点/...

    引入

    在实际项目中,往往有这样的需求:对采集到的数据进行数据处理(曲线拟合),再计算出一些想要的参数,比如峰值/dip值/周期等等。

    核心即曲线拟合。不同的曲线形式,就灵活选择不同的拟合函数。

    其中一种常见的形式为:二次函数拟合。

    方法

    获取实验数据x, y

    利用np.polyfit(x, y, 2)进行二次拟合

    得到拟合出的系数,进行后续的数据处理

    实例

    已知一组二次曲线型数据,要求拟合出该曲线,并且返回最大点/对称点的坐标。

    import numpy as np

    import matplotlib.pyplot as plt

    # 模拟生成一组实验数据

    x = np.arange(0,10,0.2)

    y = -(x-3.5)**2+4.7

    noise = np.random.uniform(-3,3,len(x))

    y += noise

    fig, ax = plt.subplots()

    ax.plot(x, y, 'b--')

    ax.set_xlabel('x')

    ax.set_ylabel('y')

    # 二次拟合

    coef = np.polyfit(x, y, 2)

    y_fit = np.polyval(coef, x)

    ax.plot(x, y_fit, 'g')

    # 找出其中的峰值/对称点

    if coef[0] != 0:

    x0 = -0.5 * coef[1] / coef[0]

    x0 = round(x0, 2)

    ax.plot([x0]*5, np.linspace(min(y),max(y),5),'r--')

    print(x0)

    else:

    raise ValueError('Fail to fit.')

    plt.show()

    结果

    本文地址:https://blog.csdn.net/kaever/article/details/109647871

    如您对本文有疑问或者有任何想说的,请点击进行留言回复,万千网友为您解惑!

    展开全文
  • 题目要求:请定义一个函数quadratic(a, b, c),接收3个参数,返回一元二次方程:ax^2 + bx + c = 0的两个解。程序代码:这只是一个函数,如果你不调用它的话,是不会产生任何输出的。import mathdef quadratic(a, b,...
  • 原创: 都小美 a小美碎碎念 (转载自微信公众平台)三维目标知识与技能:掌握二次函数与一元二次方程之间的关系,并且能够利用二者之间的关系解决实际问题过程与方法:通过小组探究的形式归纳出二次函数与一元二次方程...
  • 例如defadd(x,y,f):return f(x) +f(y)print(add(-8,11,abs))运行结果:19注:1、 调用add函数,分别执行abs(-8)和abc(11),并分别计算他们的值2、最后做运算map()函数map()函数python内置的一个高级函数,...
  • 分享给大家供大家参考,具体如下:背景:使用scipy拟合一元二次函数。参考:HYRY Studio-《用Python做科学计算》代码:# -*- coding:utf-8 -*-#! python3import numpy as npfrom scipy.optimize import ...
  • 函数是一段可重复使用的、具有特定功能的语句块,通过函数名来定义和调用。经过定义,函数内的语句块成为一个整体,即...同样功能的代码多使用,可以大幅的节省编程成本,提高编程效率,降低代码编程难度。同时,习
  • Python计算机视觉第二次作业 1.Harris检测角点 Harris角点检测算法是一个极为简单的角点检测算法。该算法的核心思想是,如果像素周围显示存在多于一个方向的边,我们认为该点为兴趣点,该点就为角点。 def compute_...
  • 背景:使用scipy拟合一元二次函数。参考:HYRY Studio-《用Python做科学计算》代码:import numpy as npfrom scipy.optimize import leastsqimport pylab as pldef func(x,p):"""数组拟合函数"""A,k,theta = preturn...
  • 2.3.python算法大O符号当我们试图通过执行时间来表征算法的效率时,并且独立于任何特定程序或计算机,重要的是量化算法需要的操作或者步骤的数量。选择适当的基本计算单位是个复杂的问题,并且将取决于如何实现算法...
  • 前言我们已经学习了二次函数的一般式和顶点式,顶点式展开之后就是一般式,那么一般式能变成顶点式吗?如果我们能把一般式转换为顶点式,那么我们就可以轻松找到二次函数的顶点,从而很容易画出二次函数。这个问题还...
  • python+Qt 开发的计算器原项目界面和功能如图所示:科学计算的内容基本都有,但按照项目的提示,想给函数显示图片,计算器直接退出,无任何提示。咨询无果,看源码。在logic.py里面找到关于函数图形绘制的函数如下:...
  • python+Qt 开发的计算器原项目界面和功能如图所示:科学计算的内容基本都有,但按照项目的提示,想给函数显示图片,计算器直接退出,无任何提示。咨询无果,看源码。在logic.py里面找到关于函数图形绘制的函数如下:...
  • 先看下要做的内容,创建一元二次函数y=x平方-0.5,其中为了更符合散点图模拟需要,在方程加噪点,以标准方差0.05行驶,如图所示 折线图 散点图 下面我们要做的,是要计算机自动拟合出该散点图的函数,画出...
  • python拟合二元一次函数

    千次阅读 2017-09-24 15:08:53
    使用scipy拟合一元二次函数。 参考: HYRY Studio-《用Python做科学计算》 代码: import numpy as np from scipy.optimize import leastsq import pylab as pl def func(x,p): """ 数组拟合函数 """ A,k,...
  • 分享给大家供大家参考,具体如下:背景:使用scipy拟合一元二次函数。参考:HYRY Studio-《用Python做科学计算》代码:# -*- coding:utf-8 -*-#! python3import numpy as npfrom scipy.optimize import ...
  • 分享给大家供大家参考,具体如下:背景:使用scipy拟合一元二次函数。参考:HYRY Studio-《用Python做科学计算》代码:# -*- coding:utf-8 -*-#! python3import numpy as npfrom scipy.optimize import ...
  • ,具体如下:背景:使用scipy拟合一元二次函数。参考:HYRY Studio-《用Python做科学计算》代码:# -*- coding:utf-8 -*-#! python3import numpy as npfrom scipy.optimize import leastsqimport pylab as pldef ...
  • 初识Python第1章 初识Python1.1什么是编程?编程的目的就是:让机器按照人们事先为其编写好的程序自发地去工作。1.2编程语言分为哪些种类?1.2.1机器语言机器语言是用进制代码表示的计算机能直接识别和执行的一种...
  • python求解多次方程的方法:使用import语句导入camtch(数学复杂运算)模块,用input函数获取用户输入的计算值,将数学计算多次方程的方法编写成算法,使用算法就可以解多次方程了示例如下:计算二次方程的解#二次方程...
  • 最近在学习Python,点击进入廖雪峰的官方网站在定义函数一章有个小练习,记录一下练习内容请定义一个函数quadratic(a, b, c),接收3个参数,返回一元二次方程:ax2 + bx + c = 0的两个解。提示:计算平方根可以调用...
  • 其中一种常见的形式为:二次函数拟合。 方法 获取实验数据x, y 利用np.polyfit(x, y, 2)进行二次拟合 得到拟合出的系数,进行后续的数据处理 实例 已知一组二次曲线型数据,要求拟合出该曲线,并且返回最大点/对称...
  • 练习请定义一个函数quadratic(a, b, c),接收3个参数,返回一元二次方程:ax2 + bx + c = 0的两个解。提示:计算平方根可以调用math.sqrt()函数:# -*- coding:utf-8 -*-import mathdef quadratic(a,b,c):if not ...
  • Python学习笔记:函数

    2021-03-24 19:17:25
    问题:请定义一个函数quadratic(a, b, c),接收3个参数,返回一元二次方程 ax2+bx+c=0ax^2+bx+c=0ax2+bx+c=0 的两个解。 提示:一元二次方程的求根公式: 计算平方根可以调用math.sqrt()函数: 解答: #导入math包 ...
  • 但对于大多数用户来说,选择Python作为脚本语言,主要是想利用Python社区提供的各种函数库或功能包,比如在科学计算和数据处理中常用的numpy、scipy、matplotlib、scipy等等。然而遗憾的是,NX中的Python只包含...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 402
精华内容 160
关键字:

python计算二次函数

python 订阅