def load_double_perovskites_gap(return_lumo=False, data_home=None, download_if_missing=True): """ Convenience function for loading the double_perovskites_gap dataset. Args: return_lumo (bool) Whether or not to provide LUMO energy dataframe in addition to gap dataframe. Defaults to False. data_home (str, None): Where to look for and store the loaded dataset download_if_missing (bool): Whether or not to download the dataset if it isn't on disk Returns: (pd.DataFrame, tuple) """ df = load_dataset("double_perovskites_gap") if return_lumo: lumo = load_dataset("double_perovskites_gap_lumo", data_home, download_if_missing) return df, lumo return df
def featurize(task, n_jobs=1): import warnings warnings.filterwarnings("ignore", category=RuntimeWarning) from modnet.preprocessing import MODData from modnet.featurizers.presets import DeBreuck2020Featurizer from matminer.datasets import load_dataset if task == "matbench_elastic": df_g = load_dataset("matbench_log_gvrh") df_k = load_dataset("matbench_log_kvrh") df = df_g.join(df_k.drop("structure", axis=1)) else: df = load_dataset(task) mapping = { col: col.replace(" ", "_").replace("(", "").replace(")", "") for ind, col in enumerate(df.columns) } df.rename(columns=mapping, inplace=True) targets = [ col for col in df.columns if col not in ("id", "structure", "composition") ] if "structure" not in df.columns: featurizer = CompositionOnlyFeaturizer() else: featurizer = DeBreuck2020Featurizer(fast_oxid=True) try: materials = df["structure"] if "structure" in df.columns else df[ "composition"].map(Composition) except KeyError: raise RuntimeError( f"Could not find any materials data dataset for task {task!r}!") data = MODData( materials=materials.tolist(), targets=df[targets].values, target_names=targets, featurizer=featurizer, ) data.featurize(n_jobs=n_jobs) os.makedirs("./precomputed", exist_ok=True) data.save(f"./precomputed/{task}_moddata.pkl.gz") return data
def simple_violin(): df = load_dataset("elastic_tensor_2015") pf = PlotlyFig(df, title="Distribution of Elastic Constant Averages", colorscale='Reds') pf.violin(cols=['K_Reuss', 'K_Voigt', 'G_Reuss', 'G_Voigt'], use_colorscale=True)
def load_citrine_thermal_conductivity(room_temperature=True, data_home=None, download_if_missing=True): """ Convenience function for loading the citrine thermal conductivity dataset. Args: room_temperature (bool) Whether or not to only return items with room temperature k_condition. True by default. data_home (str, None): Where to look for and store the loaded dataset download_if_missing (bool): Whether or not to download the dataset if it isn't on disk Returns: (pd.DataFrame) """ df = load_dataset("citrine_thermal_conductivity", data_home, download_if_missing) if room_temperature: df = df[df['k_condition'].isin(['room temperature', 'Room temperature', 'Standard', '298', '300'])] return df.drop(['k-units', 'k_condition', 'k_condition_units'], axis=1)
def load_glass_ternary_hipt(system="all", data_home=None, download_if_missing=True): """ Convenience function for loading the glass_ternary_hipt dataset. Args: system (str, list): return items only from the requested system(s) options are: "CoFeZr", "CoTiZr", "CoVZr", "FeTiNb" data_home (str, None): Where to look for and store the loaded dataset download_if_missing (bool): Whether or not to download the dataset if it isn't on disk Returns: (pd.DataFrame) """ df = load_dataset("glass_ternary_hipt", data_home, download_if_missing) if system != "all": if isinstance(system, str): system = [system] for item in system: if item not in {"CoFeZr", "CoTiZr", "CoVZr", "FeTiNb"}: raise AttributeError("some of the system list {} are not " "in this dataset".format(system)) df = df[df["system"].isin(system)] return df
def load_citrine_thermal_conductivity(room_temperature=True, data_home=None, download_if_missing=True): """ Convenience function for loading the citrine thermal conductivity dataset. Args: room_temperature (bool) Whether or not to only return items with room temperature k_condition. True by default. data_home (str, None): Where to look for and store the loaded dataset download_if_missing (bool): Whether or not to download the dataset if it isn't on disk Returns: (pd.DataFrame) """ df = load_dataset("citrine_thermal_conductivity", data_home, download_if_missing) if room_temperature: df = df[df['k_condition'].isin( ['room temperature', 'Room temperature', 'Standard', '298', '300'])] return df.drop(['k-units', 'k_condition', 'k_condition_units'], axis=1)
def load_glass_ternary_landolt(processing="all", unique_composition=True, data_home=None, download_if_missing=True): """ Convenience function for loading the glass_ternary_landolt dataset. Args: processing (str): return only items with a specified processing method defaults to all, options are sputtering and meltspin unique_composition (bool): Whether or not to combine compositions with the same formula data_home (str, None): Where to look for and store the loaded dataset download_if_missing (bool): Whether or not to download the dataset if it isn't on disk Returns: (pd.DataFrame) """ df = load_dataset("glass_ternary_landolt", data_home, download_if_missing) if processing != "all": if processing in {"meltspin", "sputtering"}: df = df[df["processing"] == processing] else: raise ValueError("Error, processing method unrecognized") if unique_composition: df = df.groupby("formula").max().reset_index() return df
def load_elastic_tensor(version="2015", include_metadata=False, data_home=None, download_if_missing=True): """ Convenience function for loading the elastic_tensor dataset. Args: version (str): Version of the elastic_tensor dataset to load (defaults to 2015) include_metadata (bool): Whether or not to include the cif, meta, and poscar dataset columns. False by default. data_home (str, None): Where to look for and store the loaded dataset download_if_missing (bool): Whether or not to download the dataset if it isn't on disk Returns: (pd.DataFrame) """ df = load_dataset("elastic_tensor" + "_" + version, data_home, download_if_missing) if not include_metadata: df = df.drop(['cif', 'kpoint_density', 'poscar'], axis=1) return df
def load_glass_ternary_hipt(system="all", data_home=None, download_if_missing=True): """ Convenience function for loading the glass_ternary_hipt dataset. Args: system (str, list): return items only from the requested system(s) options are: "CoFeZr", "CoTiZr", "CoVZr", "FeTiNb" data_home (str, None): Where to look for and store the loaded dataset download_if_missing (bool): Whether or not to download the dataset if it isn't on disk Returns: (pd.DataFrame) """ df = load_dataset("glass_ternary_hipt", data_home, download_if_missing) if system != "all": if isinstance(system, str): system = [system] for item in system: if item not in {"CoFeZr", "CoTiZr", "CoVZr", "FeTiNb"}: raise AttributeError("some of the system list {} are not " "in this dataset". format(system)) df = df[df["system"].isin(system)] return df
def load_jarvis_dft_2d(drop_nan_columns=None, data_home=None, download_if_missing=True): """ Convenience function for loading the jarvis dft 2d dataset. Args: drop_nan_columns (list, str): Column or columns to drop rows containing NaN values from data_home (str, None): Where to look for and store the loaded dataset download_if_missing (bool): Whether or not to download the dataset if it isn't on disk Returns: (pd.DataFrame) """ df = load_dataset("jarvis_dft_2d", data_home, download_if_missing) if drop_nan_columns is None: drop_nan_columns = [] elif isinstance(drop_nan_columns, str): drop_nan_columns = [drop_nan_columns] return df.dropna(subset=drop_nan_columns)
def advanced_histogram(): """ This is a work in progress """ df = load_dataset("dielectric_constant") pf = PlotlyFig(df, title="Various Histograms") pf.histogram(cols=['G_Reuss', 'G_VRH', 'G_Voigt'], bins={'size': 10})
def load_brgoch_superhard_training(subset="all", drop_suspect=False, data_home=None, download_if_missing=True): """ Convenience function for loading the expt_formation_enthalpy dataset. Args: subset (str): Identifier for subset of data to return, all: all possible columns including metadata, engineered features, and basic descriptors brgoch_features: only features from reference paper and targets basic_descriptors: only composition/structure columns and targets drop_suspect (bool): Whether to drop values with possibly incorrect elastic data and materials that could not be verified data_home (str, None): Where to look for and store the loaded dataset download_if_missing (bool): Whether or not to download the dataset if it isn't on disk Returns: (pd.DataFrame) """ if subset not in {"all", "brgoch_features", "basic_descriptors"}: raise ValueError("Error: dataset subset identifier {} " "not recognized".format(subset)) df = load_dataset("brgoch_superhard_training", data_home, download_if_missing) if drop_suspect: df = df[~df["suspect_value"]] if subset in {"all", "brgoch_features"}: feats_expanded = pd.DataFrame( [feat_dict for feat_dict in df["brgoch_feats"]]) for column in feats_expanded.columns: df[column] = feats_expanded[column] if subset == "basic_descriptors": df = df.drop([ feat for feat in df.columns if feat not in {"composition", "structure", "shear_modulus", "bulk_modulus"} ], axis=1) elif subset == "brgoch_features": df = df.drop([ "composition", "structure", "formula", "material_id", "suspect_value", "brgoch_feats" ], axis=1) return df
def advanced_bar(): """ Compare the number of sites in the unit cell and eij_max of the first 5 samples from the piezoelectric_tensor dataset. """ # Format the general layout of our figure with 5 samples pf = PlotlyFig(df=load_dataset("dielectric_constant").iloc[:5], title='Comparison of 5 materials band gaps and n') # Plot! colors = ['red', 'orange', 'yellow', 'blue', 'green'] pf.bar(cols=['n', 'band_gap'], labels='formula', colors=colors)
def load_mp(include_structures=False, data_home=None, download_if_missing=True): """ Convenience function for loading the materials project dataset. Args: include_structures (bool) Whether or not to load the full mp structure data. False by default. data_home (str, None): Where to look for and store the loaded dataset download_if_missing (bool): Whether or not to download the dataset if it isn't on disk Returns: (pd.DataFrame) """ if include_structures: df = load_dataset('mp_all', data_home, download_if_missing) else: df = load_dataset('mp_nostruct', data_home, download_if_missing) return df
def load_data(nrows): df = load_dataset("matbench_expt_is_metal") df = df.sample(nrows, random_state=42) featurizer = Meredig() df["pmg_composition"] = df["composition"].apply(lambda x: Composition(x)) df_feat = featurizer.featurize_dataframe( df=df, col_id="pmg_composition", ignore_errors=True, pbar=False).drop(columns=["pmg_composition"]) df_feat["is_metal"] = df_feat["is_metal"].apply(lambda x: 1 if x else 0) df_feat["Metal vs Nonmetal"] = df_feat["is_metal"].apply( lambda x: "Metal" if x else "Nonmetal") return df_feat
def basic_histogram(): """ Here we plot a basic histogram showing the distribution of band gaps in the matminer dielectric constant dataset, originally taken from Petousis et al., 2017. """ df = load_dataset("dielectric_constant") pf = PlotlyFig( title="Distribution of Band Gaps in the Dielectric Constant " "Dataset", x_title="Band Gap (eV)", hoverinfo='y') pf.histogram(df['band_gap'])
def df_matbench_phonons(): """Return a pandas dataframe with the data from the Matbench phonons dataset.""" df = load_dataset("matbench_phonons") df[["lattice", "sites"]] = [get_cgcnn_input(x) for x in df.structure] df["material_id"] = [f"mb_phdos_{i}" for i in range(len(df))] df["composition"] = [ x.composition.formula.replace(" ", "") for x in df.structure ] df["phdos_clf"] = [1 if x > 450 else 0 for x in df["last phdos peak"]] return df
def load_mp(include_structures=False, data_home=None, download_if_missing=True): """ Convenience function for loading the materials project dataset. Args: include_structures (bool) Whether or not to load the full mp structure data. False by default. data_home (str, None): Where to loom for and store the loaded dataset download_if_missing (bool): Whether or not to download the dataset if it isn't on disk Returns: (pd.DataFrame) """ if include_structures: df = load_dataset('mp_all', data_home, download_if_missing) else: df = load_dataset('mp_nostruct', data_home, download_if_missing) return df
def load_flla(data_home=None, download_if_missing=True): """ Convenience function for loading the flla dataset. Args: data_home (str, None): Where to look for and store the loaded dataset download_if_missing (bool): Whether or not to download the dataset if it isn't on disk Returns: (pd.DataFrame) """ df = load_dataset("flla", data_home, download_if_missing) return df
def load_double_perovskites_gap_lumo(data_home=None, download_if_missing=True): """ Convenience function for loading the double_perovskites_gap_lumo dataset. Args: data_home (str, None): Where to loom for and store the loaded dataset download_if_missing (bool): Whether or not to download the dataset if it isn't on disk Returns: (pd.DataFrame) """ df = load_dataset("double_perovskites_gap_lumo", data_home, download_if_missing) return df
def load_brgoch_superhard_training(subset="all", drop_suspect=False, data_home=None, download_if_missing=True): """ Convenience function for loading the expt_formation_enthalpy dataset. Args: subset (str): Identifier for subset of data to return, all: all possible columns including metadata, engineered features, and basic descriptors brgoch_features: only features from reference paper and targets basic_descriptors: only composition/structure columns and targets drop_suspect (bool): Whether to drop values with possibly incorrect elastic data and materials that could not be verified data_home (str, None): Where to look for and store the loaded dataset download_if_missing (bool): Whether or not to download the dataset if it isn't on disk Returns: (pd.DataFrame) """ if subset not in {"all", "brgoch_features", "basic_descriptors"}: raise ValueError("Error: dataset subset identifier {} " "not recognized".format(subset)) df = load_dataset("brgoch_superhard_training", data_home, download_if_missing) if drop_suspect: df = df[~df["suspect_value"]] if subset in {"all", "brgoch_features"}: feats_expanded = pd.DataFrame([feat_dict for feat_dict in df["brgoch_feats"]]) for column in feats_expanded.columns: df[column] = feats_expanded[column] if subset == "basic_descriptors": df = df.drop([feat for feat in df.columns if feat not in {"composition", "structure", "shear_modulus", "bulk_modulus"}], axis=1) elif subset == "brgoch_features": df = df.drop(["composition", "structure", "formula", "material_id", "suspect_value", "brgoch_feats"], axis=1) return df
def formatting_example(api_key, username): """ Demonstrate common and advanced formatting features of PlotlyFig. PlotlyFig provides a set of arguments which make setting up good looking Plotly templates quick(er) and easy(er). Most formatting options can be set through the initializer of PlotlyFig. These options will remain the same for all figures producted, but you can change some common formatting options after instantitating a PlotlyFig object using set_arguments. Chart-specific formatting options can be passed to plotting methods. """ if not api_key or not username: raise ValueError("Specify your Plotly api_key and username!") df = load_dataset("elastic_tensor_2015") pf = PlotlyFig(df=df, api_key=api_key, username=username, mode='online', title='Comparison of Bulk Modulus and Shear Modulus', x_title='Shear modulus (GPa)', y_title='Bulk modulus (GPa)', colorbar_title='Poisson Ratio', fontfamily='Raleway', fontscale=0.75, fontcolor='#283747', ticksize=30, colorscale="Reds", hovercolor='white', hoverinfo='text', bgcolor='#F4F6F6', margins=110, pad=10) pf.xy(('G_VRH', 'K_VRH'), labels='material_id', colors='poisson_ratio') # We can also use LaTeX if we use Plotly online/static pf.set_arguments(title="$\\text{Origin of Poisson Ratio } \\nu $", y_title='$K_{VRH} \\text{(GPa)}$', x_title='$G_{VRH} \\text{(GPa)}$', colorbar_title='$\\nu$') pf.xy(('G_VRH', 'K_VRH'), labels='material_id', colors='poisson_ratio')
def load(dataset_name, dataset_metadata=mbv01_metadata): """ Load a matbench dataset into memory as a dataframe. This function is simply a wrapper around the matminer dataloader. Each matbench dataset is completely self contained. See https://hackingmaterials.lbl.gov/matbench/ for a list of dataset names. For example, "matbench_jdft2d". Args: dataset_name (str): A matbench dataset name, as defined in the datasets.json. Returns: (pandas.DataFrame): The dataset, containing two columns: - Inputs, either compositions or pymatgen structure objects. - Outputs, either a float (for regression) or a boolean (for classification). """ if dataset_name not in dataset_metadata: raise KeyError( f"Dataset name {dataset_name} not recognized by matbench. " f"Please see https://hackingmaterials.lbl.gov/matbench for " f"a list of the dataset names, or choose from:" f"\n{list(dataset_metadata.keys())}") logger.debug(f"Loading {dataset_name} into memory; please be patient as " f"loading many structures can take a while to serialize.") df = load_dataset(dataset_name) id_n_zeros = math.floor(math.log(df.shape[0], 10)) + 1 mpcontribs_prefix = dataset_name.replace("matbench", "mb").replace("_", "-") df[MBID_KEY] = [ f"{mpcontribs_prefix}-{i + 1:0{id_n_zeros}d}" for i in df.index ] df = df.set_index(MBID_KEY) df = df[[ dataset_metadata[dataset_name].input_type, dataset_metadata[dataset_name].target, ]] return df
def plot_bulk_shear_moduli(): """ Very basic example of xy scatter plot of Voigt-Reuss-Hill (VRH) average bulk vs. shear modulus. Poisson ratio as marker colors make the distinction between materials with different bulk/shear modulus ratios Returns: plotly plot in "offline" mode popped in the default browser. """ df = load_dataset("elastic_tensor_2015") pf = PlotlyFig(df, y_title='Bulk Modulus (GPa)', x_title='Shear Modulus (GPa)', filename='bulk_shear_moduli.jpeg') pf.xy(('G_VRH', 'K_VRH'), labels='material_id', colors='poisson_ratio', colorscale='Picnic', limits={'x': (0, 300)})
def plot_scatter_matrix(): """ A few different scatter matrix plots using elastic dataset in matminer. Returns: plotly plot in "offline" mode opened in the default browser. """ df = load_dataset("elastic_tensor_2015") pf = PlotlyFig(df) # basic matrix: pf.scatter_matrix(cols=['K_VRH', 'G_VRH', 'nsites', 'volume']) # with colorscale and labels: pf.scatter_matrix(cols=['K_VRH', 'G_VRH', 'nsites', 'volume'], colors='nsites', labels='material_id', colorscale='Picnic') # with all the numerical columns included (note the change in sizes): pf = PlotlyFig(filename='scatter_matrix_elastic', fontscale=0.6) pf.scatter_matrix(df, marker_scale=0.6)
def load_dielectric_constant(include_metadata=False, data_home=None, download_if_missing=True): """ Convenience function for loading the dielectric_constant dataset. Args: include_metadata (bool): Whether or not to include the cif, meta, and poscar dataset columns. False by default. data_home (str, None): Where to look for and store the loaded dataset download_if_missing (bool): Whether or not to download the dataset if it isn't on disk Returns: (pd.DataFrame) """ df = load_dataset("dielectric_constant", data_home, download_if_missing) if not include_metadata: df = df.drop(['cif', 'meta', 'poscar'], axis=1) return df
def plot_mean_elastic_tensors(): """ An example of heatmap_df where the input data is real and in dataframe format. We want to look at how average of the elastic constant tensor changes with the density and crystal system. Note that density is not a categorical variable in the final dataframe. Returns: plotly plot in "offline" mode poped in the default browser. """ df = load_dataset("elastic_tensor_2015") # data preparation: df['Mean Elastic Constant'] = df['elastic_tensor'].apply( lambda x: np.mean(x)) gs = GlobalSymmetryFeatures(desired_features=['crystal_system']) df = gs.featurize_dataframe(df, col_id='structure') dsf = DensityFeatures(desired_features=['density']) df = dsf.featurize_dataframe(df, col_id='structure') # actual plotting pf = PlotlyFig(fontscale=0.75, filename='static_elastic_constants', colorscale='RdBu') pf.heatmap_df(df[['crystal_system', 'density', 'Mean Elastic Constant']])
def load_glass_binary(version="v2", data_home=None, download_if_missing=True): """ Convenience function for loading the glass_binary dataset. Args: version (str): Version identifier for dataset, see dataset description for explanation of each. Defaults to v2 data_home (str, None): Where to look for and store the loaded dataset download_if_missing (bool): Whether or not to download the dataset if it isn't on disk Returns: (pd.DataFrame) """ # Set version tag if dataset is updated to a new version dataset_identifier = "glass_binary" if version != "v1": dataset_identifier = "_".join([dataset_identifier, version]) df = load_dataset(dataset_identifier, data_home, download_if_missing) return df
https://ml.materialsproject.org/projects/matbench_dielectric """ # %% import matplotlib.pyplot as plt import pandas as pd from matminer.datasets import load_dataset from pymatgen.symmetry.analyzer import SpacegroupAnalyzer from pymatviz import ptable_heatmap, spacegroup_hist from tqdm import tqdm # %% tqdm.pandas() (dielectric := load_dataset("matbench_dielectric")) # %% dielectric.hist(column="n", bins=50, log=True) plt.savefig("dielectric-last-dos-peak-hist.pdf") # %% dielectric["volume"] = dielectric.structure.apply(lambda cryst: cryst.volume) dielectric["formula"] = dielectric.structure.apply(lambda cryst: cryst.formula) ptable_heatmap(dielectric.formula, log=True) plt.title("Elemental prevalence in the Matbench dieletric dataset") plt.savefig("dielectric-elements-log.pdf") # %% dielectric[["sg_symbol", "sg_number"]] = dielectric.progress_apply(
#!/usr/bin/env python # coding: utf-8 # In[1]: # UROP Phase 1 Data Retrieval and partial preprocessing # all data is from material project database. from matminer.datasets import load_dataset from matminer.data_retrieval.retrieve_MP import MPDataRetrieval mpdr = MPDataRetrieval(api_key="KcDv6qi5w4rUZSlt") d = load_dataset("heusler_magnetic") heusler_formula = d['formula'] # In[ ]: import pandas as pd import time query_time = list() false_list = list() true_list = list() data = list() heusler_matrix = pd.DataFrame() start_time = time.time() for name in heusler_formula: t_1 = time.time() data_got = mpdr.get_data( criteria=name, properties=['pretty_formula', 'structure', 'elasticity']) t_2 = time.time()
# the Materials Project database, and the dataframe is filtered for stability # and structure size. FABER = not args.use_mp FILTER = not FABER NJOBS = args.njobs # Print parameters. print("REMOVE UNSTABLE ENTRIES:", FILTER) print("USE FABER DATASET:", FABER) print("USE TERNARY OXIDE DATASET:", not FABER) print("NUMBER OF JOBS:", NJOBS) print("DEBUG MODE:", args.debug) # Set up dataset if FABER: df = load_dataset("flla") else: # Initialize data retrieval class from matminer.data_retrieval.retrieve_MP import MPDataRetrieval mpr = MPDataRetrieval() criteria = "*-*-O" # Choose list of properties to retrive properties = [ 'structure', 'nsites', 'formation_energy_per_atom', 'e_above_hull' ] # Get the dataframe with the matching structure from the Materials Project df = mpr.get_dataframe(criteria=criteria, properties=properties) # Create the formation_energy feature for the SCM regression, since the SCM # model learns formation energy per unit cell rather than per atom. df['formation_energy'] = df['formation_energy_per_atom'] * df['nsites'] # Structures are retrieved as dictionaries but can easily be converted to
def plot_modes(api_key, username): """ Demonstrate PlotlyFig plotting modes and show the easiest way to make adjustments. Offline mode - Set "mode" to "offline" Create a local html file. Note that offline mode in plotly disables LaTeX and some fonts on some systems by default. For the full-featured Plotly experience, please use the Plotly online mode. Static mode - Set "mode" to "static" Creates a single image file. Use height and width to specify the size of the image desired. api_key and username are required for static plotting mode. Online mode - Set "mode" to "online" Opens the figure in the Plotly online module. Notebook mode - Set "mode" to "notebook" Opens the figure in a Jupyter/IPython notebook. Not shown here, seen matminer_examples repository. Return mode - Pass "return_plot=True" into any plotting method Returns the figure as a 'bare-bones' dictionary. This can then be edited and passed into 'create_plot' of PlotlyFig or used directly with plotly. """ if not api_key or not username: raise ValueError("Specify your Plotly api_key and username!") df = load_dataset("elastic_tensor_2015") # First lets set uo our figure generally. pf = PlotlyFig(df, title='Elastic data', mode='offline', x_scale='log', y_scale='log') # Lets plot offline (the default) first. An html file will be created. pf.xy([('poisson_ratio', 'elastic_anisotropy')], labels='formula') # Now lets plot again, but changing the filename and without opening. # We do this with the 'set_arguments' method. pf.set_arguments(show_offline_plot=False, filename="myplot.html") pf.xy([('poisson_ratio', 'elastic_anisotropy')], labels='formula') # Now lets create a static image. pf.set_arguments(mode='static', api_key=api_key, username=username, filename="my_PlotlyFig_plot.jpeg") pf.xy([('poisson_ratio', 'elastic_anisotropy')], labels='formula') # You can change the size of the image with the 'height' and 'width' # arguments to set_arguments. # Now we will use the Plotly online interface. pf.set_arguments(mode='online') pf.xy([('poisson_ratio', 'elastic_anisotropy')], labels='formula') # Great! Lets get the JSON representation of the PlotlyFig template as a # python dictionary. We can do this without changing the plot mode. From # any plotting method, simply pass 'return_plot=True' to return the plot. fig = pf.xy([('poisson_ratio', 'elastic_anisotropy')], labels='formula', return_plot=True) print("Here's our returned figure!") pprint.pprint(fig) # Edit the figure and plot it with the current plot mode (online): fig['layout']['hoverlabel']['bgcolor'] = 'pink' fig['layout']['title'] = 'My Custom Elastic Data Figure' pf.create_plot(fig)
def setUp(self): self.test_df = load_dataset('elastic_tensor_2015').rename( columns={"formula": "composition"})
else: raise ValueError(f"Worker {worker} not valid!") o_utf = o.decode("utf-8") o_all = o_utf.split("\n") o_all.remove("") password = o_all[-1] ssh = SSHClient() ssh.load_system_host_keys() ssh.connect(host, username=user, password=password, look_for_keys=False) with SCPClient(ssh.get_transport()) as scp: scp.put(filepath, recursive=True, remote_path="/global/home/users/ardunn") else: pass if __name__ == "__main__": import pandas as pd from matminer.datasets import load_dataset from automatminer_dev.workflows.util import get_time_str df = load_dataset("matbench_jdft2d") transfer_data(df, "lrc", get_time_str())