标签: mathematical-optimization

我需要找到构成一定金额的最佳硬币组合.基本上,我想用最少量的硬币到达那里.

例如:

如果货币系统有硬币:{13,8,1},那么贪婪的解决方案会将24改为{13,8,1,1,1},但真正的最优解是{8,8,8} .

我希望用Javascript写这个,但伪代码很好,因为我相信这会帮助更多的人.

我正在scipy.optimize.leastsq和模拟器一起使用.leastsq调用用户定义的目标函数并将输入向量传递给它.反过来,目标函数返回错误向量.leastsq以这样的方式优化输入向量,使得误差向量的平方和最小化.

在我的情况下,目标函数将在每次调用时运行整个模拟.使用的模拟器是单线程的,每次运行需要几分钟.因此,我想一次运行模拟器的多个实例.但是,对目标函数的调用是连续执行的.

如何leastsq一次执行对目标函数的多次调用？

这是我在Interviewstreet 代码印刷中遇到的一个问题.我无法找到解决方案,甚至没有想到它的方向.如果有人能帮助我找到灵魂,或者解释我需要如何解决这个问题,我会感激不尽.

给定数字1,2,3,...,N,按顺序排列它们,使得生长数字的乘积之和最大化.

例如:如果N = 3,我们将它们命名为(1,2,3),产品总和为1*2 + 2*3 = 8,如果我们将它们命名为(1,3,2),则总和产品是1*3 + 3*2 = 9.

输入格式:

输入的第一行包含T,测试用例的数量.然后按照T行,每行包含一个整数N.

输出格式 :

对于每个测试用例,打印相邻数字的最大乘积和.

样本输入:

2 2 4

样本输出:

2 23

说明:

在给出置换的第一个测试案例中是(1,2).所以产品的最大总和是1*2.在第二个测试案例中,数字是(1,2,3,4).排列1,3,4,2具有相邻数字的乘积之和为1*3 + 3*4 + 4*2 = 23.没有其他排列的相邻数的乘积之和超过23.

制约因素:

1 <= T <= 10 1 <= N <= 200000

我试图理解算法的概念,以及它们如何提高计算机程序的性能.

所以假设,我必须编写一个程序,生成一个数字列表,

1. 从数字1开始.

2. 添加3.

3. 将结果(1 + 3 = 4)存储在列表中.

4. 将5添加到新号码.

5. 将结果(4 + 5 = 9)存储在列表中.

6. 保持另外将3和5添加到列表中的最新数字.

现在这是一个非常简单的程序,并且假设程序必须在数字大于10,00,000时停止,并且假设一个简单的程序执行此操作需要10秒来生成列表.

如何为此问题设计算法,以便程序花费较少的时间来生成列表.

注意 - 我试图通过一个例子来理解这里的概念,上面提到的时间是随机的而不是事实的.如果有人能够帮助我用一个"简单"的例子来理解这个概念,如果他们不想使用上面的例子那就太棒了.

我是机器学习和统计学的新手.因为我使用opencv作为我的项目(我在visual studio中使用)并且想要执行难以执行的基础执行操作.所以,我搜索并征求专家的意见,以获得基于c ++的高效编程库(我来自电子背景和c ++知识绰绰有余).我有信息你可以在eclipse上构建R程序>

能否请一些关于在Visual Studio上运行R的参考资料？

Rcpp是否在Visual Studio上运行？

我正在尝试编写一个公式来确定一个a最小化函数输出的值myfun(即a-fptotal).MWE:

c <- as.matrix(c(.25,.5,.25))
d <- as.matrix(c(10000,12500,15000))
e <- 700
f <- 1.1
tr <- .30

myfun <- function(a) {
   b <- max(a-e,0)
   df <- data.frame(u1=c(c*b*.40),u2=c(c*b*.60))
   df$year <- 1:nrow(df)
   df$factor <- 1/(f)^df$year
   df$d <- d
   df$t <- (df$d-df$u1-df$u2)*tr
   df$f <- df$d-df$t
   df$fp <- df$f*df$factor
   fptotal <- sum(df$fp)
   return(a-fptotal) # what is a good approach to minimize this?
}

我尝试过这样的事情没有任何成功:

o2 <- optimize(myfun, lower = 0, upper = 30000)

正确的答案应该是28355:

myfun(28355)  
## [1] …

我的代码是使用L-BFGS优化来实现主动学习算法.我想优化四个参数:alpha,beta,w和gamma.

但是,当我运行下面的代码时,我收到一个错误:

optimLogitLBFGS = sp.optimize.fmin_l_bfgs_b(func, x0 = x0, args = (X,Y,Z), fprime = func_grad)                                           
  File "C:\Python27\lib\site-packages\scipy\optimize\lbfgsb.py", line 188, in fmin_l_bfgs_b
    **opts)
  File "C:\Python27\lib\site-packages\scipy\optimize\lbfgsb.py", line 311, in _minimize_lbfgsb
    isave, dsave)
    _lbfgsb.error: failed in converting 7th argument ``g' of _lbfgsb.setulb to C/Fortran array 
    0-th dimension must be fixed to 22 but got 4

我的代码是:

# -*- coding: utf-8 -*-
import numpy as np
import scipy as sp
import scipy.stats as sps

num_labeler = 3 …

我正在尝试使用最小化复杂（向量）变量的功能scipy.optimize。到目前为止，我的结果表明这可能是不可能的。为了研究这个问题，我实现了一个简单的示例-最小化带有偏移量的复数向量的2范数：

import numpy as np
from scipy.optimize import fmin

def fun(x):
    return np.linalg.norm(x - 1j * np.ones(2), 2)

sol = fmin(fun, x0=np.ones(2) + 0j)

输出是

Optimization terminated successfully.
         Current function value: 2.000000
         Iterations: 38
         Function evaluations: 69

>>> sol
array([-2.10235293e-05,  2.54845649e-05])

显然，解决方案应该是

array([0.+1.j, 0.+1.j])

对此结果感到失望，我也尝试过scipy.optimize.minimize：

from scipy.optimize import minimize

def fun(x):
    return np.linalg.norm(x - 1j * np.ones(2), 1)

sol = minimize(fun, x0=np.ones(2) + 0j)

输出是

>>> sol
      fun: 2.0
 hess_inv: array([[ 9.99997339e-01, -2.66135332e-06],
       [-2.66135332e-06,  9.99997339e-01]])
      jac: …

我正在使用betareg软件包进行beta回归，但是收到以下错误：

optim中的错误（par =开始，fn = loglikfun，gr = gradfun，方法=方法，：由optim提供的非有限值

我可以将此错误追溯到为创建初始值optim。具体地，这些线betareg.fit，其使用lm.wfit生成的起始值。

事实证明，返回的起始值之一与NA我的数据集一样。我不确定为什么会这样，因为在的数据/输入中没有缺失值lm.wfit。

可复制的示例，不适用

## data -- a sample of 100 obs from my actual data
nobs <- 100L
w <- rep(1, nobs)
offset <- rep(0, nobs)
y <- stats::rbeta(nobs, 0.75, 1.658)
x <- structure(c(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, …

我正在寻找一种比在这样的问题中找到最佳系数(又称权重)的快于强力的算法:

将样本定义为一系列N个数字.在这种情况下,比如说N = 10.样本数M非常大,比如M = 1000000.这基本上是M行XN列的矩阵.所以这些样本的集合如下所示:

S_0_0  S_0_1 S_0_2 ... S_0_N
S_1_0  S_1_1 S_1_2 ... S_1_N
...
S_M_0  S_M_1 S_M_2 ... S_M_N

此外,还有一系列相应的N个权重.权重系列P的数量也很大,比如P = 2000000.这是P行XN列的另一个矩阵.它看起来类似于样本集:

W_0_0  W_0_1 S_0_2 ... W_0_N
W_1_0  W_1_1 S_1_2 ... W_1_N
...
W_P_0  W_P_1 S_P_2 ... W_P_N

我试图找到一系列权重(即权重集中的右行),它最大化了以下总和(即行x):

W_x_0 * S_0_0  +  W_x_1 * S_0_1  + ... +  W_x_N * S_0_N +
W_x_0 * S_1_0  +  W_x_1 * S_1_1  + ... +  W_x_N * S_1_N + …