Je réfléchis depuis longtemps. Je l'ai comme variable dans le programme, mais je veux en faire un CSV car il s'arrête. Je veux dire, compte tenu de la recherche croisée, je veux le mettre dans la base de données. Mais c'est pénible d'écrire des conversions mutuelles une par une ...
C'est ce à quoi j'ai pu penser en créant un tableau à partir d'informations de colonne au minimum et en y plongeant la valeur.
Commencez par récupérer le nom de la colonne dans le fichier CSV. Comme prévu, je ne souhaite pas déterminer automatiquement le type de chaque colonne, alors spécifiez-le. Eh bien, puisque le but est l'apprentissage automatique, la forme par défaut des colonnes est des fractions flottantes à double précision. Par conséquent, spécifiez les colonnes de type entier et de type texte. Ensuite, sur cette base, utilisez CREATE TABLE, INSERT INTO à partir du nom de colonne que vous venez d'obtenir. (Eh bien, vous pouvez utiliser Pandas pour INSERT, mais il est plus facile de faire diverses autres choses si vous faites ce flux.)
CalculateDescriptors.py
import os
import pandas as pd
# Renvoie le composé
# I: chemin SDF
# O: liste d'objets composés
def get_mols(sdfpath):
from rdkit import Chem
mols = [mol for mol in Chem.SDMolSupplier(sdfpath) if mol is not None]
return mols
# Renvoie des informations de base sur le composé [nom du composé, informations structurelles, nombre d'atomes, nombre de liaisons, SMILES, InChI]
# I: Liste d'objets composés
# O: données de résultat
def get_values_base(mols):
from rdkit import Chem
columns = ['Name', 'Structure', 'Atoms', 'Bonds', 'SMILES', 'InChI']
values = list()
for mol in mols:
tmp = list()
tmp.append(mol.GetProp('_Name'))
tmp.append(Chem.MolToMolBlock(mol))
tmp.append(mol.GetNumAtoms())
tmp.append(mol.GetNumBonds())
tmp.append(Chem.MolToSmiles(mol))
tmp.append(Chem.MolToInchi(mol))
values.append(tmp)
index = [i for i in range(len(mols))]
df = pd.DataFrame(values, columns=columns, index=index)
return df
# Renvoie les paramètres externes du composé
# I: Liste d'objets composés
# O: données de résultat
def get_values_external(mols):
from rdkit import Chem
columns = ['ID', 'NAME', 'SOL', 'SMILES', 'SOL_classification']
values = list()
for mol in mols:
tmp = list()
for column in columns:
tmp.append(mol.GetProp(column))
values.append(tmp)
columns = ['ext_' + column for column in columns]
index = [i for i in range(len(mols))]
df = pd.DataFrame(values, columns=columns, index=index)
return df
# Calculer le descripteur: RDKit
# I: Liste d'objets composés
# O: données de résultat
def get_rdkit_descriptors(mols):
from rdkit.Chem import AllChem, Descriptors
from rdkit.ML.Descriptors import MoleculeDescriptors
# Calcul du descripteur RDKit
# names = [mol.GetProp('_Name') for mol in mols]
descLists = [desc_name[0] for desc_name in Descriptors._descList]
calcs = MoleculeDescriptors.MolecularDescriptorCalculator(descLists)
values = [calcs.CalcDescriptors(mol) for mol in mols]
Convertir en #DataFrame
index = [i for i in range(len(mols))]
df = pd.DataFrame(values, columns=descLists, index=index)
return df
# Calculer le descripteur: mordred
# I: Liste d'objets composés
# O: données de résultat
def get_mordred_descriptors(mols):
Calcul du # descripteur mordred
from mordred import Calculator, descriptors
calcs = Calculator(descriptors, ignore_3D=False)
df = calcs.pandas(mols)
df['index'] = [i for i in range(len(mols))]
df.set_index('index', inplace=True)
return df
# Calculer le descripteur: CDK
# I: fichier SDF
# chemin du fichier d'exécution java
# Chemin du fichier jar CDK
# O: données de résultat
def get_cdk_descriptors(sdfpath, workfolderpath, java_path, cdk_jar_path):
filepath = os.path.join(workfolderpath, 'tmp.csv')
import subprocess
command = f'{java_path} -jar {cdk_jar_path} -b {sdfpath} -t all -o {filepath}'
print(command)
subprocess.run(command, shell=False)
df = pd.read_table(filepath)
os.remove(filepath)
return df
# Traitement principal
def main():
data_folderpath = 'D:\\data\\python_data\\chem'
sdfpath = os.path.join(data_folderpath, 'sdf\\solubility.test.20.sdf')
csvpath = 'solubility.test.csv'
java_path = 'C:\\Program Files\\Java\\jdk-14.0.1\\bin\\java.exe'
workfolderpath = os.path.dirname(os.path.abspath(__file__))
cdk_jar_path = os.path.join(data_folderpath, 'jar\\CDKDescUI-1.4.6.jar')
# Acquisition de composés
mols = get_mols(sdfpath)
# Obtenez chaque valeur
# (bibliothèque python)
dfs = list()
for calcs in [get_values_base, get_values_external, get_rdkit_descriptors, get_mordred_descriptors]:
dfs.append(calcs(mols))
# (calcul du fichier jar)
dfs.append(get_cdk_descriptors(sdfpath, workfolderpath, java_path, cdk_jar_path))
# Tout combiner
df = pd.concat(dfs, axis=1)
df.to_csv('all_parameters.csv')
print(df)
# Démarrez le processus
if __name__ == '__main__':
main()
Aussi un.
CreateSQL.py
import ReadCSVColumn
# Renvoie SQL: DROP
# I: nom de la table
O : SQL
def get_sql_drop_table(table_name):
sql = f'DROP TABLE IF EXISTS {table_name}'
return sql
# Renvoie SQL: SELECT
# I: nom de la table
# Liste des noms de colonnes
O : SQL
def get_sql_select(table_name, columns):
sql = f'''
SELECT
{','.join(columns)}
FROM
{table_name}
'''
return sql
# Renvoie SQL: INSERT
# I: nom de la table
# Liste des noms de colonnes
O : SQL
def get_sql_insert_table(table_name, columns):
sql = f'''
INSERT INTO
{table_name}
(
{','.join(columns)}
)
VALUES
(
{','.join(['%s' for column in columns])}
)
'''
return sql
# Renvoie SQL: CREATE TABLE
# I: nom de la table
# Liste des noms de colonnes
# Liste des noms de colonnes (republication: type entier)
# Liste des noms de colonnes (republication: type de texte)
O : SQL
def get_sql_create_table(table_name, columns, columns_int, columns_text):
sql_columns = list()
for column in columns:
if column in columns_int:
sql_columns.append(column + ' ' + 'integer')
elif column in columns_text:
sql_columns.append(column + ' ' + 'text')
else:
sql_columns.append(column + ' ' + 'double precision')
sql = f'''
CREATE TABLE {table_name}
(
{','.join(sql_columns)}
)
'''
return sql
# Traitement principal
def main():
csvpath = 'solubility.test.csv'
columns = ReadCSVColumn.get_columns_list(csvpath)
columns_int = ['SampleID', 'Atoms', 'Bonds']
columns_text = ['SampleName', 'Structure', 'ID', 'NAME', 'SOL', 'SMILES', 'SOL_classification']
sql = get_sql_create_table('RDKit', columns, columns_int, columns_text)
print(sql)
# Démarrez le processus
if __name__ == '__main__':
main()
Oh, il y en avait un aussi.
ReadCSVColumn.py
# Lire le fichier texte au format de liste de lignes
# I: chemin du fichier
# O: liste de textes
def get_lines_from_textfile(filepath):
with open(filepath, 'r', encoding='utf-8') as f:
lines = f.readlines()
return lines
# Renvoie la première ligne de la liste des chemins CSV sous forme de liste d'éléments lus
# I: chemin CSV
# O: liste d'articles
def get_columns_list(csvpath):
# Il y a eu un saut de ligne dans le dernier élément, alors supprimez-le
line_1st = get_lines_from_textfile(csvpath)[0]
# Il y a un saut de ligne à la fin de la première ligne, alors supprimez-le
line_1st = line_1st.replace('\n', '')
return line_1st.split(',')
# Traitement principal
def main():
csvpath = 'solubility.test.csv'
columns = get_columns_list(csvpath)
for column in columns:
print(column)
# Démarrez le processus
if __name__ == '__main__':
main()
Si vous déplacez tout cela, vous devez créer une table du même type que le premier CSV sur PostgreSQL et l'INSÉRER. Après cela, vous pouvez REJOINDRE avec le maître sur le DB et GROUP BY librement.
Eh bien ... je pense que c'est mieux si Python fonctionne sur PostgreSQL ... Eh bien, c'est un problème futur.
J'ai l'impression d'avoir enfin créé un cadre décent. Eh bien, la prochaine fois, je ferai quelque chose d'un peu plus près du sujet principal.
Recommended Posts