小编fel*_*lix的帖子

[这与最小集合覆盖有关 ]

我想通过计算机解决以下小巧的n难题.考虑长度为n的所有2 ^ n个二进制向量.对于每一个,您只删除n/3个位,留下二进制向量长度2n/3(假设n是3的整数倍).目标是选择您删除的位,以便最小化保留在末尾的长度为2n/3的不同二进制向量的数量.

例如,对于n = 3,最佳答案是2个不同的向量11和00.对于n = 6,它是4,对于n = 9,它是6,对于n = 12,它是10.

我之前尝试将此问题解决为以下类型的最小集合覆盖问题.所有列表仅包含1和0.

我说,名单A涵盖了列表B,如果你可以B从A正好插入x符号.

考虑所有2 ^ n个1和0的长度n和集合列表x = n/3.我想计算一组2n/3涵盖所有长度的最小长度列表.David Eisenstat提供了将这个最小集合覆盖问题转换为混合整数编程问题的代码,该问题可以输入CPLEX(或http://scip.zib.de/,它是开源的).

from collections import defaultdict
from itertools import product, combinations

def all_fill(source, num):
    output_len = (len(source) + num)
    for where in combinations(range(output_len), len(source)):
        poss = ([[0, 1]] * output_len)
        for (w, s) in zip(where, source):
            poss[w] = [s]
        for tup …

我可以列出所有使用的组合,list(itertools.combinations(range(n), m)) 但这通常会非常大.

给定n和m,如何在不首先构建大量列表的情况下随机均匀地选择组合？

我在范围内有整数,0..2**m - 1我想将它们转换为长度为二进制的numpy数组m.例如,说m = 4.现在15 = 1111是二进制的,所以输出应该是(1,1,1,1). 2 = 10在二进制中,所以输出应该是(0,0,1,0).如果m是3则2应该转换(0,1,0).

我试过np.unpackbits(np.uint8(num))但是没有给出正确长度的数组.例如,

np.unpackbits(np.uint8(15))
Out[5]: array([0, 0, 0, 0, 1, 1, 1, 1], dtype=uint8)

我想要一个适用于m我在代码中的任何方法的方法.

我有以下代码尝试最小化对数似然函数.

#!/usr/bin/python
import math
import random
import numpy as np
from scipy.optimize import minimize

def loglikelihood(params, data):
    (mu, alpha, beta) = params
    tlist = np.array(data)
    r = np.zeros(len(tlist))
    for i in xrange(1,len(tlist)):
        r[i] = math.exp(-beta*(tlist[i]-tlist[i-1]))*(1+r[i-1])
    loglik  = -tlist[-1]*mu
    loglik = loglik+alpha/beta*sum(np.exp(-beta*(tlist[-1]-tlist))-1)
    loglik = loglik+np.sum(np.log(mu+alpha*r))
    return -loglik

atimes = [ 148.98894201,  149.70253172,  151.13717804,  160.35968355,
        160.98322609,  161.21331798,  163.60755544,  163.68994973,
        164.26131871,  228.79436067]
a= 0.01
alpha = 0.5
beta = 0.6
print loglikelihood((a, alpha, beta), atimes)

res = minimize(loglikelihood, (0.01, 0.1,0.1), method = 'BFGS',args …

我正在使用pygeocoder来使用像这样的代码获取lat和long的地址.

from pygeocoder import Geocoder

for a in address:
    result = Geocoder.geocode(a)
    print(result[0].coordinates)

这非常有效.有没有办法在python中实际生成带有这些点的谷歌地图网页？能够尽可能地使用一种编程语言会很棒.

我在网上搜索了很多解决方案,但没有找到合适的解决方案.也许这不可能？

在Linux中,如何将释放的内存页面清零以减小VM快照的大小？

非归零内存存储在快照中,即使该内存已被释放且不再使用.例如,内存页面从文件系统缓存中释放出来

 sync && echo 3 > /proc/sys/vm/drop_caches

不必要地存储在快照中,因为它们尚未归零.

更新一个看似有用的非常糟糕的解决方案是在循环中使用malloc + memset内存,直到OOM杀手进入.这将我测试的一个VM快照的大小从大约800MB减少到大约400MB.有更好的解决方案吗？

我正在尝试编写代码来给出递归关系的数字答案.关系本身很简单,定义如下.变量x是整数

• 如果i> 0且i <x,则p(i)= p(i + 2)/ 2 + p(i-1)/ 2
• p(0)= p(2)/ 2
• 如果i> = x,则p(i)= 1

这也是在这段代码中.

from __future__ import division
def p(i):
    if (i == 0):
        return p(2)/2
    if (i >= x):
        return 1
    return p(i-1)/2+p(i+2)/2


x = 4
#We would like to print p(0)  for example.

这当然不会让你计算p(0).你怎么能在python中做到这一点？

是否有可能建立一个numpy.linalg.solve可以求解的联立方程组？

我试图从python中的http://jheusser.github.io/2013/09/08/hawkes.html重现这项工作,除了不同的数据.我编写了代码来模拟泊松过程以及他们描述的霍克斯过程.

为了做霍克斯模型MLE,我将对数似然函数定义为

def loglikelihood(params, data):
    (mu, alpha, beta) = params
    tlist = np.array(data)
    r = np.zeros(len(tlist))
    for i in xrange(1,len(tlist)):
        r[i] = math.exp(-beta*(tlist[i]-tlist[i-1]))*(1+r[i-1])
    loglik  = -tlist[-1]*mu
    loglik = loglik+alpha/beta*sum(np.exp(-beta*(tlist[-1]-tlist))-1)
    loglik = loglik+np.sum(np.log(mu+alpha*r))
    return -loglik

使用一些虚拟数据,我们可以计算Hawkes过程的MLE

atimes=[58.98353497,   59.28420225,   59.71571013,   60.06750179,   61.24794134,
61.70692463,   61.73611983,   62.28593814,   62.51691723,   63.17370423
,63.20125152,   65.34092403,  214.24934446,  217.0390236,   312.18830525,
319.38385604,  320.31758188,  323.50201334,  323.76801537,  323.9417007]

res = minimize(loglikelihood, (0.01, 0.1,0.1),method='Nelder-Mead',args = (atimes,))
print res

但是,我不知道如何在python中执行以下操作.

1. 我怎样才能获得相同的evalCIF来获得类似的拟合与经验强度图？
2. 如何计算Hawkes模型的残差,使其等效于他们拥有的QQ图.他们说他们使用一个名为ptproc的R包但我找不到python等价物.

我正在绘制一些看起来像的数据

931,Oxfordshire,9314125,123255,Larkmead School,Abingdon,125,124,20,SUPP,8
931,Oxfordshire,9314126,123256,John Mason School,Abingdon,164,164,25,6,16
931,Oxfordshire,9314127,123257,Fitzharrys School,Abingdon,150,149,9,0,11
931,Oxfordshire,9316076,123298,Our Lady's Abingdon,Abingdon,57,57,SUPP,SUPP,16

我的基本步骤是

df = pandas.read_csv("file.csv", names=['A','B','C','D','E','F','G', 'H','I','J', 'K'], header=None)
df.replace('SUPP', 3.0, inplace=True)
df = df.convert_objects(convert_numeric=True)
df['KG'] = df['K']*1.0/df['G']
plt.plot(result['KG'])
plt.show()

但是当我将鼠标悬停在图表上时,我真的想得到每所学校的名称,以便我可以探索数据.有没有办法做到这一点？

我正在阅读有关学校的 excel 电子表格，其中包含三张纸，如下所示。

import sys
import pandas as pd
inputfile = sys.argv[1]
xl = pd.ExcelFile(inputfile)
print xl.sheet_names
df1 = xl.parse(xl.sheet_names[0], skiprows=14)
df2 = xl.parse(xl.sheet_names[1], skiprows=14)
df3 = xl.parse(xl.sheet_names[2], skiprows=14)
df1.columns = [chr(65+i) for i in xrange(len(df1.columns))]
df2.columns = df1.columns
df3.columns = df1.columns

每所学校的唯一 ID 位于三个数据帧中的每一个的“D”列中。我想制作一个有两列的新数据框。第一个是来自 df1、df2、df3 的“G”列的总和，第二个是来自 df1、df2、df3 的“K”列的总和。换句话说，我认为我需要以下步骤。

1. 过滤在所有三个数据框中实际存在唯一列“D”ID 的行。如果学校没有出现在所有三张纸中，那么我将其丢弃。
2. 对于剩余的每一行（学校），将三个数据框中“G”列中的值相加。
3. 对“K”列执行相同操作。

我是大熊猫的新手，但我该怎么做？不知何故，必须在步骤 2 和 3 中使用唯一 ID，以确保添加的值对应于同一所学校。

尝试的解决方案

df1 = df1.set_index('D')
df2 = df2.set_index('D')
df3 = df3.set_index('D')
df1['SumK']= df1['K'] +  df2['K'] + df3['K']
df1['SumG']= df1['G'] +  df2['G'] + …