Eine relativ speichersparende Sparse-Matrix-Python-Speicherlösung

Empfehlungssysteme müssen häufig Daten wie Benutzer-ID, Artikel-ID und Bewertung verarbeiten, bei denen es sich in der Mathematik eigentlich um spärliche Matrizen handelt, um dieses Problem zu lösen. scipy.sparse weist jedoch viele Probleme auf, die nicht für die Verwendung geeignet sind: 1 , kann das gleichzeitige schnelle Schneiden von Daten [i, ...], Daten [..., j], Daten [i, j] nicht unterstützen. Da die Daten im Speicher gespeichert sind, können große Datenmengen nicht gut unterstützt werden . bewältigen.

Um das schnelle Slicing von Daten[i, ...], Daten[..., j] zu unterstützen, müssen die Daten von i oder j gleichzeitig zentral gespeichert werden, um sie zu speichern Bei großen Datenmengen müssen die Daten auch teilweise auf der Festplatte abgelegt werden und der Speicher wird als Puffer verwendet. Die Lösung hier ist relativ einfach. Verwenden Sie ein Dict-ähnliches Ding, um Daten für ein bestimmtes i (z. B. 9527) zu speichern. In ähnlicher Weise werden die Daten für ein bestimmtes j (z. B. 3306) gespeichert. Alle seine Daten werden in dict['j3306'] gespeichert. Wenn Sie Daten [9527, ...] herausnehmen müssen, nehmen Sie einfach dict['i9527'] heraus, das ursprünglich ein Diktatobjekt ist , speichert den Wert, der einem bestimmten j entspricht. Um Speicherplatz zu sparen, speichern wir dieses Diktat in Form einer Binärzeichenfolge und geben den Code direkt ein:

'''
Sparse Matrix
'''
import struct
import numpy as np
import bsddb
from cStringIO import StringIO
  
class DictMatrix():
    def __init__(self, container = {}, dft = 0.0):
        self._data  = container
        self._dft   = dft
        self._nums  = 0
  
    def __setitem__(self, index, value):
        try:
            i, j = index
        except:
            raise IndexError('invalid index')
  
        ik = ('i%d' % i)
        # 为了节省内存，我们把j, value打包成字二进制字符串
        ib = struct.pack('if', j, value)
        jk = ('j%d' % j)
        jb = struct.pack('if', i, value)
  
        try:
            self._data[ik] += ib
        except:
            self._data[ik] = ib
        try:
            self._data[jk] += jb
        except:
            self._data[jk] = jb
        self._nums += 1
  
    def __getitem__(self, index):
        try:
            i, j = index
        except:
            raise IndexError('invalid index')
  
        if (isinstance(i, int)):
            ik = ('i%d' % i)
            if not self._data.has_key(ik): return self._dft
            ret = dict(np.fromstring(self._data[ik], dtype = 'i4,f4'))
            if (isinstance(j, int)): return ret.get(j, self._dft)
  
        if (isinstance(j, int)):
            jk = ('j%d' % j)
            if not self._data.has_key(jk): return self._dft
            ret = dict(np.fromstring(self._data[jk], dtype = 'i4,f4'))
  
        return ret
  
    def __len__(self):
        return self._nums
  
    def __iter__(self):
        pass
  
    '''
    从文件中生成matrix
    考虑到dbm读写的性能不如内存，我们做了一些缓存，每1000W次批量写入一次
    考虑到字符串拼接性能不太好，我们直接用StringIO来做拼接
    '''
    def from_file(self, fp, sep = 't'):
        cnt = 0
        cache = {}
        for l in fp:
            if 10000000 == cnt:
                self._flush(cache)
                cnt = 0
                cache = {}
            i, j, v = [float(i) for i in l.split(sep)]
  
            ik = ('i%d' % i)
            ib = struct.pack('if', j, v)
            jk = ('j%d' % j)
            jb = struct.pack('if', i, v)
  
            try:
                cache[ik].write(ib)
            except:
                cache[ik] = StringIO()
                cache[ik].write(ib)
  
            try:
                cache[jk].write(jb)
            except:
                cache[jk] = StringIO()
                cache[jk].write(jb)
  
            cnt += 1
            self._nums += 1
  
        self._flush(cache)
        return self._nums
  
    def _flush(self, cache):
        for k,v in cache.items():
            v.seek(0)
            s = v.read()
            try:
                self._data[k] += s
            except:
                self._data[k] = s
  
if __name__ == '__main__':
    db = bsddb.btopen(None, cachesize = 268435456)
    data = DictMatrix(db)
    data.from_file(open('/path/to/log.txt', 'r'), ',')

Testen Sie 4500-W-Bewertungsdaten (Ganzzahl, Ganzzahl, Gleitkommaformat), importieren Sie eine 922-MB-Textdatei, verwenden Sie Speicherdikt zum Speichern, der Aufbau ist in 12 Minuten abgeschlossen, verbrauchen Sie 1,2 GB Speicher und verwenden Sie den BDB-Speicher im Beispielcode, die Erstellung ist in 20 Minuten abgeschlossen. Er belegt etwa 300 bis 400 MB Speicher, nicht viel mehr als die Cachegröße > benötigt 1,4788 Sekunden und das Lesen eines Datenelements dauert etwa 1,5 ms.

import timeit
timeit.Timer('foo = __main__.data[9527, ...]', 'import __main__').timeit(number = 1000)

Ein weiterer Vorteil der Verwendung der Dict-Klasse zum Speichern von Daten besteht darin, dass Sie Memory Dict oder jede andere Form von DBM oder sogar das legendäre Tokyo Cabinet verwenden können...

Okay, machen Sie Schluss . .