L'enregistrement d'énormes bigram dictionnaire de fichier à l'aide de cornichon

un ami à moi qui a écrit ce petit programme.
le textFile est de 1,2 GO en taille (7 ans d'une valeur de journaux).
Il gère avec succès pour créer le dictionnaire, mais il ne peut pas écrire dans un fichier en utilisant cornichon(programme se bloque).

import sys
import string
import cPickle as pickle

biGramDict = {}

textFile = open(str(sys.argv[1]), 'r')
biGramDictFile = open(str(sys.argv[2]), 'w')


for line in textFile:
   if (line.find('<s>')!=-1):
      old = None
      for line2 in textFile:
         if (line2.find('</s>')!=-1):
            break
         else:
            line2=line2.strip()
            if line2 not in string.punctuation:
               if old != None:
                  if old not in biGramDict:
                     biGramDict[old] = {}
                  if line2 not in biGramDict[old]:
                     biGramDict[old][line2] = 0
                  biGramDict[old][line2]+=1
               old=line2

textFile.close()

print "going to pickle..."    
pickle.dump(biGramDict, biGramDictFile,2)

print "pickle done. now load it..."

biGramDictFile.close()
biGramDictFile = open(str(sys.argv[2]), 'r')

newBiGramDict = pickle.load(biGramDictFile)

merci d'avance.

MODIFIER

pour toute personne intéressée, je vais vous expliquer brièvement ce que ce programme n'.
en supposant que vous avez un fichier formaté à peu près comme ceci:

<s>
Hello
,
World
!
</s>
<s>
Hello
,
munde
!
</s>
<s>
World
domination
.
</s>
<s>
Total
World
domination
!
</s>
  • <s> sont des phrases séparateurs.
  • un mot par ligne.

un biGramDictionary est généré pour une utilisation ultérieure.

quelque chose comme ceci:

{
 "Hello": {"World": 1, "munde": 1}, 
 "World": {"domination": 2},
 "Total": {"World": 1},
}

espère que cette aide. actuellement, la stratégie a changé à l'aide de mysql parce que sqlite ne fonctionnait pas (probablement à cause de la taille)

si vous allez jouer avec les GROS fichiers, pourquoi ne pas utiliser une base de données? aussi, je vois que vous faites pour une boucle sur le même fichier 2 fois, ce qui peut être superflu et ajoute au coût de traitement. pourquoi ne pas décrire ce que vous faites avec des exemples de fichiers d'entrée ?
ghostdog74, à vous de voir 2 pour les déclarations, mais il y a une seule boucle sur le fichier 🙂 de parcourir un fichier est juste la lecture des lignes (à partir de la position réelle), il ne cherche pas à le début du fichier.
Tout simplement essayer de sqlitedict (votre Python dict soutenu par la DB sur le disque, pas de RAM).

OriginalL'auteur João Portela | 2010-01-21

  1. 10

    Cornichon est uniquement destiné à l'écriture complète (petits) objets. Votre dictionnaire est un peu grand à même de tenir en mémoire, vous feriez mieux d'utiliser une base de données au lieu de sorte que vous pouvez stocker et de récupérer les entrées une par une au lieu de tout à la fois.

    Bien et facilement intégrable singe-fichier formats de base de données que vous pouvez utiliser à partir de Python sont SQLite ou l'un des DBM variantes. Le dernier agit comme un dictionnaire (c'est à dire que vous pouvez lire et écrire des clé/valeur-paires), mais qui utilise le disque en tant que disque de stockage plutôt que de 1.2 go de mémoire.

    Sqlite est entièrement de base de données relationnelle, tandis que Berkeley DB n'est pas, juste de clé/valeur. Si c'est juste le stockage, je pense que Berkeley est une meilleure option, alors si vous voulez faire quelques requêtes et stocker les informations dans plus de manière organisée, sqlite, c'est plus approprié.
    BerkeleyDB est plutôt capricieux et difficile à gérer, surtout avec les grandes quantités de données. Même pour une seule chaîne->chaine de magasin (qui est ce que BerkeleyDB) je voudrais utiliser SQLite, qui prendra soin de tous les BerkeleyDB de gestion.
    SQLite ne pas agir comme un dictionnaire.
    Le Python de la page pour la bsddb moddule (python.org/doc/2.6/library/bsddb.html) dit qu'il est obsolète. Est-il une autre non-déconseillé Python option pour un BSD DB?
    python.org/doc/2.6/library/persistence.html énumère un certain nombre de persistance des données des modules. Le gdbm module est très similaire et toujours pris en charge, j'irais pour que l'on.

    OriginalL'auteur Wim

  2. 1

    Avez-vous vraiment besoin de l'ensemble des données dans la mémoire? Vous pourriez diviser naïve des moyens comme l'un fichier pour chaque année o chaque mois si vous voulez le dictionnaire/cornichon approche.

    Aussi, n'oubliez pas que les dictionnaires ne sont pas triés, vous pouvez avoir des problèmes pour avoir de sorte que la quantité de données. Dans le cas où vous souhaitez rechercher ou trier les données, bien sûr...

    De toute façon, je pense que l'approche de base de données commenté, est le plus souple, spécialement sur le long terme...

    OriginalL'auteur Khelben

  3. 1

    Une solution consiste à utiliser buzhug au lieu de cornichon. C'est un pur Python solution, et conserve très Pythonic de la syntaxe. Je pense que la prochaine étape de mettre en veilleuse et de leurs semblables. Il prendra en charge la taille des données que vous êtes en train de parler. Sa limite de taille de 2 GO par domaine (chaque champ est stocké dans un fichier séparé).

    OriginalL'auteur Ryan Ginstrom

  4. 0

    Si votre vraiment, vraiment souhaitez utiliser un dictionnaire comme sémantique, essayez de SQLAlchemy de associationproxy. La suite (plutôt long) bout de code traduit votre dictionnaire dans Clé,la Valeur des Paires dans le entries-Table. Je ne sais pas comment SQLAlchemy s'adapte à votre grand dictionnaire, mais SQLite devrait être en mesure de la traiter gentiment.

    from sqlalchemy import create_engine, MetaData
from sqlalchemy import Table, Column, Integer, ForeignKey, Unicode, UnicodeText
from sqlalchemy.orm import mapper, sessionmaker, scoped_session, Query, relation
from sqlalchemy.orm.collections import column_mapped_collection
from sqlalchemy.ext.associationproxy import association_proxy
from sqlalchemy.schema import UniqueConstraint
engine = create_engine('sqlite:///newspapers.db')
metadata = MetaData()
metadata.bind = engine
Session = scoped_session(sessionmaker(engine))
session = Session()
newspapers = Table('newspapers', metadata,
Column('newspaper_id', Integer, primary_key=True),
Column('newspaper_name', Unicode(128)),
)
entries = Table('entries', metadata,
Column('entry_id', Integer, primary_key=True),
Column('newspaper_id', Integer, ForeignKey('newspapers.newspaper_id')),
Column('entry_key', Unicode(255)),
Column('entry_value', UnicodeText),
UniqueConstraint('entry_key', 'entry_value', name="pair"),
)
class Base(object):
def __init__(self, **kw):
for key, value in kw.items():
setattr(self, key, value)
query = Session.query_property(Query)
def create_entry(key, value):
return Entry(entry_key=key, entry_value=value)
class Newspaper(Base):
entries = association_proxy('entry_dict', 'entry_value',
creator=create_entry)
class Entry(Base):
pass
mapper(Newspaper, newspapers, properties={
'entry_dict': relation(Entry,
collection_class=column_mapped_collection(entries.c.entry_key)),
})
mapper(Entry, entries)
metadata.create_all()
dictionary = {
u'foo': u'bar',
u'baz': u'quux'
}
roll = Newspaper(newspaper_name=u"The Toilet Roll")
session.add(roll)
session.flush()
roll.entries = dictionary
session.flush()
for entry in Entry.query.all():
print entry.entry_key, entry.entry_value
session.commit()
session.expire_all()
print Newspaper.query.filter_by(newspaper_id=1).one().entries

    donne

    foo bar
baz quux
{u'foo': u'bar', u'baz': u'quux'}

    OriginalL'auteur pi.