小编use*_*060的帖子

挑战:

在两个大小相等的缓冲区上执行按位XOR.缓冲区将需要是python str类型,因为传统上它是python中数据缓冲区的类型.将结果值作为a返回str.尽快做到这一点.

输入是两个1兆字节(2**20字节)的字符串.

挑战是使用python或现有的第三方python模块(轻松的规则:或创建自己的模块)大幅击败我的低效算法.边际增加是无用的.

from os import urandom
from numpy import frombuffer,bitwise_xor,byte

def slow_xor(aa,bb):
    a=frombuffer(aa,dtype=byte)
    b=frombuffer(bb,dtype=byte)
    c=bitwise_xor(a,b)
    r=c.tostring()
    return r

aa=urandom(2**20)
bb=urandom(2**20)

def test_it():
    for x in xrange(1000):
        slow_xor(aa,bb)

简单的机器学习问题.可能有很多方法可以解决这个问题:

有4个可能的事件无限流:

'event_1', 'event_2', 'event_4', 'event_4'

事件不是完全随机的.我们假设大多数事件都有一些复杂的模式,其余的事件只是随机的.我们提前不知道这些模式.

收到每个事件后,我想根据事件过去的顺序预测下一个事件的内容.所以我的问题是:我应该为这个预测器使用什么机器学习算法？

然后,预测器将被告知下一个事件实际上是什么:

Predictor=new_predictor()

prev_event=False
while True:
    event=get_event()
    if prev_event is not False:
        Predictor.last_event_was(prev_event)
    predicted_event=Predictor.predict_next_event(event)

问题在于预测者应该维持多长时间的历史,因为维持无限的历史将是不可能的.我会把这个留给你回答.但实际上答案不可能是无足轻重的.

因此,我认为预测必须通过某种滚动的历史来完成.因此,添加新事件并使旧事件过期应该相当有效,并且不需要重建整个预测器模型.

具体的代码,而不是研究论文,将为您的回复增添巨大的价值.Python或C库很不错,但任何事情都可以.

更新:如果在每一轮中同时发生多个事件,该怎么办？这会改变解决方案吗？

我有一个我认为是一个简单的机器学习问题.

这是基本问题:我反复给出一个新对象和一个关于该对象的描述列表.例如:new_object:'bob'new_object_descriptions : ['tall','old','funny']. 然后,我必须使用某种机器学习来查找具有10个或更少相似描述的先前处理的对象,例如,past_similar_objects : ['frank','steve','joe']. 接下来,我有一个算法可以直接测量这些对象是否确实类似于bob,例如correct_objects : ['steve','joe']. 然后给分类器进行成功匹配的反馈训练.然后这个循环重复一个新对象.这是伪代码:

Classifier=new_classifier()

while True:
    new_object,new_object_descriptions = get_new_object_and_descriptions()
    past_similar_objects = Classifier.classify(new_object,new_object_descriptions)
    correct_objects = calc_successful_matches(new_object,past_similar_objects)
    Classifier.train_successful_matches(object,correct_objects)

但是,有一些规定可能限制可以使用的分类器:

• 将有数百万个对象放入此分类器中,因此分类和培训需要能够很好地扩展到数百万个对象类型,并且仍然很快.我认为这取消了类似垃圾邮件分类器的资格,这种分类器只适用于两种类型:垃圾邮件或非垃圾邮件.(更新:如果这是一个问题,我可以将其缩小到数千个对象而不是数百万个.)

• 再次,当数百万个物体被分类时,我更喜欢速度,而不是准确性.

• 更新:分类器应根据过去训练的反馈返回10个(或更少)最相似的对象.没有这个限制,一个明显的作弊将是分类器可以只返回所有过去的对象:)

为此目的,什么是体面的,快速的机器学习算法？

注意:calc_successful_matches距离度量计算起来非常昂贵,这就是为什么我使用快速机器学习算法来尝试在实际进行昂贵的计算之前猜测哪些对象将会关闭.

我有一个简单的问题,我相信这里有人已经做过......

我想重写第4层TCP/IP流(不是低层单独的数据包或帧.)Ettercap的etterfilter命令允许您基于固定字符串或正则表达式执行第4层TCP/IP流的简单实时替换.示例ettercap脚本代码:

 if (ip.proto == TCP && tcp.dst == 80) {
    if (search(DATA.data, "gzip")) {
       replace("gzip", "    ");
       msg("whited out gzip\n");
    }
 }

 if (ip.proto == TCP && tcp.dst == 80) {
    if (search(DATA.data, "deflate")) {
       replace("deflate", "       "); 
       msg("whited out deflate\n");
    }
 } 

http://ettercap.sourceforge.net/forum/viewtopic.php?t=2833

我想基于我自己的过滤器程序重写流,而不是简单的字符串替换.任何人都知道如何做到这一点？除了Ettercap之外还有什么可以做这样的实时替换,可能作为VPN软件的插件还是什么？

我想在两个以太网接口之间进行类似于ettercap的静默桥接嗅探配置的配置.通过这种方式,我可以无声地过滤来自任一方向的流量而不会出现NAT问题.请注意,我的过滤器是一个充当管道过滤器的应用程序,类似于unix命令行过滤器的设计:

 >[eth0] <----------> [my filter] <----------> [eth1]<

我的过滤器将是用户空间Python函数.

我已经知道但不适合:

• Tun/Tap - 在较低的数据包层工作,我需要使用更高层的流.

• Ettercap - 除了上面示例中的受限功能之外,我找不到任何替换方法.

• 挂进一些VPN软件？ - 我无法弄清楚究竟是哪种或者究竟是怎样的.

• libnetfilter_queue - 使用较低层数据包,而不是TCP/IP流.

同样,重写应该在传输层(第4层)发生,就像在本例中那样,而不是基于较低层数据包的方法.确切的代码将极大地帮助!

谢谢!

有一个1千兆字节的任意数据字符串,你可以认为它等同于:

1_gb_string=os.urandom(1*gigabyte)

我们将搜索此字符串,1_gb_string以获得无限数量的固定宽度,1千字节模式,1_kb_pattern.每次我们搜索模式都会有所不同.所以缓存机会并不明显.将反复搜索相同的1千兆字节的字符串.这是一个简单的生成器来描述正在发生的事情:

def findit(1_gb_string):
    1_kb_pattern=get_next_pattern()
    yield 1_gb_string.find(1_kb_pattern)

请注意,只需要找到第一次出现的模式.之后,不应该进行其他主要处理.

我能用什么比python的bultin找到更快的匹配1KB模式与1GB或更大的数据字符串？

(我已经知道如何拆分字符串并并行搜索它,因此您可以忽略该基本优化.)

更新:请将内存要求限制为16GB.

我在这里错过了什么吗？为什么不应该在"Broken"部分下的代码工作？我正在使用Python 2.6.

#!/usr/bin/env python

def func(a,b,c):
    print a,b,c

#Working: Example #1:

p={'c':3}

func(1,
     b=2,
     c=3,
     )

#Working: Example #2:

func(1,
     b=2,
     **p)

#Broken: Example #3:

func(1,
     b=2,
     **p,
     )

我在哈希表中存储了数百万,可能是数十亿的4字节值,我不想存储任何密钥.我希望只需要存储键和值的哈希值.这必须很快并且都保存在RAM中.与set()不同,仍然可以使用键查找条目.

Python的这个实现是什么？这有名字吗？

是的,允许碰撞,可以忽略.

(我可以为碰撞做一个例外,可以存储密钥.或者,碰撞只能覆盖以前存储的值.)

我想将数据字符串写入NumPy数组.伪代码:

d = numpy.zeros(10, dtype = numpy.character)
d[1:6] = 'hello'

示例结果:

d=
  array(['', 'h', 'e', 'l', 'l', 'o', '', '', '', ''],
        dtype='|S1')

如何使用NumPy最自然有效地完成这项工作？

我不想要for循环,生成器或任何迭代.与伪代码一样,可以使用一个命令吗？

假设有一个1024位的数组全部为零:

示例:[0,0,0,0,0,0,0,...]

然后我用完全随机位置的那些覆盖20个零:

示例:[0,1,0,0,0,0,0,...]

假设我有一个完美的编码器,那么编码这20个随机放置位的位置所需的理论最小位数是多少？

我知道有通信理论方程会告诉我这个,但我想仔细检查我的计算.

更难的红利问题:向我展示一种算法的代码,该算法实现接近此最小限制的编码.

额外奖励:如果位翻转字节级别而不是位级别怎么办？例如整个字节翻转.结果相同？