Les Pandas DataFrame.fusion MemoryError

Objectif

Mon but est de fusionner deux DataFrames par leur commune colonne (noms de gènes) donc je peux prendre un produit de chaque gène score sur chaque gène ligne. Je puis à effectuer une groupby sur les patients et de cellules et la somme de tous les scores de chacun. L'ultime bloc de données devrait ressembler à ceci:

    patient  cell 
    Pat_1    22RV1    12
             DU145    15
             LN18      9
    Pat_2    22RV1    12
             DU145    15
             LN18      9
    Pat_3    22RV1    12
             DU145    15
             LN18      9

Cette dernière partie devrait fonctionner correctement, mais je n'ai pas été en mesure d'effectuer la première fusion sur les noms des gènes en raison d'un MemoryError. Ci-dessous sont extraits de chaque DataFrame.

Données

cell_s =

    Description          Name                      level_2  0
0  LOC100009676  100009676_at  LN18_CENTRAL_NERVOUS_SYSTEM  1
1  LOC100009676  100009676_at               22RV1_PROSTATE  2
2  LOC100009676  100009676_at               DU145_PROSTATE  3
3          AKT3      10000_at  LN18_CENTRAL_NERVOUS_SYSTEM  4
4          AKT3      10000_at               22RV1_PROSTATE  5
5          AKT3      10000_at               DU145_PROSTATE  6
6          MED6      10001_at  LN18_CENTRAL_NERVOUS_SYSTEM  7
7          MED6      10001_at               22RV1_PROSTATE  8
8          MED6      10001_at               DU145_PROSTATE  9

cell_s est d'environ 10 000 000 de lignes

patient_s =

             id level_1  0
0          MED6   Pat_1  1
1          MED6   Pat_2  1
2          MED6   Pat_3  1
3  LOC100009676   Pat_1  2
4  LOC100009676   Pat_2  2
5  LOC100009676   Pat_3  2
6          ABCD   Pat_1  3
7          ABCD   Pat_2  3
8          ABCD   Pat_3  3
    ....

patient_s est d'environ de 1 200 000 lignes

Code

def get_score(cell, patient):
    cell_s = cell.set_index(['Description', 'Name']).stack().reset_index()
    cell_s.columns = ['Description', 'Name', 'cell', 's1']

    patient_s = patient.set_index('id').stack().reset_index()
    patient_s.columns = ['id', 'patient', 's2']

    # fails here:
    merged = cell_s.merge(patient_s, left_on='Description', right_on='id')
    merged['score'] = merged.s1 * merged.s2

    scores = merged.groupby(['patient','cell'])['score'].sum()
    return scores

J'ai été faire un MemoryError lors de la première read_csving de ces fichiers, mais en spécifiant l'dtypes résolu le problème. Confirmant que mon python est en 64 bits n'a pas résolu mon problème. Je n'ai pas atteint les limites sur les pandas, je n'ai?

Python 3.4.3 |Anaconda 2.3.0 (64-bit)| Pandas 0.16.2

Vous pourriez économiser un peu de mémoire par la conversion de chaînes en categoricals si vous ne l'avez pas déjà. Je ne crois pas 64 bits pandas aura toutes les limitations de la mémoire autres que ce qui est dans votre ordinateur.
Lors de l'importation avec "read_csv', j'ai mis le 'dtype=" catégorie " pour toutes les colonnes contenant des chaînes de caractères, je reçois TypeError: data type "category" not understood. J'imagine, parce que Catégorique n'est pas un tableau numpy. Pouvez-vous penser à un travail autour? Puis-je tout simplement ignorer le MemoryError?
Je pense que vous devez le convertir après la lecture. Je usu faire quelque chose comme df['x'] = df['x'].astype('category')

OriginalL'auteur Thomas Matthew | 2015-08-01

5

Envisager deux solutions:

CSV Par MORCEAUX

Apparemment, read_csv peuvent souffrir de problèmes de performances et donc de gros fichiers doit charger dans itéré morceaux.
```
cellsfilepath = 'C:\\Path\To\Cells\CSVFile.csv'
tp = pd.io.parsers.read_csv(cellsfilepath, sep=',', iterator=True, chunksize=1000)
cell_s = pd.concat(tp, ignore_index=True)

patientsfilepath = 'C:\\Path\To\Patients\CSVFile.csv'
tp = pd.io.parsers.read_csv(patientsfilepath, sep=',', iterator=True, chunksize=1000)
patient_s = pd.concat(tp, ignore_index=True)
```
CSV VIA SQL

Comme une base de données gars, je recommande toujours de la manipulation de grands chargements de données et de fusion/rejoindre un moteur relationnel SQL qui va bien pour ce type de processus. J'ai beaucoup écrit un commentaire sur dataframe de fusion Q/Comme à cet effet -même, dans l'arrêt R. Vous pouvez utiliser n'importe quelle base de données SQL, y compris le serveur de fichier dbs (Accès, SQLite) ou de serveur de client de dbs (MySQL, MSSQL, ou autres), même lorsque votre dfs dériver. Python gère une bibliothèque intégrée pour SQLite (sinon vous utilisez ODBC); et dataframes peut être poussé dans les bases de données sous forme de tables à l'aide de les pandas to_sql:
```
import sqlite3

dbfile = 'C:\\Path\To\SQlitedb.sqlite'
cxn = sqlite3.connect(dbfile)
c = cxn.cursor()

cells_s.to_sql(name='cell_s', con = cxn, if_exists='replace')
patient_s.to_sql(name='patient_s', con = cxn, if_exists='replace')

strSQL = 'SELECT * FROM cell_s c INNER JOIN patient_s p ON c.Description = p.id;'
# MIGHT HAVE TO ADJUST ABOVE FOR CELL AND PATIENT PARAMS IN DEFINED FUNCTION

merged = pd.read_sql(strSQL, cxn)
```
Merci pour les deux solutions. J'ai commencé à courir read_csv en morceaux, et il semble réduire l'utilisation de la mémoire (bien que je n'ai pas mesuré exactement). Le SQL solution ressemble à "la voie", mais lorsque j'exécute le code ci-dessus, il jette un attribut erreur de 'sqlite3.Cursor' object has no attribute 'cursor' à cells_s.to_sql. Je trouve la question de la ligne de 1467 de pandas/io/sql.py , en exécution cur = self.con.cursor(). Vérifié la documentation et de la SORTE, et n'a pas pu déterminer la cause de l'erreur. Des idées?
EDIT: j'ai éliminé le c = conn.cursor() à la suite d'un exemple de Sebastian Raschka. Semble fonctionner pour mon fusion, mais je wouldn pas être en mesure de requête ma nouvelle base de données, les corriger?
La première question est à cause de moi, en utilisant le curseur de l'objet dans con argument de to_sql() et non pas l'objet de connexion. J'ai fait la modifier avec une nouvelle variable, cxn. Oui, vous devriez être en mesure d'interroger db à l'aide de curseur execute() fetchall() qui affiche sous forme de liste. Mais ne remarque ci-dessus, les résultats de la requête sont passés dans une pandas df à l'aide de read_sql().
Il ne devrait pas être nécessaire de faire une solution de contournement. Les Pandas devraient être en mesure de gérer cela. Personne n'a signalé que la question de pandas?

OriginalL'auteur Parfait
1

Vous pouvez avoir à le faire dans les morceaux, et se pencher sur le brasier. http://blaze.pydata.org

OriginalL'auteur Skorpeo

Vous devez vous connecter pour publier un commentaire.