精华内容
下载资源
问答
  • 此仓库包含一个教程,该教程显示了从基本骨干用户管理SPA到功能全面可部署应用程序的迭代步骤。 从视频获得碱应用称为“Backbone.js入门视频教程”。 在本视频中, 在创建基本的骨干用户管理应用程序方面做得...
  • 迭代(一):迭代算法的基本思想

    千次阅读 2019-06-14 17:37:00
    迭代法也称辗转法,是一种不断用变量的旧... 迭代算法的基本思想是:为求一个问题的解x,可由给定的一个初值x0,根据某一迭代公式得到一个新的值x1,这个新值x1比初值x0更接近要求的值x;再以新值作为初值,即:x1→...

          迭代法也称辗转法,是一种不断用变量的旧值推出新值的过程。它是解决问题的一种基本方法,通过让计算机对一组指令(或一定步骤)进行重复执行,在每次执行这组指令(或这些步骤)时,都从变量的原值推出它的一个新值。

          迭代算法的基本思想是:为求一个问题的解x,可由给定的一个初值x0,根据某一迭代公式得到一个新的值x1,这个新值x1比初值x0更接近要求的值x;再以新值作为初值,即:x1→x0,重新按原来的方法求x1,重复这一过程直到|x1-x0|<ε(某一给定的精度)。此时可将x1作为问题的解x。

          利用迭代算法解决问题,需要做好以下三个方面的工作:

          (1)确定迭代变量。在可以用迭代算法解决的问题中,至少存在一个直接或间接地不断由旧值推出新值的变量,这个变量就是迭代变量。

          (2)建立迭代关系式。所谓迭代关系式,指如何从变量的前一个值推出其下一个值的公式(或关系)。迭代关系式的建立是解决迭代问题的关键。

          (3)对迭代过程进行控制。在什么时候结束迭代过程?这是编写迭代程序必须考虑的问题。不能让迭代过程无休止地重复执行下去。迭代过程的控制通常可分为两种情况:一种是所需的迭代次数是个确定的值,可以计算出来;另一种是所需的迭代次数无法确定。对于前一种情况,可以构建一个固定次数的循环来实现对迭代过程的控制;对于后一种情况,需要进一步分析出用来结束迭代过程的条件。

          迭代也是用循环结构实现,只不过要重复的操作是不断从一个变量的旧值出发计算它的新值。其基本格式描述如下:

    迭代变量赋初值;

    while (迭代终止条件)

    {

          根据迭代表达式,由旧值计算出新值;

          新值取代旧值,为下一次迭代做准备;

    }

    【例1】验证谷角猜想

          日本数学家谷角静夫在研究自然数时发现了一个奇怪现象:对于任意一个自然数 n ,若 n 为偶数,则将其除以 2 ;若 n 为奇数,则将其乘以 3 ,然后再加 1 。如此经过有限次运算后,总可以得到自然数 1 。人们把谷角静夫的这一发现叫做“谷角猜想”。

          要求:编写一个程序,由键盘输入一个自然数 n ,把 n 经过有限次运算后,最终变成自然数 1 的全过程打印出来。

          (1)编程思路

          定义迭代变量为n,按照谷角猜想的内容,可以得到两种情况下的迭代关系式:当 n 为偶数时,n=n/2 ;当 n 为奇数时, n=n*3+1 。

          这就是需要计算机重复执行的迭代过程。这个迭代过程需要重复执行多少次,才能使迭代变量 n 最终变成自然数 1 ,这是我们无法计算出来的。因此,还需进一步确定用来结束迭代过程的条件。由于对任意给定的一个自然数 n ,只要经过有限次运算后,能够得到自然数 1 ,从而完成验证工作。因此,用来结束迭代过程的条件可以定义为: n==1 。

    (2)源程序

    #include <iostream>

    using namespace std;

    int main()

    {

       unsigned int data; 

       cout<<"请输入一个自然数:"; 

       cin>>data; 

       while(data!=1) 

       { 

            if((data%2==0)) 

                  {

                cout<<data<<"/2=";

                         data/=2; 

                         cout<<data<<endl;

                  }

            else 

            { 

                cout<<data<<"*3+1=";

                         data=data*3+1; 

                cout<<data<<endl; 

            } 

       } 

       return 0;

    }

    【例2】求平方根

          用迭代法求某个数的平方根。已知求平方根的迭代公式为:

          (1)编程思路

          用迭代法求某个数a的平方根的算法为:

          (1)先自定一个初值x0,作为a的平方根值,例如,取a/2作为x0的初值。利用迭代公式求出一个x1。此值与真正的a的平方根值相比,误差可能很大。

          (2)把新求得的x1代入x0中,准备用此新的x0再去求出一个新的x1。

          (3)利用迭代公式再求出一个新的x1的值,也就是用新的x0又求出一个新的平方根值x1,此值将更趋近于真正的平方根值。

          (4)比较前后两次求得的平方根值x0和x1,如果它们的差值小于指定的值(如0.000001),即达到要求的精度,则认为x1就是a的平方根值,执行步骤5;否则执行步骤2,即循环进行迭代。  

          (5)迭代结束,输出结果x1。

    (2) 源程序

    #include <iostream>

    #include <cmath>

    using namespace std;

    int main()

    {

        double x0,x1,a ;

           cin>>a;

        x0 =a/2;          // 迭代初值

        x1 =0.5*(x0 + a/x0);

        do

           {

             x0 = x1;  // 为下一次迭代作准备

             x1 = 0.5*(x0 + a/x0);

        } while (fabs(x1-x0)>0.000001);

        cout<<x1<<endl;       // 输出结果

           return 0 ;

    }

    转载于:https://www.cnblogs.com/cs-whut/p/11024564.html

    展开全文
  • (此文所指设计是指批量销售产品,而非定制话个案) 很多有两到三年开发经验程序员很想提高自己应用程序设计分析能力,希望可以以后做系统分析师,可是这项技能很难从书本或者网络直接学习到,身边又没有...

    (此文所指设计是指批量销售的产品,而非定制话的个案)

    很多有两到三年开发经验的程序员很想提高自己的应用程序设计分析能力,希望可以以后做系统分析师,可是这项技能很难从书本或者网络直接的学习到,身边又没有合适的老师,所以经常无所适从,往往是设计模式比他们的架构师背的还熟,可是就是什么也设计不好。

    写这些系列的文章,并不打算让你从程序员可以“突变”成分析师,只是为你提供学习的方向和零碎的技巧。

    好,言归正传,我们怎么做分析,刚开始的时候,你不要想着一下子接收一个系统过来,即使再小(麻雀虽小,五脏俱全)也不好。比较容易接手的项目是一些独立的小模块,他们看起来功能单一,你所需要考虑的面就小的多。

    现在就假设你已经“光荣”的接到这个模块的设计任务,有些人可能已经迫不及待的编码的一番(这个功能太简单了),呵呵,不是太好,虽然我也是搞极限编程的,但是也不推荐一点不做系统分析。还是按部就班一二三:

    • 找合理的功能用例;
    • 分析排列用例的重要级别;
    • 设计出满足基本功能的第一个版本(没有文档吗?是的,基本上只有用例);
    • 使用用例测试;
    • 加入部分未实现的用例,重构当前版本,再来一个轮回。
    • 直到你认为工期就要到了,赶紧收手,或者你很聪明,搞定了所有用例;
    • 出文稿吧。

    嗯?和书上写的差不多吗?当然差不多,我还没有神奇到可以发明成一种新的设计方法论。事实上,只是帮你复习一下:)。

    步骤都一样,最重要的还是看到底怎么做。

    怎么做找用例

    要找到合理的用例是十分重要的,一般你可以在这些地方找到用例:

    • 现有产品的功能,如果你有老版本,那现有的功能怎么可以丢呢?否则你的功能做的再天花乱坠,客户还是说:这个都没有以前的好。
    • 竞争对手的产品,其实我们的销售人员在外面推销的时候,除了花60%的时间陪客户,10%的时间讲我们的功能,还有30%的时间在讲竞争对手的产品怎么怎么的不好,你看我这个功能他们就没有。能够将竞争对手好的设计“吸收”进来,会给你减少很多麻烦。
    • 来自以前的不管是做好的,还是未做好的二次开发案例,既然存在这些案例,就表示事实存在这些需求。
    • 好吧,如果你真的时间好充足,精力好旺盛,老板也批准的话,你还有一个选择,挑几个你的典型用户,到客户那边去,像个空气人一样的在那里看他们怎么工作的。千万不要拿个本子,露出微笑的面孔,来一句:请问,您有什么需求啊。

    哦,你一定发现了,我把与客户交流放在最后了,这是不是大忌?这个问题我就要讲讲找用例的注意事项了:

    • 你面对的客户是他所在行业的专业人员,不是“软件专业人员”,你才是“人才”,你问他需求,搞错了吧?所以到客户那里是用自己的主观去“悟”别人的需求。他们提出的需求是外行的需求,你要自己悟出来成内行的需求。
    • 用例切记防止需求膨胀,需求膨胀主要表现有:
      • 暂时不要的功能,未来8年的功能基本就不要考虑了;
      • 过分的性能和负载,明明是几百人的小厂,却想办法要搞一个负载平衡,上千在线用户并发操作;
      • 过多的兼容性,你的产品明明就只卖1万块钱,你却要搞SQLServer和Oracle两个版本出来;
      • 客户随口的“强烈”需求。这个就不要说了,好多文章发过此类警告。
    • 用例必须是简单的,对于总结出来的用例,必须非常的简单,如果太复杂,建议再拆分成几个更简单的用例。简单的用例能够减少交流时的歧义。

    网上有很多的需求用例的模板,可以参考拿来用用,一般最重要的是:输入和输出,需要描述的很准确。

    好了,文章也一样,还是短一点的好,我将有空的时候再继续写:如何将需求用例转化为代码。

    展开全文
  • 本文以逻辑回归拟合二维数据为例进行演示tensorflow的基本开发步骤。 实例:从一组看似混乱的数据中找出y≈2x的规律 实例描述: 假设有一组数据集,其x和y的对应关系为y≈2x。 深度学习大概有如下四个步骤: (1) ...

    本文以逻辑回归拟合二维数据为例进行演示tensorflow的基本开发步骤。

    实例:从一组看似混乱的数据中找出y≈2x的规律

    实例描述:

    假设有一组数据集,其x和y的对应关系为y≈2x。

    深度学习大概有如下四个步骤:

    (1) 准备数据
    (2) 搭建模型
    (3) 迭代训练
    (4) 使用模型

    3、迭代训练

    (1)训练模型

    通过初学深度学习(一)TensorFlow基本开发步骤之准备数据and搭建模型(正向+反向)的第二步搭建模型中建立好的模型,就可以通过迭代训练模型了。

    注意:tensorflow中的任务是通过session来进行的

    # 初始化变量
    init = tf.global_variables_initializer() # global_variables_initializer()函数初始化所有变量
    
    # 训练参数
    training_epochs = 20 # 设置迭代次数为20次
    display_step = 2
    
    # 启动session
    with tf.Session() as sess:
        sess.run(init) # 通过sess.进行网络节点的运算
        plotdata = {"batchsize":[],"loss":[]} # 存放批次值和损失值
    
        # 向模型输入数据
        for epoch in range(training_epochs):
            for (x, y) in zip(train_X, train_Y):
                sess.run(optimizer, feed_dict={X: x, Y: y}) # 通过feed机制将真实数据灌到占位符(第二步创建模型时)对应的位置
    
            # 输出显示训练中的详细信息,每执行一次都会将网络结构的节点打印出来
            if epoch % display_step == 0:
                loss = sess.run(cost, feed_dict={X: train_X, Y:train_Y})
                print ("Epoch:", epoch+1, "cost=", loss,"W=", sess.run(W), "b=", sess.run(b))
                if not (loss == "NA" ):
                    plotdata["batchsize"].append(epoch)
                    plotdata["loss"].append(loss)
    
        print (" Finished!")
        print ("cost=", sess.run(cost, feed_dict={X: train_X, Y: train_Y}), "W=", sess.run(W), "b=", sess.run(b))
    

    结果显示:
    在这里插入图片描述

    由以上结果可以看出,cost(生成的预测值与真实值之间的差距)在不断的变小,W和b(两个参数)也在不断的变换。

    (2)训练模型的可视化

    # 初始化变量
    init = tf.global_variables_initializer() # global_variables_initializer()函数初始化所有变量
    
    # 训练参数
    training_epochs = 20 # 设置迭代次数为20次
    display_step = 2
    
    # 启动session
    with tf.Session() as sess:
        sess.run(init) # 通过sess.进行网络节点的运算
        plotdata = {"batchsize":[],"loss":[]} # 存放批次值和损失值
    
        # 向模型输入数据
        for epoch in range(training_epochs):
            for (x, y) in zip(train_X, train_Y):
                sess.run(optimizer, feed_dict={X: x, Y: y}) # 通过feed机制将真实数据灌到占位符(第二步创建模型时)对应的位置
    
            # 输出显示训练中的详细信息,每执行一次都会将网络结构的节点打印出来
            if epoch % display_step == 0:
                loss = sess.run(cost, feed_dict={X: train_X, Y:train_Y})
                print ("Epoch:", epoch+1, "cost=", loss,"W=", sess.run(W), "b=", sess.run(b))
                if not (loss == "NA" ):
                    plotdata["batchsize"].append(epoch)
                    plotdata["loss"].append(loss)
    
        print (" Finished!")
        print ("cost=", sess.run(cost, feed_dict={X: train_X, Y: train_Y}), "W=", sess.run(W), "b=", sess.run(b))
    
        def moving_average(a,w=10): # 定义moving_average()函数
            if len(a) < w:
                return a[:]
            return [val if idx<w else sum(a[(idx-w):idx])/w for idx,val in enumerate(a)]
    
        #图形显示
        plt.plot(train_X, train_Y, 'ro', label='Original data')
        plt.plot(train_X, sess.run(W) * train_X + sess.run(b), label='Fitted line')
        plt.legend()
        plt.show()
    
        plotdata["avgloss"] = moving_average(plotdata["loss"])
        plt.figure(1)
        plt.subplot(211)
        plt.plot(plotdata["batchsize"], plotdata["avgloss"], 'b--')
        plt.xlabel('Minibatch number')
        plt.ylabel('Loss')
        plt.title('Minibatch run vs. Training loss')
        plt.show()
    

    结果显示:
    在这里插入图片描述

    • 第一张图中所示的斜线,是模型的参数w和b为常量时所组成的关于x与y的直线方程,几乎是一条y=2x的直线。
    • 第二张图可以看出刚开始损失值一直下降,到第五次左右趋于平稳。

    4、使用模型

    模型训练好后,只需要往里面传入一个输入值,然后使用sess.run来运行模型中的各个节点就可以使用模型了。

    # 初始化变量
    init = tf.global_variables_initializer() # global_variables_initializer()函数初始化所有变量
    
    # 训练参数
    training_epochs = 20 # 设置迭代次数为20次
    display_step = 2
    
    # 启动session
    with tf.Session() as sess:
        sess.run(init) # 通过sess.进行网络节点的运算
        plotdata = {"batchsize":[],"loss":[]} # 存放批次值和损失值
    
        # 向模型输入数据
        for epoch in range(training_epochs):
            for (x, y) in zip(train_X, train_Y):
                sess.run(optimizer, feed_dict={X: x, Y: y}) # 通过feed机制将真实数据灌到占位符(第二步创建模型时)对应的位置
    
            # 输出显示训练中的详细信息,每执行一次都会将网络结构的节点打印出来
            if epoch % display_step == 0:
                loss = sess.run(cost, feed_dict={X: train_X, Y:train_Y})
                print ("Epoch:", epoch+1, "cost=", loss,"W=", sess.run(W), "b=", sess.run(b))
                if not (loss == "NA" ):
                    plotdata["batchsize"].append(epoch)
                    plotdata["loss"].append(loss)
    
        print (" Finished!")
        print ("cost=", sess.run(cost, feed_dict={X: train_X, Y: train_Y}), "W=", sess.run(W), "b=", sess.run(b))
    
        def moving_average(a,w=10): # 定义moving_average()函数
            if len(a) < w:
                return a[:]
            return [val if idx<w else sum(a[(idx-w):idx])/w for idx,val in enumerate(a)]
    
        #图形显示
        plt.plot(train_X, train_Y, 'ro', label='Original data')
        plt.plot(train_X, sess.run(W) * train_X + sess.run(b), label='Fitted line')
        plt.legend()
        plt.show()
    
        plotdata["avgloss"] = moving_average(plotdata["loss"])
        plt.figure(1)
        plt.subplot(211)
        plt.plot(plotdata["batchsize"], plotdata["avgloss"], 'b--')
        plt.xlabel('Minibatch number')
        plt.ylabel('Loss')
        plt.title('Minibatch run vs. Training loss')
        plt.show()
        
        print ("x=0.2,z=", sess.run(z, feed_dict={X: 0.2}))
    

    如上面代码的最后一行即:往里面传入一个0.2(feed_dict={X: 0.2}),然后使用sess.run来运行模型中的z节点,就可以查看其生成的值。

    产生结果:
    在这里插入图片描述

    展开全文
  • 基本步骤 1、 准备数据集 2、 定义网络结构 3、定义损失函数 4、定义优化算法 5、迭代训练 1、准备好Tensor形式输入数据及标签(涉及到torch.utils.data.Dataset和DataLoader) 2、定义好网络前向传播用于计算网络...

    基本步骤

    1、 准备数据集

    2、 定义网络结构

    3、定义损失函数

    4、定义优化算法

    5、迭代训练

    1、准备好Tensor形式的输入数据及标签(涉及到torch.utils.data.Dataset和DataLoader)
    2、定义好网络前向传播用于计算网络的输出(output)以及网络的损失(loss)
    3、定义传播进行网络参数更新:
    (1)将上一个迭代所计算的梯度进行清零:optimizer.zero_grad()
    (2)进行本次迭代的梯度计算:loss.backward()
    (3)更新网络的权值参数:optimizer.step()
    保存训练集上的loss以及验证集上的loss以及准确率,并打印可视化

    import torch
    import torch.nn as nn
    import numpy as np
    import matplotlib.pyplot as plt
    
    
    # Hyper-parameters 定义迭代次数, 学习率以及模型形状的超参数
    input_size = 1
    output_size = 1
    num_epochs = 60
    learning_rate = 0.001
    
    # Toy dataset  1. 准备数据集
    x_train = np.array([[3.3], [4.4], [5.5], [6.71], [6.93], [4.168], 
                        [9.779], [6.182], [7.59], [2.167], [7.042], 
                        [10.791], [5.313], [7.997], [3.1]], dtype=np.float32)
    
    y_train = np.array([[1.7], [2.76], [2.09], [3.19], [1.694], [1.573], 
                        [3.366], [2.596], [2.53], [1.221], [2.827], 
                        [3.465], [1.65], [2.904], [1.3]], dtype=np.float32)
    
    # Linear regression model  2. 定义网络结构 y=w*x+b 其中w的size [1,1], b的size[1,]
    model = nn.Linear(input_size, output_size)
    
    # Loss and optimizer 3.定义损失函数, 使用的是最小平方误差函数
    criterion = nn.MSELoss()
    # 4.定义迭代优化算法, 使用的是随机梯度下降算法
    optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)  
    loss_dict = []
    # Train the model 5. 迭代训练
    for epoch in range(num_epochs):
        # Convert numpy arrays to torch tensors  5.1 准备tensor的训练数据和标签
        inputs = torch.from_numpy(x_train)
        targets = torch.from_numpy(y_train)
    
        # Forward pass  5.2 前向传播计算网络结构的输出结果
        outputs = model(inputs)
        # 5.3 计算损失函数
        loss = criterion(outputs, targets)
        
        # Backward and optimize 5.4 反向传播更新参数
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    
        
    
    
    
    
    展开全文
  • 变分迭代的应用

    2012-03-20 23:22:54
    变分迭代方法是一种简洁有效的求微分方程各种定解问题的方法,主要是变分法 和迭代... 1、熟悉微分方程各种定解问题 2、了解变分迭代方法的基本思想,掌握变分迭代方法的基本步骤. 3、会用理论针对某个简单实例展开研究
  • 搭建神经网络的基本步骤

    千次阅读 2019-03-08 22:14:14
    1 搭建神经网络的步骤 搭建神经网络,可分为四步完成:准备工作、前向传播、反向传播、循环迭代 1-0 准备工作 导入模块,生成数据集 import 常量定义 生成数据集 1-1 前向传播 定义输入、输出和参数 x =...
  • 迭代的含义及操作

    千次阅读 2016-06-23 17:02:24
    迭代的基本含义:基本:迭代是重复反馈过程的活动,其目的通常是为了接近并到达所需的目标或结果。每一次对过程的重复被称为一次“迭代”,而每一次迭代得到的结果会被用来作为下一次迭代的初始值。 计算机:在...
  • (1) 定义TensorFlow输入节点(2) 定义”学习参数”变量(3) 定义”运算”(4) 定义优化函数,优化目标(5) 初始化所有变量.(6) 迭代更新参数到最优解(7) 测试模型(8) 使用模型 一. 定义输入节点:分为三种、{...
  • 目录 ...迭代次数 打乱数据(Shuffling) 正则化 评估模型准确率 二元分类(Binary Classification) 多类分类(Multiclass Classification) 回归(Regression) 提高模型精度 模型拟...
  • 迭代算法概念

    千次阅读 2018-11-27 21:22:20
     迭代算法是用计算机处理问题一种基本方法。它利用计算机运算速度快、适合做重复性操做特点,让计算机对一组指令(或一定步骤)进行重复执行,在每次执行这组指令(或这些步骤)时,都从变量原值推出它一个新值...
  • 迭代

    2008-04-28 11:43:00
    迭代算法是用计算机解决问题一种基本方法。它利用计算机运算速度快、适合做重复性操作特点,让计算机对一组指令(或一定步骤)进行重复执行,在每次执行这组指令(或这些步骤)时,都从变量原值推出它一个新...
  • 为什么要使用迭代迭代器接口 迭代器的使用步骤 迭代的基本原理 ListIterator和Iterator的区别
  • 对数据库的基本操作步骤 + 面试题 MyBatis 最初的设计是基于 XML 配置文件的,但随着 Java 的发展(Java 1.5 开始引入注解)和 MyBatis 自身的迭代升级,终于在 MyBatis 3 之后就开始支持基于注解的开发了。 下面...
  • 迭代

    2021-04-12 11:10:44
    迭代 算法是用计算机解决问题一种基本方法。它利用计算机运算速度快、适合做重复性操作特点,让计算机对一组指令(或一定步骤)进行重复执行,在每次执行这组指令(或这些步骤)时,都从变量原值推出它一个...
  • 针对如何快速确定分数阶Fourier 变换最佳阶次问题,在分析拟牛顿迭代基本原理基础上,研究了其在这一实际应用中具体实现步骤.通过仿真实验展现了拟牛顿迭代法搜索分数阶Fourier变换最佳变换阶次收敛过程,...
  • 迭代与递归区别

    2016-07-15 13:02:48
    迭代算法是用计算机解决问题一种基本方法。它利用计算机运算速度快、适合做重复性操作特点,让计算机对一组指令(或一定步骤)进行重复执行,在每次执行这组指令(或这些步骤)时,都从变量原值推出它一个新...
  • 迭代算法

    2017-10-07 11:41:26
    迭代算法是用计算机解决问题一种基本方法。它利用计算机运算速度快、适合做重复性操作特点,让计算机对一组指令(或一定步骤)进行重复执行,在每次执行这组指令(或这些步骤)时,都从变量原值推出它一个新值。...
  • 迭代算法是用计算机解决问题一种基本方法。 利用迭代算法解决问题,需要以下三个步骤: 1.确定迭代变量  在可以用迭代算法解决问题中,至少存在一个直接或间接地不断由旧值递推出新值变量,这个变量就是...
  • 迭代

    2016-03-02 15:49:38
    迭代算法是用计算机解决问题一种基本方法。它利用计算机运算速度快、适合做重复性操作特点,让计算机对一组指令(或一定步骤)进行重复执行,在每次执行这组指令(或这些步骤)时,都从变量原值推出它一个新
  • 准备数据 ... 将上次迭代计算梯度值清0optimizer.zero_grad() 反向传播,计算梯度值loss.backward() 更新权值参数optimizer.step() 保存训练集上loss和验证集上loss以及准确率以及打印
  • 变分迭代算法

    2012-03-20 23:13:14
    变分迭代方法是一种简洁有效的求微分方程各种定解问题的方法,主要是变分法 和迭代... 1、熟悉微分方程各种定解问题 2、了解变分迭代方法的基本思想,掌握变分迭代方法的基本步骤. 3、会用理论针对某个简单实例展开研究
  • 1. 前言:随着Web项目不断规范以及测试驱动开发理念,以及迭代开发和Dailybuild等概念产生,自动化测试是一个很重要发展方向,它可以及时得发现新开发功能对旧有功能影响,同时由于可以自动化测试,减轻...
  • 为提高该方法的工作效率,用"迭代位移叠加法"对目标斑点图进行预处理,经少数几次位移叠加的步骤后,很快就提供了目标像的基本结构和分布,得到了积木块投放点的位置,从而避免了盲目投放,大大减少了迭代投放的次数,显著...
  • 迭代化开发主要理解瀑布模型在需求变更方面带来的缺陷,以及迭代化开发的基本步骤,从风险控制的角度,迭代化开发可以在项目初期就把风险降下来。需求管理主要理解为什么要做需求管理,即需求管理的目标是什么,...

空空如也

空空如也

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

迭代的基本步骤