def predict_densenet(model_name, csv_pred):
"""
A function to allow for quickly generating prediction using densenet
after a model has been trained.
Parameters
----------
model_name : str
The name of your trained model.
csv_pred : str
The name of a .csv file located in "data/user_properties". This is
the data you are predicting. This file needs to have two columns:
"formula" and "target".
Returns
-------
input_values : list
List containing original 'target' values.
predicted_values : list
List containing predicted values.
"""
mat_props_root = r'data/user_properties/'
csv_pred = f'{mat_props_root}{csv_pred}'
batch_size = 2**10
data_loaders = EDM_CsvLoader(csv_data=csv_pred, batch_size=batch_size)
loaders = data_loaders.get_data_loaders(inference=True)
data_loader = loaders
pretrained_models = cons.mps
if model_name in pretrained_models:
info = f'{model_name}'
weights_pth = ('data/user_properties/trained_weights/'
f'DenseNet-{model_name}.pth')
else:
info = f'CUSTOM_{model_name}'
weights_pth = ('data/user_properties/trained_weights/'
f'DenseNet-CUSTOM_{model_name}.pth')
model = load_densenet(info, batch_size)
compute_device = get_compute_device()
checkpoint = torch.load(weights_pth, map_location=compute_device)
model.load_checkpoint(checkpoint, model_name)
input_values, predicted_values = model.predict(data_loader)
return (input_values, predicted_values)
import os
import numpy as np
import pandas as pd
import torch
from sklearn.metrics import roc_auc_score
from crabnet.kingcrab import CrabNet
from crabnet.model import Model
from utils.get_compute_device import get_compute_device
compute_device = get_compute_device(prefer_last=False)
RNG_SEED = 42
torch.manual_seed(RNG_SEED)
np.random.seed(RNG_SEED)
# %%
def get_model(mat_prop,
i,
classification=False,
batch_size=None,
transfer=None,
verbose=True):
# Get the TorchedCrabNet architecture loaded
model = Model(CrabNet(compute_device=compute_device).to(compute_device),
model_name=f'{mat_prop}{i}',
verbose=verbose)
# Train network starting at pretrained weights
if transfer is not None:
from torch import nn
from sklearn.model_selection import KFold
from sklearn.metrics import roc_auc_score
from crabnet.kingcrab import CrabNet
from crabnet.model import Model
from utils.get_compute_device import get_compute_device
import matplotlib.pyplot as plt
import matplotlib.patches as patches
import matplotlib.cm as cm
from matplotlib.ticker import AutoMinorLocator
from matplotlib.colors import Normalize
compute_device = get_compute_device()
data_type = torch.float
# %%
all_symbols = [
'None', 'H', 'He', 'Li', 'Be', 'B', 'C', 'N', 'O', 'F', 'Ne', 'Na', 'Mg',
'Al', 'Si', 'P', 'S', 'Cl', 'Ar', 'K', 'Ca', 'Sc', 'Ti', 'V', 'Cr', 'Mn',
'Fe', 'Co', 'Ni', 'Cu', 'Zn', 'Ga', 'Ge', 'As', 'Se', 'Br', 'Kr', 'Rb',
'Sr', 'Y', 'Zr', 'Nb', 'Mo', 'Tc', 'Ru', 'Rh', 'Pd', 'Ag', 'Cd', 'In',
'Sn', 'Sb', 'Te', 'I', 'Xe', 'Cs', 'Ba', 'La', 'Ce', 'Pr', 'Nd', 'Pm',
'Sm', 'Eu', 'Gd', 'Tb', 'Dy', 'Ho', 'Er', 'Tm', 'Yb', 'Lu', 'Hf', 'Ta',
'W', 'Re', 'Os', 'Ir', 'Pt', 'Au', 'Hg', 'Tl', 'Pb', 'Bi', 'Po', 'At',
'Rn', 'Fr', 'Ra', 'Ac', 'Th', 'Pa', 'U', 'Np', 'Pu', 'Am', 'Cm', 'Bk',
'Cf', 'Es', 'Fm', 'Md', 'No', 'Lr', 'Rf', 'Db', 'Sg', 'Bh', 'Hs', 'Mt',
'Ds', 'Rg', 'Cn', 'Nh', 'Fl', 'Mc', 'Lv', 'Ts', 'Og'
]
import os
import numpy as np
import pandas as pd
import torch
from sklearn.metrics import roc_auc_score
from crabnet.kingcrab import CrabNet
from crabnet.model import Model
from utils.get_compute_device import get_compute_device
compute_device = get_compute_device(prefer_last=True)
RNG_SEED = 42
torch.manual_seed(RNG_SEED)
np.random.seed(RNG_SEED)
# %%
def get_model(data_dir,
mat_prop,
classification=False,
batch_size=None,
transfer=None,
verbose=True):
# Get the TorchedCrabNet architecture loaded
model = Model(CrabNet(compute_device=compute_device).to(compute_device),
model_name=f'{mat_prop}',
verbose=verbose)
# Train network starting at pretrained weights
if transfer is not None:
def __init__(self,
model_type,
elem_prop,
mat_prop,
input_dims,
hidden_dims,
output_dims,
out_dir,
edm=False,
batch_size=1,
random_seed=None,
save_network_info=True):
super(NeuralNetWrapper, self).__init__()
self.model_type = model_type
self.elem_prop = elem_prop
self.mat_prop = mat_prop
self.input_dims = input_dims
self.hidden_dims = hidden_dims
self.output_dims = output_dims
self.out_dir = out_dir
self.edm = edm
self.batch_size = batch_size
self.random_seed = random_seed
self.data_type = torch.float
self.save_network_info = save_network_info
# Default to using the last GPU available
self.CUDA_count = torch.cuda.device_count()
self.compute_device = get_compute_device()
print(f'Creating Model of type {self.model_type}')
if self.model_type == 'CrabNet':
self.model = CrabNet(self.compute_device,
input_dims=self.input_dims,
d_model=201,
nhead=3,
num_layers=3,
dim_feedforward=64,
dropout=0.1,
edm=self.edm)
elif self.model_type == 'DenseNet':
self.model = DenseNet(self.compute_device,
input_dims=self.input_dims,
hidden_dims=self.hidden_dims,
output_dims=self.output_dims,
dropout=0.1,
edm=self.edm)
self.model.to(self.compute_device,
dtype=self.data_type,
non_blocking=True)
self.num_network_params = count_parameters(self.model)
print(f'number of network params: {self.num_network_params}')
# self.criterion = nn.MSELoss()
self.criterion = nn.L1Loss()
# self.optim_lr = 1e-3
# self.optimizer = optim.Adam(self.model.parameters(), lr=self.optim_lr)
self.optim_lr = 5e-4
# self.optimizer = optim.AdamW(self.model.parameters(), lr=1e-3)
self.optimizer = optim.AdamW(self.model.parameters(),
lr=self.optim_lr,
weight_decay=1e-6)
# Logging
self.start_time = datetime.now()
self.start_datetime = self.start_time.strftime('%Y-%m-%d-%H%M%S.%f')
self.log_filename = (f'{self.start_datetime}-{self.model_type}-'
f'{self.elem_prop}-{self.mat_prop}.log')
self.sub_dir = (f'{self.start_datetime}-{xstrh(self.random_seed)}'
f'{self.model_type}-'
f'{self.elem_prop}-{self.mat_prop}')
self.log_dir = os.path.join(self.out_dir, self.sub_dir)
if 'CUSTOM' in self.mat_prop:
os.makedirs(self.log_dir, exist_ok=True)
if self.save_network_info:
os.makedirs(self.log_dir, exist_ok=True)
self.log_file = os.path.join(self.out_dir, self.sub_dir,
self.log_filename)
print(56 * '*')
print(f'creating and writing to log file {self.log_file}')
print(56 * '*')
with open(self.log_file, 'a') as f:
try:
f.write('Start time: ')
f.write(f'{self.start_datetime}\n')
f.write(f'random seed: {self.random_seed}\n')
f.write('Model type: ')
f.write(f'{self.model_type}\n')
f.write('Material property: ')
f.write(f'{self.mat_prop}\n')
f.write('Element property: ')
f.write(f'{self.elem_prop}\n')
f.write(f'EDM input: {self.edm}\n')
f.write('Network architecture:\n')
f.write(f'{self.model}\n')
f.write(f'Number of params: ')
f.write(f'{self.num_network_params}\n')
f.write(f'CUDA count: {self.CUDA_count}\n')
f.write(f'Compute device: {self.compute_device}\n')
f.write('Criterion and Optimizer:\n')
f.write(f'{self.criterion}\n')
f.write(f'{self.optimizer}\n')
f.write(56 * '*' + '\n')
except:
pass
