Ich habe lange nachgedacht. Ich habe es als Variable im Programm, aber ich möchte es CSV machen, weil es heruntergefahren wird. Ich meine, in Anbetracht der Kreuzsuche möchte ich es in die Datenbank aufnehmen. Aber es ist ein Schmerz, nacheinander gegenseitige Konvertierungen zu schreiben ...
Dies ist, woran ich denken konnte, indem ich mindestens eine Tabelle aus Spalteninformationen erstellte und den Wert in diese eintauchte.
Nehmen Sie zuerst den Spaltennamen aus der CSV-Datei. Wie erwartet möchte ich den Typ jeder Spalte nicht automatisch bestimmen, also geben Sie ihn an. Nun, da der Zweck maschinelles Lernen ist, ist die Standardform von Spalten schwebende Brüche mit doppelter Genauigkeit. Geben Sie daher Spalten mit Ganzzahl- und Texttyp an. Verwenden Sie dann basierend darauf CREATE TABLE, INSERT INTO aus dem Spaltennamen, den Sie gerade erhalten haben. (Nun, Sie können Pandas für INSERT verwenden, aber es ist einfacher, verschiedene andere Dinge zu tun, wenn Sie diesen Fluss machen.)
CalculateDescriptors.py
import os
import pandas as pd
# Gibt die Verbindung zurück
# I: SDF-Pfad
# O: Zusammengesetzte Objektliste
def get_mols(sdfpath):
from rdkit import Chem
mols = [mol for mol in Chem.SDMolSupplier(sdfpath) if mol is not None]
return mols
# Gibt grundlegende Informationen über die Verbindung zurück [Name der Verbindung, Strukturinformationen, Anzahl der Atome, Anzahl der Bindungen, SMILES, InChI]
# I: Zusammengesetzte Objektliste
# O: Ergebnisdaten
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
# Gibt die externen Parameter der Verbindung zurück
# I: Zusammengesetzte Objektliste
# O: Ergebnisdaten
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
# Deskriptor berechnen: RDKit
# I: Zusammengesetzte Objektliste
# O: Ergebnisdaten
def get_rdkit_descriptors(mols):
from rdkit.Chem import AllChem, Descriptors
from rdkit.ML.Descriptors import MoleculeDescriptors
# Berechnung des RDKit-Deskriptors
# 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]
In #DataFrame konvertieren
index = [i for i in range(len(mols))]
df = pd.DataFrame(values, columns=descLists, index=index)
return df
# Deskriptor berechnen: mordred
# I: Zusammengesetzte Objektliste
# O: Ergebnisdaten
def get_mordred_descriptors(mols):
Berechnung des # mordred Deskriptors
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
# Deskriptor berechnen: CDK
# I: SDF-Datei
# Pfad der Java-Ausführungsdatei
# CDK-JAR-Dateipfad
# O: Ergebnisdaten
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
# Hauptverarbeitung
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')
# Zusammengesetzte Akquisition
mols = get_mols(sdfpath)
# Holen Sie sich jeden Wert
# (Python-Bibliothek)
dfs = list()
for calcs in [get_values_base, get_values_external, get_rdkit_descriptors, get_mordred_descriptors]:
dfs.append(calcs(mols))
# (Berechnung der JAR-Datei)
dfs.append(get_cdk_descriptors(sdfpath, workfolderpath, java_path, cdk_jar_path))
# Kombiniere alle
df = pd.concat(dfs, axis=1)
df.to_csv('all_parameters.csv')
print(df)
# Prozess starten
if __name__ == '__main__':
main()
Auch eine.
CreateSQL.py
import ReadCSVColumn
# Gibt SQL: DROP zurück
# I: Tabellenname
O : SQL
def get_sql_drop_table(table_name):
sql = f'DROP TABLE IF EXISTS {table_name}'
return sql
# Gibt SQL zurück: SELECT
# I: Tabellenname
# Liste der Spaltennamen
O : SQL
def get_sql_select(table_name, columns):
sql = f'''
SELECT
{','.join(columns)}
FROM
{table_name}
'''
return sql
# Gibt SQL: INSERT zurück
# I: Tabellenname
# Liste der Spaltennamen
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
# Gibt SQL zurück: CREATE TABLE
# I: Tabellenname
# Liste der Spaltennamen
# Liste der Spaltennamen (Repost: Integer-Typ)
# Liste der Spaltennamen (Repost: Texttyp)
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
# Hauptverarbeitung
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)
# Prozess starten
if __name__ == '__main__':
main()
Oh, da war auch einer.
ReadCSVColumn.py
# Lesen Sie die Textdatei im Zeilenlistenformat
# I: Dateipfad
# O: Textliste
def get_lines_from_textfile(filepath):
with open(filepath, 'r', encoding='utf-8') as f:
lines = f.readlines()
return lines
# Gibt die erste Zeile aus der CSV-Pfadliste als Liste der gelesenen Elemente zurück
# I: CSV-Pfad
# O: Artikelliste
def get_columns_list(csvpath):
# Das letzte Element enthielt einen Zeilenumbruch. Entfernen Sie ihn daher
line_1st = get_lines_from_textfile(csvpath)[0]
# Am Ende der ersten Zeile befindet sich ein Zeilenumbruch. Entfernen Sie ihn daher
line_1st = line_1st.replace('\n', '')
return line_1st.split(',')
# Hauptverarbeitung
def main():
csvpath = 'solubility.test.csv'
columns = get_columns_list(csvpath)
for column in columns:
print(column)
# Prozess starten
if __name__ == '__main__':
main()
Wenn Sie all dies verschieben, sollten Sie eine Tabelle des gleichen Typs wie die erste CSV unter PostgreSQL erstellen und einfügen. Danach können Sie sich mit dem Master auf der DB verbinden und GROUP BY frei.
Nun ... ich denke, es ist am besten, wenn Python unter PostgreSQL läuft ... Nun, es ist ein zukünftiges Problem.
Ich habe das Gefühl, endlich einen anständigen Rahmen geschaffen zu haben. Nun, das nächste Mal werde ich etwas näher am Hauptthema tun.