def test_predict(): client = CitrinationClient(environ['CITRINATION_API_KEY'], environ['CITRINATION_SITE']) inputs = [ { "CHEMICAL_FORMULA": "AlCu" }, ] resp = client.predict("betterdensitydemo", inputs) prediction = resp['candidates'][0]['Density'] assert abs(prediction[0] - 5.786) < 0.1
def main(): # Set up client client = CitrinationClient(os.environ["CITRINATION_API_KEY"], 'https://citrination.com') # Read in experimental data filename = "C:/Users/mvane/Documents/Skunkworks/BMG/Data/BMG_full_dataset_with_energies.csv" exp_data = pd.read_csv(filename) formula = exp_data['formula'].as_matrix() energy = exp_data['PROPERTY: Nearest DFT Formation Energy (eV)'].as_matrix( ) form = "formula" property = "Property Nearest DFT Formation Energy" # Convert formulas & energies to dictionary. Make a list of dictionaries. input = [] for i in range(0, len(formula)): input.append({form: formula[i], property: energy[i]}) # Make predictions of Tg, Tx, and Tl. (These will also contain many of the Magpie descriptors used to train the model) model_num = "4416" predictions = client.predict(model_num, input) # Write all these predictions to json files with date and time to differentiate predictions. # Folder path: folder_out = "C:/Users/mvane/Documents/GitHub/better-glasses/predictions_output.csv" first = True # Make CSV writer. with open(folder_out, 'w', newline='') as csvfile: writer = csv.writer(csvfile) # Go through every prediction that we made from the chemical formula for p in predictions: keys = p.all_keys() # Make a header row with all of the keys listed if first: row = [] row.append('Formula') for k in keys: row.append(k) row.append(str(k) + ' Uncertainty') writer.writerow(row) first = False row = [] # Write the formula in the first column of the CSV. Formula will also show up in a later column. row.append(p.get_value('formula').value) # Write the value and uncertainty of each key to the CSV for k in keys: val = p.get_value(k).value loss = p.get_value(k).loss row.append(str(val)) row.append(str(loss)) writer.writerow(row) csvfile.close()
def predict_from_pifs(view_id, pifs, predict, condition={}, exclude=[], client=None): ''' predict properties using inputs from pifs. returns dataframe with actual and predicted values ------------------ view_id: dataview id containing model pifs: list of pifs to predict predict: list of properties to predict condition: dict of conditions and values exclude: properties in pif to exclude from inputs (besides properties to predict) client: CitrinationClient instance ''' if client is None: client = CitrinationClient(os.environ['CITRINATION_API_KEY'], 'https://citrination.com') ids = [] inputs = [] predict = predict actuals = [] for pif in pifs: pids = {p.name: p.value for p in pif.ids} ids.append(pids) props = {p.name: p.scalars for p in pif.properties} props['formula'] = pif.chemical_formula inp = { 'Property {}'.format(k): v for (k, v) in props.items() if k not in predict + exclude } inp.update(condition) inputs.append(inp) actuals.append({k: v for (k, v) in props.items() if k in predict}) modelout = client.predict(view_id, inputs) predictions = [] for r in modelout: pred = { 'pred_{}'.format(p): r.get_value('Property {}'.format(p)).value for p in predict } predictions.append(pred) dicts = [] for i, a, p in zip(ids, actuals, predictions): td = {**i, **a, **p} dicts.append(td) result = pd.DataFrame(dicts) return result
class CitrinationSaxsClassifer(object): """A set of classifiers to be used on SAXS spectra""" def __init__(self, address, api_key_file): with open(api_key_file, "r") as g: api_key = g.readline() a_key = api_key.strip() self.client = CitrinationClient(site = address, api_key=a_key) def citrination_classify(self,sample_params): """ Parameters ---------- sample_params : ordered dictionary ordered dictionary of floats representing features of test sample Returns ------- flags : dict dictionary of (boolean,float) tuples, where the first item is the flag and the second is the probability, for each of the potential scattering populations """ inputs = self.append_str_property(sample_params) flags = OrderedDict() resp = self.client.predict("24", inputs) # "24" is ID of dataview on Citrination flags['unidentified'] = resp['candidates'][0]['Property unidentified'] flags['guinier_porod'] = resp['candidates'][0]['Property guinier_porod'] flags['spherical_normal'] = resp['candidates'][0]['Property spherical_normal'] flags['diffraction_peaks'] = resp['candidates'][0]['Property diffraction_peaks'] return flags # helper function def append_str_property(self, sample_params): inputs = {} for k,v in sample_params.items(): k = "Property " + k inputs[k] = v return inputs def citrination_predict(self, populations, sample_params, q_I): """Apply self.models and self.scalers to sample_params. Parameters ---------- sample_params : ordered dictionary ordered dictionary of floats representing features of test sample Returns ------- flags : dict dictionary of (boolean,float) tuples, where the first item is the flag and the second is the probability, for each of the potential scattering populations """ features = self.append_str_property(sample_params) params = OrderedDict.fromkeys(saxs_math.all_parameter_keys) if populations['unidentified'][0] == '1': # TODO: we could still use a fit to 'predict' I0_floor... return params # all params are "None" if populations['spherical_normal'][0] == '1' and populations['diffraction_peaks'][0] == '0': resp = self.client.predict("27", features) # "27" is ID of dataview on Citrination params['r0_sphere'] = resp['candidates'][0]['Property r0_sphere'] additional_features = saxs_math.spherical_normal_profile(q_I) additional_features = self.append_str_property(additional_features) ss_features = dict(features) ss_features.update(additional_features) resp = self.client.predict("28", ss_features) params['sigma_sphere'] = resp['candidates'][0]['Property sigma_sphere'] if populations['guinier_porod'][0] == '1': additional_features = saxs_math.guinier_porod_profile(q_I) additional_features = self.append_str_property(additional_features) rg_features = dict(features) rg_features.update(additional_features) resp =self.client.predict("29", rg_features) params['rg_gp'] = resp['candidates'][0]['Property rg_gp'] return params
def test_predict(): client = CitrinationClient(environ['CITRINATION_API_KEY'], environ['CITRINATION_SITE']) inputs = [{"CHEMICAL_FORMULA": "AlCu"}, ] resp = client.predict("betterdensitydemo", inputs) prediction = resp['candidates'][0]['Density'] assert abs(prediction[0] - 5.786) < 0.1