标签: stochastic

我的数据集具有m要素和n数据点。设w一个向量（待估计）。我正在尝试使用随机更新方法来实现梯度下降。我的最小化功能是least mean square。

更新算法如下所示：

for i = 1 ... n data:
    for t = 1 ... m features:
         w_t = w_t - alpha * (<w>.<x_i> - <y_i>) * x_t

其中<x>是要素的原始向量m，<y>是真实标签的列向量，并且alpha是一个常数。

我的问题：

• 现在根据Wiki，我不需要遍历所有数据点，并且当错误足够小时我可以停止。是真的吗

• 我不明白这里应该是什么停止标准。如果有人可以帮助您，那就太好了。

• 使用此公式-我使用的公式for loop正确吗？我相信(<w>.<x_i> - <y_i>) * x_t是我的?Q(w)。

现在我正在写一篇关于 SAT 解答的文章，但我陷入了困境。我希望你能帮助我。

我想描述一些解决 SAT 问题的方法。现在我有三种不同的方式：

\n
1. 暴力破解
\n
2. 随机（天真的）
\n
3. DPLL（具有不同的启发式）
\n
4. ？丢失的 ？
\n
5. ...
\n

我的问题是唯一有效的算法是 DPLL（以及其他一些与 DPLL 略有不同的算法）。因此我没有什么可以与 DPLL 进行比较。

我的问题：如果您能告诉我一些不基于 DPLL (DP) 的算法，我可以将其进行比较，那就太好了。

以下是我发现的一些，但无法确定它们是否是一个不错的选择，或者是否有更好的选择：

\n
• 莫尼恩-斯佩肯梅尔
\n
• 丹辛、戈特、赫希和 Sch\xc3\xb6ning
\n
• Paturi-Pudl\xc3\xa1k-Zane-算法
\n
• 霍夫迈斯特、Sch\xc3\xb6ning、舒勒和渡边
\n

感谢您的帮助。

例如，下面的代码模拟了几何布朗运动（GBM）过程，它满足以下随机微分方程：

该代码是这篇 Wikipedia 文章中代码的精简版本。

import numpy as np
np.random.seed(1)

def gbm(mu=1, sigma = 0.6, x0=100, n=50, dt=0.1):
    step = np.exp( (mu - sigma**2 / 2) * dt ) * np.exp( sigma * np.random.normal(0, np.sqrt(dt), (1, n)))
    return x0 * step.cumprod()

series = gbm()

如何在 Python 中拟合 GBM 过程？也就是说，如何估计mu和sigma求解给定时间序列的随机微分方程series？

我有一个随机微分方程 (SDE)，我试图使用 Milsteins 方法求解它，但得到的结果与实验不一致。

SDE 是

我已将其分解为 2 个一阶方程：

方程1：

方程2：

然后我使用了 Ito 形式：

所以对于 eq1：

对于 eq2：

我用来尝试解决这个问题的python代码是这样的：

# set constants from real data
Gamma0 = 4000  # defines enviromental damping
Omega0 = 75e3*2*np.pi # defines the angular frequency of the motion
eta = 0 # set eta 0 => no effect from non-linear p*q**2 term
T_0 = 300 # temperature of enviroment
k_b = scipy.constants.Boltzmann 
m = 3.1e-19 # mass of oscillator

# set a and b functions …

我正在编写一个Android应用程序,通过以下公式为每个客户端提供长用户ID:

long userID = (long) (Math.random() * 2 * Long.MAX_VALUE - Long.MAX_VALUE);

我是否正确使用MAX_VALUE,即利用每一个可能的长值？

我有两个重复用户ID与10k,100k或100万用户的几率是多少？我该如何计算呢？

我的目标是在外汇市场上有一个显示随机振荡器的图,为了验证哪个参数是设置它的最佳参数,我会使用滑块修改它并在图上显示更新的结果.

我有我的历史数据,对于一个已定义的对(比如说是AUDUSD),加载后,我计算了Stocastic振子:

function [stoch, fk, dk] = stochastic(n, k, d)
    X=csvread("AUDUSD_2017.csv");
    C=X(2:length(X),5);
    L=X(2:length(X),4);
    H=X(2:length(X),3);
    O=X(2:length(X),2);
    for m=n:length(C)-n
        stoch(m)=((C(m)-min(L(m-n+1:m)))/(max(H(m-n+1:m))-min(L(m-n+1:m))))*100;

    endfor

for m=n:length(C)-n

    fk(m)=mean(stoch(m-d:m));

 endfor
for m=n:length(C)-n

    dk(m)=mean(fk(m-d:m));
endfor


endfunction

这是我在绘制stoch,fk和dk时所拥有的图片:

我会在图中添加3个滑块,以便在一个范围内更改参数作为输入,即,使用滑块将第一个参数"n"更改为3到50之间,"k"更改为2到20之间,以及"d" "在2到20之间.

我会在octave中使用UI包,当我使用滑块时,有人可以告诉我更新的情节吗？

弗朗切斯科

我正在尝试求解布朗粒子和 Langevein Dynamics 的 SDE。\n首先我尝试使用普通随机数生成器来模拟 2D 布朗运动，\n代码是：

import numpy as np\nimport matplotlib.pyplot as plt\n\n%matplotlib inline\ndt = .001  # Time step.\nT = 2.  # Total time.\nn = int(T / dt)  # Number of time steps.\nt = np.linspace(0., T, n)  # Vector of times.\nsqrtdt = np.sqrt(dt)\ny = np.zeros(n)\nx = np.zeros(n)\n\n\nfor i in range(n-1):\n  x[i + 1] = x[i] +  np.random.normal(0.0,1.0)\n  y[i + 1] = y[i] +  np.random.normal(0.0,1.0)\n\n\nfig, axs = plt.subplots(1, 1, figsize=(12, 12))\nplt.plot(y, x, label =\'Position\')\nplt.title("Simulation of Brownian motion") \nplt.show()\n

我有一个遗传算法，目前正在使用轮盘赌选择来生成新的种群，我想将其更改为随机通用采样。

我对这里的工作方式有一个粗略的概述：

pointerDistance = sumFitness/popSize
start = rand.uniform(0, pointerDistance)
for i in xrange(popSize):
    pointers.append(start + i*pointerDistance)
cumulativeFit = 0
newIndiv = 0
for p in pointers:
    while cumulativeFit <= p:
        cumulativeFit += pop[newIndiv].fitness
        newPop[newIndiv] = copy.deepcopy(pop[newIndiv])
        newIndiv += 1

但我正在努力解决如何准确地实现随机通用采样。有谁知道一些伪代码或示例的好来源？

用一个例子简要描述什么是随机通用采样（但我不确定它是否有意义？）：

http://en.wikipedia.org/wiki/Stochastic_universal_sampling

随机爬山和首选爬山算法有什么区别？

我正在尝试使用值迭代（通过 pymdptoolbox）和 NumPy找到此图中指定的马尔可夫决策过程问题的最佳策略。但是 pymdptoolbox 说我的转换矩阵“不是随机的”。

是不是因为有 [0, 0, 0, 0] 的数组？有些转换是不可能的，比如从状态 1 到状态 3。如果不是用零，我如何表示这些不可能的转换？

我的代码：

import mdptoolbox 
import numpy as np

transitions = np.array([
#action1
    [
            [0.2, 0.8, 0, 0], #s1
            [0, 0, 0, 0], #s2
            [0, 0, 0, 0], #s3
            [0, 0, 0.9, 0.1] #s4
    ],

#action2
    [
            [0.2, 0, 0, 0.8], #s1
            [0, 0.2, 0.8, 0], #s2
            [0, 0, 0, 0], #s3
            [0, 0, 0, 0] #s4
    ],

#action3
    [
            [0, 0, 0, 0], #s1
            [0.8, …

我正在做文档分类并获得了高达 76% 的准确率。在预测文档类别时，我遵循了一个

doc_clf.predict(tf_idf.transform((count_vect.transform([r'document']))))

我收到以下错误：

File "/usr/local/lib/python3.5/dist- packages/sklearn/utils/metaestimators.py", line 115, in <lambda>
  out = lambda *args, **kwargs: self.fn(obj, *args, **kwargs)
File "/usr/local/lib/python3.5/dist-packages/sklearn/pipeline.py", line 306, in predict
  Xt = transform.transform(Xt)
File "/usr/local/lib/python3.5/dist-packages/sklearn/feature_extraction/text.py", line 923, in transform
  _, X = self._count_vocab(raw_documents, fixed_vocab=True)
File "/usr/local/lib/python3.5/dist-packages/sklearn/feature_extraction/text.py", line 792, in _count_vocab
  for feature in analyze(doc):
File "/usr/local/lib/python3.5/dist-packages/sklearn/feature_extraction/text.py", line 266, in <lambda>
  tokenize(preprocess(self.decode(doc))), stop_words)
File "/usr/local/lib/python3.5/dist-packages/sklearn/feature_extraction/text.py", line 232, in <lambda>
  return lambda x: strip_accents(x.lower())
File "/usr/local/lib/python3.5/dist-packages/scipy/sparse/base.py", line 647, in __getattr__
  raise AttributeError(attr + " not found") …

我尝试了解如何用数值方法求解随机微分方程（SDE）（我没有任何语言的经验，但出于某些原因，我选择了Julia）。作为初始模型，我决定使用Lotka-Volterra方程。我阅读了DifferentialEquations.jl的手册和教程。虽然我的模型是一个简单的ODE系统：

一切正常：

using DifferentialEquations
using Plots
function lotka(du,u,p,t);
    , , ,  = p; 
    du[1] = *u[1]-*u[1]*u[2];
    du[2] = *u[1]*u[2]-*u[2];
end
u0 = [15.0,1.0,0.0,0.0];
p = (0.3,0.05,0.7,0.1);
tspan = (0.0,50.0);
prob = ODEProblem(lotka,u0,tspan,p);
sol = solve(prob);
plot(sol,vars = (1,2))

现在，我要添加Ornstein-Uhlenbeck噪声：

愚蠢的简单解决方案是：

using DifferentialEquations
using Plots
function lotka(du,u,p,t);
    , , , , ,  = p; 
    du[1] = *u[1]-*u[1]*u[2]+u[3];
    du[2] = *u[1]*u[2]-*u[2]+u[4];
    du[3] = -u[3]/+sqrt((2.0*^2.0/))*randn();
    du[4] =  -u[4]/+sqrt((2.0*^2.0/))*randn();
end
u0 = [15.0,1.0,0.0,0.0];
p = (0.3,0.05,0.7,0.1,0.1,0.1);
tspan = …

我写了一个随机过程模拟器,但我想加快它,因为它很慢.

模拟器的主要部分是一个for循环,我想重写为foreach%%dopar%.

我试过用简化的循环这样做,但我遇到了一些问题.假设我的for循环看起来像这样

library(foreach)

r=0
t<-rep(0,500)
for(n in 1:500){
    s<-1/2+r
    u<-runif(1, min = 0, max = 1)
    if(u<s){
        t[n]<-u
        r<-r+0.001
    }else{r<-r-0.001}
}

这意味着在每次迭代时我都会更新和的值,r并且s在两个结果中的一个中填充我的向量t.我已经尝试了几种不同的方式将它重新编写为foreach循环,但似乎每次迭代我的值都没有得到更新,我得到一些非常奇怪的结果.我尝试过使用return但似乎没有用!

这是我想出的一个例子.

rr=0
tt<-foreach(i=1:500, .combine=c) %dopar% {
    ss<-1/2+rr
    uu<-runif(1, min = 0, max = 1)
    if(uu<=ss){
        return(uu)
        rr<-rr+0.001
    }else{
        return(0)
        rr<-rr-0.001}
}

如果不可能使用foreach其他方式让我重新编写循环,以便能够使用所有内核并加快速度？