精华内容
下载资源
问答
  • Java MKT(平均动力学温度)值计算

    千次阅读 2019-12-11 14:36:31
    公式这里找的 https://wenku.baidu.com/view/4293062b2f60ddccda38a0ce.html ...假设有2个温度平均值( 23°C 、25°C ),即n = 2 先列一下 各项的值(先列表,再把公式上的用表的数据代替 最后才计...
     

    公式这里找的   https://wenku.baidu.com/view/4293062b2f60ddccda38a0ce.html

              (开尔文和摄氏度的关系)    

         

    n 表示记录温度的总次数

     

     

    过程

    假设有2个温度平均值( 23°C 、25°C ),即 n = 2

    先列一下  各项的值(先列表,再把公式上的用表的数据代替  最后才计算

    (好吧。。。 不会用word画公式)

                          -10000K                                                 

    ln( (e的-33.772 次方 + e的-33.546 次方)除以2  )              

    用我大PS之术

     

    ^{}

            // 两个温湿度平均值参与计算
        double temp1 = 23.0;
        double temp2 = 25.0;
        int n = 2;
    
        double t1 = -(10000/(temp1+273.1));//t1值为 ΔH/RT ,    根据公式: H/R=10000K   K = 273.1 + 温度      所以  10000除以K  等于  t1
        double t2 = -(10000/(temp2+273.1));
        double e1 = Math.exp(t1);//求e的t1次方的值    //Math.exp(x)      e的x次方
        double e2 = Math.exp(t2);//-33.546
        double result = Math.log((e1+e2)/n);   //Math.log   对数计算(以e为底的log对数计算)
    
        System.out.println("ΔH/RT1: "+t1);
        System.out.println("ΔH/RT2: "+t2 +"\n ---------------------------- \n");
    
        System.out.printf("e 的值为 %.4f%n", Math.E);
        System.out.println("e1: "+e1);
        System.out.println("e2: "+e2+"\n ---------------------------- \n");
        System.out.println("ln结果: "+result);
        System.out.println("结果K =:"+ (-10000/result)  );
        System.out.println("最后结果: "+ ((-10000/result)-273.1)  + "\n\t也就是说MKT(平均动力学温度)为"+ String.format("%.2f", ((-10000/result)-273.1)) );

    结果
     

    ΔH/RT1: -33.77237419790611
    ΔH/RT2: -33.545790003354576
     ---------------------------- 
    
    e 的值为 2.7183
    e1: 2.1520098017475617E-15
    e2: 2.699283565142198E-15
     ---------------------------- 
    
    ln结果: -33.6526782324868
    结果K =:297.15316953128695
    最后结果: 24.053169531286926
        也就是说MKT(平均动力学温度)为24.05

     

    最终结果 

    public static void main(String[] args) {
    
            // 两个温湿度平均值参与计算
            double temp1 = 23.0;
            double temp2 = 25.0;
            List<Double> list = new ArrayList();
            list.add(temp1);
            list.add(temp2);
    
            int n = list.size();
            double temp = 0;
            for (int i = 0; i < n; i++) {
                double e = Math.exp(-10000/(list.get(i)+273.1));
                temp = temp + e;
            }
            double result = (-10000/Math.log(temp/n))-273.1;
    
            System.out.println("MKT(平均动力学温度)为"+ String.format("%.2f", result ));
        }

    同事采用C语言计算  但是没有计算对数的库,采取先计算对数的方式,     我未经许可   不敢擅自添加到博客上

    -- 2020-07-31  他发博客了

    https://blog.csdn.net/weixin_38343172/article/details/104537767

    展开全文
  • 数组求平均值

    千次阅读 2021-01-25 16:02:46
    数组求平均值 1.先定义变量sum=0求和,变量avr=0求平均数 2.让数组从第0位开始,每个元素相加到变量sum中 3.用变量sum除以数组的长度,求出平均值 4.打印在页面中 <script> var arr = [2,6,1,7,4]; var sum...

    数组求平均值

    1.先定义变量sum=0求和,变量avr=0求平均数
    2.让数组从第0位开始,每个元素相加到变量sum中
    3.用变量sum除以数组的长度,求出平均值
    4.打印在页面中

        <script>
            var arr = [2,6,1,7,4];
            var sum = 0,avr = 0;
            for(var i = 0;i < arr.length;i++){
                sum += arr[i];
            }
            avr = sum/arr.length;
            document.write("sum="+sum+"<br />");
            document.write("平均值:"+avr);
        </script>
    

    在这里插入图片描述

    展开全文
  • 1.概述 平均绝对误差(MAE)、对数平均绝对误差(LMAE)、指数平均绝对误差(EMAE)都是用来描述两条序列间各点的平均偏差程度的,区别在于他们受残差(特别是残差的离群值)的影响程度不同,按影响程度由小到大依次...
    • 1.概述
      平均绝对误差(MAE)、对数平均绝对误差(LMAE)、指数平均绝对误差(EMAE)都是用来描述两条序列间各点的平均偏差程度的,区别在于他们受残差(特别是残差的离群值)的影响程度不同,按影响程度由小到大依次是:LMAE<MAE<EMAE。因为做对数变换会压缩残差,而做指数变换会拉伸残差。将它们用作目标函数时的差别,类似于做最小二乘OLS时,对目标函数SSE的各点做加权操作,使某些偏差点占大权重,某些偏差点占小权重;参见statsmodels.api.WLS(Weighted Least Squares)

    • 2.下面给出测试代码

    import numpy as np
    import pandas as pd
    import matplotlib.pyplot as plt
    from scipy.stats import pearsonr
    
    
    freq = 'D'
    t0 = '2020-01-01'
    data_length = 7*10
    num_ts = 3
    period = 7
    fit_series, origin_series = [], []
    time_ticks = np.array(range(data_length))
    index = pd.date_range(t0, periods=data_length, freq='D')
    np.random.seed(0)
    level = 10 * np.random.rand()
    
    
    for k in range(num_ts):
        # generate fitting data
        np.random.seed(k+10)
        seas_amplitude_fit = (0.1 + 0.3*np.random.rand()) * level
        sig_fit = 0.05 * level  # noise parameter (constant in time)
        source_fit = level + seas_amplitude_fit * np.sin(time_ticks * (2 * np.pi) / period)
        noise_fit = 0.1 * sig_fit * np.random.randn(data_length)
        data_fit = source_fit + noise_fit
        fit_series.append(pd.Series(data=data_fit, index=index))
        # generate origin data
        np.random.seed(k+10)
        seas_amplitude_origin = (0.2 + 0.3 * np.random.rand()) * level
        sig_origin = 0.5 * level  # noise parameter (constant in time)
        source_origin = level + seas_amplitude_origin * np.sin(time_ticks * (2 * np.pi) / period)
        noise_origin = 0.5 * sig_origin * np.random.randn(data_length)
        data_origin = source_origin + noise_origin
        origin_series.append(pd.Series(data=data_origin, index=index))
        # plot the two contrast series
        plt.figure()
        fit_series[k].plot()
        origin_series[k].plot()
        plt.title('contrast fit_series and origin series')
        plt.show()
    
    
    def MAE(Y, y):
        """
        param:
            Y: 原始序列(假定波动较大)
            y: 拟合序列(假定波动较小)
        return:
            MAE值,该值的大小与两条序列间平均偏差程度成正比,该值越大,平均偏差程度越大;
            两序列间的残差(特别是残差的离群值)对MAE的影响比LMAE大,比EMAE小。
        """
    
        Y, y = np.array(Y), np.array(y)
        mae = sum(abs(Y - y)) / len(Y)
    
        return mae
    
    
    def LMAE(Y, y, a=np.exp(1)):
        """
        param:
            Y: 原始序列(假定波动较大)
            y: 拟合序列(假定波动较小)
            a: 对数的底数,大于1,作用于换底公式,使所有对数函数为单调递增函数;
            该值越大,则两序列间的残差(特别是残差的离群值)对LMAE返回值影响的弱化作用越明显。
        return:
            对数MAE值,该值的大小与两条序列间平均偏差程度成正比,该值越大,平均偏差程度越大;
            但两序列间的残差(特别是残差的离群值)对LMAE的影响比MAE小。
        """
    
        Y, y = np.array(Y), np.array(y)
        Y[Y < 0] = 0  # 使对数的真数≥1,从而使所有对数值非负,便于统一比较。
        y[y < 0] = 0
        lmae = sum(abs(np.log(abs(Y+1)) / np.log(a) - np.log(abs(y+1)) / np.log(a))) / len(Y)
    
        return lmae
    
    
    def EMAE(Y, y, a=1.2):
        """
        param:
            Y: 原始序列(假定波动较大)
            y: 拟合序列(假定波动较小)
            a: 指数的自变量,≥1,该值越大,则两序列间的残差(特别是残差的离群值)对EMAE返回值影响的强化作用越明显;
            当a=1时,EMAE化简为MAE。
        return:
            指数MAE值,该值的大小与两条序列间平均偏差程度成正比,该值越大,平均偏差程度越大;
            且两序列间的残差(特别是残差的离群值)对EMAE的影响比MAE大。
        """
    
        Y, y = np.array(Y), np.array(y)
        Y[Y < 0] = 0  # 使指数的底数≥1,则所有指数均为递增函数
        y[y < 0] = 0
        emae = sum(abs((Y+1)**a - (y+1)**a)) / len(Y)
    
        return emae
    
    
    a, b, c = [], [], []
    for k in range(num_ts):
        a.append(MAE(origin_series[k], fit_series[k]))
        b.append(LMAE(origin_series[k], fit_series[k]))
        c.append(EMAE(origin_series[k], fit_series[k]))
    print(' 每对序列的MAE:', '\n', a, '\n', '每对序列的LMAE:', '\n', b, '\n', '每对序列的EMAE:', '\n', c, '\n')
    print(' EMAE - MAE', '\n', np.array(c)-np.array(a), '\n', 'MAE - LMAE', '\n', np.array(a)-np.array(b), '\n')
    print(' MAE与LMAE间的相关程度:', '\n', pearsonr(a, b), '\n', 'MAE与EMAE间的相关程度:', '\n', pearsonr(a, c), '\n',
          'LMAE与EMAE间的相关程度:', '\n', pearsonr(c, b), '\n')
    
    

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    • 3.结果分析
      3.1. 从以上三图可以看到,Figure2的平均偏差最小,Figure3的平均偏差最大。
      3.2. 从数值结果也可以看到,每对序列的MAE、LMAE、EMAE,都是第二列数值最小(对应Figure2),第三列数值最大(对应Figure3),与三张图的偏差程度相符。
      3.3. 三对序列的EMAE-MAE均为正,说明EMAE放大了残差;MAE-LMAE均为正,说明LMAE缩小了残差,与公式的作用是相符的。
      3.4. 三对序列的MAE、LMAE、EMAE的相关系数都很高,P值都很小,说明MAE、LMAE、EMAE几乎完全正相关,则三种指标对序列间平均偏差程度的判断结果几乎是完全等效的,采用任何一种均可。
      3.5. 对于r和P值的解释:例如三对序列的MAE与LMAE的r≈99.95%,P-value≈1.97%,说明对于[1.1384901846078306, 1.0264781458259842, 1.3147042766176245] 与[0.19016978075266716, 0.16388341516116947, 0.22711381950612006]这两条序列,从不相关系统中产生线性相关程度为99.95%的这样两条序列的概率为1.97%,而在一次试验中这样小概率的事件是不可能发生的,所以我们拒绝这两条序列是从不相关系统中产生的这一原假设,转而接受这两条序列是线性相关的这一备择假设。
    展开全文
  • 这两个事情看起来都很简单,那么计算数组的平均值并不是很难了吧。解法如下: function average(nums) { return nums.reduce((a, b) => a + b) / nums.length; } 复制代码 确实不是很难,是吧?但是如果...

    函数式编程中用于操作数组的方法就像“毒品”一样,它让很多人爱上函数式编程。因为它们真的十分常用而且又超级简单。 .map().filter()都仅需一个参数,该参数定义操作数组每一个元素的函数即可。reduce()会复杂一些,我之前写过一篇文章介绍为什么人们难以掌握reduce()方法,其中一个原因在于很多入门资料都仅仅用算术作为例子。我写了很多用reduce()来做算术以外的例子。

    reduce()来计算数组的平均值是一个常用的模式。代码看起来非常简单,不过在计算最终结果之前你需要做两个准备工作:

    • 数组的长度
    • 数组所有元素之和

    这两个事情看起来都很简单,那么计算数组的平均值并不是很难了吧。解法如下:

    function average(nums) {
        return nums.reduce((a, b) => a + b) / nums.length;
    }
    复制代码

    确实不是很难,是吧?但是如果数据结构变得复杂了,就没那么简单了。比如,数组里面的元素是对象,你需要先过滤掉某些对象,然后从对象中取出数字。这样的场景让计算平均值变得复杂了一点。

    接下来我们处理一个类似的问题(从this Free Code Camp challenge获得灵感),我们会提供 5 种不同的解法,每一种方法有各自的优点和缺点。这 5 种方法也展示了 JavaScript 的灵活。我希望可以给你在使用reduce的实战中一些灵感。

    问题提出

    假设我们有一个数组,记录了维多利亚时代常用的口语。接下来我们要找出那些依然现存于 Google Books 中的词汇,并计算他们的平均流行度。数据的格式是这样的:

    const victorianSlang = [
        {
            term: "doing the bear",
            found: true,
            popularity: 108
        },
        {
            term: "katterzem",
            found: false,
            popularity: null
        },
        {
            term: "bone shaker",
            found: true,
            popularity: 609
        },
        {
            term: "smothering a parrot",
            found: false,
            popularity: null
        },
        {
            term: "damfino",
            found: true,
            popularity: 232
        },
        {
            term: "rain napper",
            found: false,
            popularity: null
        },
        {
            term: "donkey’s breakfast",
            found: true,
            popularity: 787
        },
        {
            term: "rational costume",
            found: true,
            popularity: 513
        },
        {
            term: "mind the grease",
            found: true,
            popularity: 154
        }
    ];
    复制代码

    接下来我们用 5 中不同的方法计算平均流行度值。

    1. for 循环

    初次尝试,我们不使用reduce()。如果你对数组的常用函数不熟悉,用 for 循环可以让你更好地理解我们要做什么。

    let popularitySum = 0;
    let itemsFound = 0;
    const len = victorianSlang.length;
    let item = null;
    for (let i = 0; i < len; i++) {
        item = victorianSlang[i];
        if (item.found) {
            popularitySum = item.popularity + popularitySum;
            itemsFound = itemsFound + 1;
        }
    }
    const averagePopularity = popularitySum / itemsFound;
    console.log("Average popularity:", averagePopularity);
    复制代码

    如果你熟悉 JavaScript,上面的代码理解起来应该很容易:

    1. 初始化polularitySumitemsFound变量。popularitySum记录总的流行度值,itemsFound记录我们已经找到的所有的条目;
    2. 初始化lenitem来帮助我们遍历数组;
    3. for 循环每一次增加i的值,直到循环n次;
    4. 在循环中,我们每次取出当前索引位置的条目vitorianSlang[i]
    5. 检查该条目是否在 Google Books 中
    6. 如果在,获取popularity并累加到popularitySum
    7. 并递增itemsFound
    8. 最后,用popularitySum除以itemsFound来计算平均值。

    代码虽然不是那么简洁,但是顺利完成了任务。使用数组迭代方法可以更加简洁,接下来开始吧…..

    2. 简单模式: filter, map 和 sum

    我们首先将这个问题拆分成几个子问题:

    1. 使用fitler()找到那些在 Google Books 中的条目;
    2. 使用map()获取流行度;
    3. 使用reuduce()来计算总的流行度;
    4. 计算平均值。

    下面是实现代码:

    // 辅助函数
    // ----------------------------------------------------------------------------
    function isFound(item) {
        return item.found;
    }
    
    function getPopularity(item) {
        return item.popularity;
    }
    
    function addScores(runningTotal, popularity) {
        return runningTotal + popularity;
    }
    
    // 计算
    // ----------------------------------------------------------------------------
    
    // 找出所有isFound为true的条目
    const foundSlangTerms = victorianSlang.filter(isFound);
    
    // 从条目中获取流行度值,返回为数组
    const popularityScores = foundSlangTerms.map(getPopularity);
    
    // 求和
    const scoresTotal = popularityScores.reduce(addScores, 0);
    
    // 计算平均值
    const averagePopularity = scoresTotal / popularityScores.length;
    console.log("Average popularity:", averagePopularity);
    复制代码

    注意看addScores函数以及调用reduce()函数的那一行。addScores()接收两个参数,第一个runningTotal,我们把它叫做累加数,它一直记录着累加的总数。每访问数组中的一个条目,我们都会用addScores函数来更新它的值。第二个参数popularity是当前某个元素的值。注意,第一次调用的时候,我们还没有runningTotal的值,所以在调用reduce()的时候,我们给runningTotal初始化。也就是reduce()的第二个参数。

    这个版本的代码简洁很多了,也更加的直观。我们不再告诉 JavaScript 引擎如何循环,如何对当前索引的值做操作。我们定义了很多小的辅助函数,并且把它们组合起来完成任务。filter()map()reduce()帮我们做了很多工作。上面的实现更加直观地告诉我们这段代码要做什么,而不是底层如何去实现。

    3. 简单模式 II: 记录多个累加值

    在之前的版本中,我们创建了很多中间变量:foundSlangTermspopularityScores。接下来,我们给自己设一个挑战,使用链式操作,将所有的函数调用组合起来,不再使用中间变量。注意:popularityScores.length变量需要用其它的方式来获取。我们可以在addScores的累加参数中记录它。

    // 辅助函数
    // ---------------------------------------------------------------------------------
    function isFound(item) {
        return item.found;
    }
    
    function getPopularity(item) {
        return item.popularity;
    }
    
    // 我们使用一个对象来记录总的流行度和条目的总数
    function addScores({ totalPopularity, itemCount }, popularity) {
        return {
            totalPopularity: totalPopularity + popularity,
            itemCount: itemCount + 1
        };
    }
    
    // 计算
    // ---------------------------------------------------------------------------------
    
    const initialInfo = { totalPopularity: 0, itemCount: 0 };
    const popularityInfo = victorianSlang
        .filter(isFound)
        .map(getPopularity)
        .reduce(addScores, initialInfo);
    
    const { totalPopularity, itemCount } = popularityInfo;
    const averagePopularity = totalPopularity / itemCount;
    console.log("Average popularity:", averagePopularity);
    复制代码

    我们在reduce函数中使用对象来记录了totalPopularityitemCount。在addScores中,每次都更新itemCount的计数。

    通过filtermapreduce计算的最终的结果存储在popularityInfo中。你甚至可以继续简化上述代码,移除不必要的中间变量,让最终的计算代码只有一行。

    4. point-free 式函数组合

    注意: 如果你不熟悉函数式语言或则觉得难以理解,请跳过这部分!

    如果你熟悉curry()compose(),接下来的内容就不难理解。如果你想知道更多,可以看看这篇文章: ‘A Gentle Introduction to Functional JavaScript’. 特别是第三部分

    我们可以使用compose函数来构建一个完全不带任何变量的代码,这就叫做point-free的方式。不过,我们需要一些帮助函数。

    // 辅助函数
    // ----------------------------------------------------------------------------
    const filter = p => a => a.filter(p);
    const map = f => a => a.map(f);
    const prop = k => x => x[k];
    const reduce = r => i => a => a.reduce(r, i);
    const compose = (...fns) => arg => fns.reduceRight((arg, fn) => fn(arg), arg);
    
    // The blackbird combinator.
    // See: https://jrsinclair.com/articles/2019/compose-js-functions-multiple-parameters/
    const B1 = f => g => h => x => f(g(x))(h(x));
    
    // 计算
    // ----------------------------------------------------------------------------
    
    // 求和函数
    const sum = reduce((a, i) => a + i)(0);
    
    // 计算数组长度的函数
    const length = a => a.length;
    
    // 除法函数
    const div = a => b => a / b;
    
    // 我们使用compose()来将函数组合起来
    // compose()的参数你可以倒着读,来理解程序的含义
    const calcPopularity = compose(
        B1(div)(sum)(length),
        map(prop("popularity")),
        filter(prop("found"))
    );
    
    const averagePopularity = calcPopularity(victorianSlang);
    console.log("Average popularity:", averagePopularity);
    复制代码

    我们在compose中做了所有的计算。从后往前看,首先filter(prop('found'))筛选出所有在 Google Books 中的条目,然后通过map(prop('popularity'))获取所有的流行度数值,最后使用 magical blackbird (B1) combinator 来对同一个输入进行sumlength的计算,并求得平均值。

    // All the lines below are equivalent:
    const avg1 = B1(div)(sum)(length);
    const avg2 = arr => div(sum(arr))(length(arr));
    const avg3 = arr => sum(arr) / length(arr);
    const avg4 = arr => arr.reduce((a, x) => a + x, 0) / arr.length;
    复制代码

    不要担心看不明白,上面主要是为大家演示有 4 种方式来实现average功能。这就是 JavaScript 的优美之处。

    相对来说,本文的内容是有点极客的。虽然笔者之前深度使用函数式语言 Haskell 做过不少研究项目,对函数式颇有理解,但是 point-free 风格的代码,我们是不建议在实际工程中使用的,维护成本会很高。我们Fundebug所有的代码都要求直观易懂,不推崇用一些奇淫技巧来实现。除非某些万不得已的地方,但是一定要把注释写得非常清楚,来降低后期的维护成本。

    5. 终极优化: 一次计算出结果

    之前所有的解法都可以很好地工作。那些使用reduce()的解法都有一个共同点,它们将大的问题拆解问小的子问题,然后通过不同的方式将它们组合起来。但是也要注意它们对数组遍历了三次,感觉很没有效率。如果一次就可以计算出来,才是最佳的方案。确实可以,不过需要一点数学运算。

    为了计算 n 个元素的平均值,我们使用下面的公式:

     

     

     

    那么,计算 n+1 个元素的平均值,使用同样的公式(唯一不同的是 n 变成 n+1):

     

     

     

    它等同于:

     

     

     

    同样等同于:

     

     

     

    做点变换:

     

     

     

    结论是,我们可以一直记录当前状态下的所有满足条件的元素的平均值。只要我们知道之前所有元素的平均值和元素的个数。

    // 求平均值
    function averageScores({ avg, n }, slangTermInfo) {
        if (!slangTermInfo.found) {
            return { avg, n };
        }
        return {
            avg: (slangTermInfo.popularity + n * avg) / (n + 1),
            n: n + 1
        };
    }
    
    const initialVals = { avg: 0, n: 0 };
    const averagePopularity = victorianSlang.reduce(averageScores, initialVals).avg;
    console.log("Average popularity:", averagePopularity);
    复制代码

    这个方法只需要遍历一次就计算出平均值,缺点是我们做了更多的计算。每一次当元素满足条件,都要做乘法和除法,而不是最后才做一次除法。不过,它使用了更少的内存,因为没有中间的数组变量,我们只是记录了一个仅仅有两个元素的对象。

    这样写还有一个缺点,代码一点都不直观,后续维护麻烦。至少一眼看过去不能理解它是做什么的。

    所以,到底哪一种方案才是最好的呢?视情形而定。也许你有一个很大的数组要处理,也许你的代码需要在内存很小的硬件上跑。在这些场景下,使用第 5 个方案最佳。如果性能不是问题,那么就算使用最低效的方法也没问题。你需要选择最适合的。

    还有一些聪明的朋友会思考:是否可以将问题拆解为子问题,仍然只遍历一次呢?是的,确实有。需要使用 transducer。

     

    如果你对编程感兴趣或者想往编程方向发展,可以关注微信公众号【筑梦编程】,大家一起交流讨论!小编也会每天定时更新既有趣又有用的编程知识!
     

    展开全文
  • 图像平均亮度公式

    千次阅读 2013-04-22 15:28:16
    平均亮度的计算由下面的公式给出: ...接着对所有像素亮度值的对数平均值,再求平均值的自然指数值。至于为什么这样算出的值能够合理地表示图像的平均亮度,这里就不再详细说明了,有兴趣可以参
  • Unity常用数学计算公式

    千次阅读 2016-11-16 17:48:20
    Mathf.Abs绝对值  计算并返回指定参数 f 绝对值。...以弧度为单位计算并返回参数 f 中指定的数字的反余弦。  Mathf.Approximately近似  static function Approximately (a : float, b:
  • 接收机灵敏度的计算公式推导和分析

    万次阅读 多人点赞 2017-02-23 14:10:33
    接收机灵敏度定义的接收机能够接收到的并且还能正常工作的最低电平强度。 接收机灵敏度跟很多东西有关,如噪声系数、信号带宽、解调信噪比等,灵敏度...公式为:-174+NF+10lgB+10lgSNR (NF噪声系数、B信号带宽、
  • 信息论之父 C. E. Shannon 在 1948 年发表的论文“通信的数学理论(A Mathematical ...Shannon 借鉴了热力学的概念,把信息中排除了冗余后的平均信息量称为“信息熵”,并给出了计算信息熵的数学表达式。 假设信息中...
  • 平均值mean,众数mode,中值median 和 标准差stddev 均值,众数,中位数,标称差: 均值是就全部数据计算的,它具有优良的数学性质,是实际中应用最广泛的集中趋势测度值.其主要缺点是易受数据极端值的影响,对于偏...
  • 首先,我们看一下两种计算方法的公式: 百分比收益率计算:Rb=( s2- s1)/ s1= s2/ s1-1 对数收益率计算:Rd=ln(s2/ s1) 其中,s1,s2,s3是连续各期的股价,Rb表示百分比收益率,Rd表示对数收益率。  由定义可...
  • 虽然不是最精确的计算平均值的方法,但是相比于原有的计算平均值需要保存所有数据求和后取平均的方法效率更高和资源占用率大大减小.所以在 机器学习中大部分采用指数加权平均的方法计算平均值 .递推公式如下(占用...
  • 目录1. 对数变换 log transformation2....它们的主要作用在于它能帮助稳定方差,始终保持分布接近于正态分布并使得数据与分布的平均值无关。 3. 取对数的意义 缩小数据的绝对数值,方便计算对数后,可
  • 离散值计算方法JAVA实现

    千次阅读 2018-07-23 17:55:20
    最近做数据分析时需要用到一个离散值的东西我个人的理解就是每个数与所有数平均值的差的平均实现方法如下:publicstaticdoubledoCal(double[]datas){ //平均值 doublepingjun=0; //总和/个数 doubletotal=0;...
  • 对数几率回归

    千次阅读 2018-08-06 16:48:55
    对数几率回归 ...个人觉得是因为它跟线性回归的公式有点关联。 对数几率函数是sigmoid函数。 1、模型 线性回归:z=w∗x+bz=w∗x+bz = w*x+ b 逻辑回归:y=11+e−zy=11+e−zy = \frac{1}{1+e^...
  • 2.2 平均灰度处理方法 该方法的灰度值等于彩色图像 R,G,B 是哪个分量灰度值的求和平均值,其计算公式如下所示: 这种方法产生的灰度图像比较柔和。 平均灰度处理方法实现代码如下所示: 1 2 3 4 5 6 7 8 9 10 11 ...
  •  其中这个算法里使用了log对数域,这个主要原因不是为了扩展低灰度,压缩高灰度,而是为了避免负值的灰度。是因为原图像直接减去滤波后的图像,可能会出现负值,处理麻烦,如果是装换到对数域的话,虽然相减...
  • 本文内容 算术平均 几何平均 调和平均 平方平均 移动平均 算术平均、几何平均、调和平均、平方平均和移动平均跟计算编程有什么关系:Just One Word,不能只会算术平均数,还有...计算公式为: 即,n 个数据...
  • 1 对数几率回归原理分析 1.1 引入 1.2 损失函数 1.3 求最优解 2 对数几率回归实践 Logistic回归的一般过程 Logistic回归的优缺点 Logistic回归算法描述(改进的随机梯度下降) 《机器学习实战》第五章代码...
  • 图示代码,轻松解决IV值计算问题(python)

    万次阅读 多人点赞 2018-09-03 03:14:07
    今天来讲一下IV计算问题 因本人从事风控建模行业,故不可避免需要明白IV的整个今生前世,故此次来讲解IV。 一、IV的定义及必备常见知识 IV是什么?全称是InformationValue,中文意思是信息价值,或者信息...
  • 使用STM32的HAL库,配置多通道ADC,用DMA采集,算数平均值滤波,把GL5528光敏电阻得到的数据,转为光照度Lux,其中有Matlab计算公式与函数拟合,数据处理。
  • MIT自然语言处理第五讲:最大熵和对数线性模型(第一部分) 自然语言处理:最大熵和对数线性模型 Natural Language Processing: Maximum Entropy and Log-linear Models  作者:Regina Barzilay...
  • 对数阶排序算法

    千次阅读 2015-03-18 09:53:49
    建堆过程简单上界可以这么计算:由于从底向上建堆,时间复杂度应该是调整的节点数x每个节点数下面调整的时间,假设n个节点,就是3n/2xlogN。通过公式推导严格来说建堆接近线性时间O(n)。 堆排序中包含了建堆和...
  • 1、应用背景:实际业务场景,我们会遇到一些特征随着时间(量)的变大,实际的意义成指数衰减或增加。例如: 用户收到的邮件越多,每封邮件对用户的影响越小,因此计算每封邮件的价值时,我们不能等同计算,需要做...
  • 使用C++、opencv实现对图像的对数变换及非线性变换,实现图像增强 相关API: void normalize(InputArray src, OutputArray dst, double alpha=1, double beta=0, int norm_type=NORM_L2, int dtype=-1, Input...
  • 对数几率回归 —— Logistic Regression

    千次阅读 2018-07-02 16:13:12
     由于借助对数几率函数,其输出是介于0~1之间连续概率。仔细查看,不难发现,当真实   时,第一项为0,当真实   时,第二项为0,所以,这个损失函数其实在每次计算时永远都只有一项在发挥作用,那这不就...
  • AUC的计算优化

    千次阅读 2019-06-19 22:56:14
    AUC AUC主要用于评估当前模型的排序能力,假设一共有m条正样本和n条负样本,模型为model,那么通过model可以对其中每一条记录进行预测并获得概率。 对于m条正样本和n条负样本,一共可以有mn中二元组合方式...
  • 变量的系数为0.468,表示其他人种的平均工资比白人高0.468个单位,但是在统计上不显著。 在实证分析中,有时会根据研究内容的需要改变基准组的设定,此时可使用 ib. 或 b. 的前缀,具体写法如下 表2 中所描述: ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 17,854
精华内容 7,141
关键字:

对数平均值计算公式