def advanced_histogram():
"""
This is a work in progress
"""
df = load_elastic_tensor()
pf = PlotlyFig(df, title="Various Histograms")
pf.histogram(cols=['G_Reuss', 'G_VRH', 'G_Voigt'], bins={'size': 10})
def advanced_histogram():
"""
This is a work in progress
"""
df = load_elastic_tensor()
pf = PlotlyFig(df, title="Various Histograms")
pf.histogram(cols=['G_Reuss', 'G_VRH', 'G_Voigt'], bins={'size': 10})
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 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_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 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_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 train_split():
name='full_vector_all.csv'
df=pd.read_csv(name,index_col = [0])
y=df['is_daoti'].values
uwnanted_columns=['band_gap.optimize_structure_gap','gaps','full_formula','composition','composition_oxid','is_daoti']
X_df=df.drop(uwnanted_columns,axis=1,inplace=False)
print(X_df[X_df.isnull().values==True])
X=X_df.values
X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0.2,random_state=1)
print("\n")
print("我们看下这些分开的不同测试集合训练集")
rf_reg=RandomForestClassifier(n_estimators=100,random_state=1)
rf_reg.fit(X_train,y_train)
#下面我们看一下进行训练集、测试集划分之后的效果
print("训练集的准确度是：{:.3f}".format(rf_reg.score(X_train,y_train)))
print("训练集的rmse是:{:.3f}".format(np.sqrt(mean_squared_error(y_true=y_train,y_pred=rf_reg.predict(X_train)))))
print("测试集上的准确度是:{:.3f}".format(rf_reg.score(X_test,y_test)))
print("测试集上的rmse是:{:.3f}".format(np.sqrt(mean_squared_error(y_true=y_test,y_pred=rf_reg.predict(X_test)))))
#然后我们还是来画图
pf_rf=PlotlyFig(x_title='Bulk modulus prediction residual (Gpa)',y_title='Probability',title='Random forest regression residuals',filename='rf_regression_residuals.html')
hist_plot=pf_rf.histogram(data=[y_train-rf_reg.predict(X_train),y_test-rf_reg.predict(X_test)],histnorm='probability',colors=['blue','red'],return_plot=True)
hist_plot['data'][0]['name']='train'
hist_plot['data'][1]['name']='test'
pf_rf.create_plot(hist_plot)
print('\n\n')
def refresh_json(open_plots=False):
"""
For developer use. Refresh the json files and open plots to see if they
look good. Use this function to set the current PlotlyFig build outputs
as the true values of the tests.
Args:
open_plots (bool): If True, opens all plots generated. Useful if you
want to check the current build outputs to make sure they look good.
If False, just generates the json files and quits.
"""
pf = PlotlyFig(**pfkwargs)
xys = pf.xy([(a, b)], return_plot=True)
xym = pf.xy([(a, b), (b, a)], return_plot=True)
xy_colors = pf.xy([(a, b), (a, c), (c, c)],
modes=['markers', 'markers+lines', 'lines'],
colors=[c, 'red', 'blue'], return_plot=True)
hmb = pf.heatmap_basic([a, b, c], xlabels, ylabels, return_plot=True)
his = pf.histogram(a + b + c, n_bins=5, return_plot=True)
bar = pf.bar(x=a, y=b, labels=xlabels, return_plot=True)
pcp = pf.parallel_coordinates([a, b], cols=xlabels, return_plot=True)
# Layout is compared for the plots which always convert to dataframes,
# as dataframes are not easily encoded by json.dump
vio = pf.violin([a, b, c, b, a, c, b], cols=xlabels, return_plot=True)
scm = pf.scatter_matrix([a, b, c], return_plot=True)
df = pd.DataFrame(data=np.asarray([ah, bh, ch]).T,
columns=['ah', 'bh', 'ch'])
x_labels = ['low', 'high']
y_labels = ['small', 'large']
# TODO: this plot was not JSON serializable, use a different serialization method for all plots
hmdf = pf.heatmap_df(df, x_labels=x_labels, y_labels=y_labels, return_plot=True)
df = pd.DataFrame(np.random.rand(50, 3), columns=list('qwe'))
triangle = pf.triangle(df[['q', 'w', 'e']], return_plot=True)
fnamedict = {"xys": xys, "xym": xym, "xy_colors":xy_colors,
"hmb": hmb, "his": his, "bar": bar,
"pcp": pcp, "vio": vio, "scm": scm,
'triangle': triangle,
'hmdf': hmdf
}
for fname, obj in fnamedict.items():
if obj in [vio, scm]:
obj = obj['layout']
with open("template_{}.json".format(fname), "w") as f:
json.dump(obj, f, cls=MontyEncoder)
if open_plots:
for obj in fnamedict.values():
pf.create_plot(obj, return_plot=False)
def train_split():
df = pd.read_csv('引入结构中的密度.csv')
y = df['K_VRH'].values
excluded = [
"G_VRH", "K_VRH", "elastic_anisotropy", "formula", "material_id",
"poisson_ratio", "structure", "composition", "composition_oxid"
]
X = df.drop(excluded, axis=1)
X['formula'] = df['formula']
X_train, X_test, y_train, y_test = train_test_split(X,
y,
test_size=0.2,
random_state=1)
print("\n")
print("我们看下这些分开的不同测试集合训练集")
print("x训练集是\n{}".format(X_train))
#time.sleep(30)
train_formula = X_train['formula']
X_train = X_train.drop('formula', axis=1)
test_formula = X_test['formula']
X_test = X_test.drop('formula', axis=1)
rf_reg = RandomForestRegressor(n_estimators=100, random_state=1)
rf_reg.fit(X_train, y_train)
#下面我们看一下进行训练集、测试集划分之后的效果
print("训练集的r2是：{:.3f}".format(rf_reg.score(X_train, y_train)))
print("训练集的rmse是:{:.3f}".format(
np.sqrt(
mean_squared_error(y_true=y_train,
y_pred=rf_reg.predict(X_train)))))
print("测试集上的r2是:{:.3f}".format(rf_reg.score(X_test, y_test)))
print("测试集上的rmse是:{:.3f}".format(
np.sqrt(
mean_squared_error(y_true=y_test, y_pred=rf_reg.predict(X_test)))))
#然后我们还是来画图
pf_rf = PlotlyFig(x_title='Bulk modulus prediction residual (Gpa)',
y_title='Probability',
title='Random forest regression residuals',
filename='rf_regression_residuals.html')
hist_plot = pf_rf.histogram(data=[
y_train - rf_reg.predict(X_train), y_test - rf_reg.predict(X_test)
],
histnorm='probability',
colors=['blue', 'red'],
return_plot=True)
hist_plot['data'][0]['name'] = 'train'
hist_plot['data'][1]['name'] = 'test'
pf_rf.create_plot(hist_plot)
print('\n\n')
def refresh_json(open_plots=False):
"""
For developer use. Refresh the json files and open plots to see if they
look good. Use this function to set the current PlotlyFig build outputs
as the true values of the tests.
Args:
open_plots (bool): If True, opens all plots generated. Useful if you
want to check the current build outputs to make sure they look good.
If False, just generates the json files and quits.
"""
pf = PlotlyFig(**pfkwargs)
xys = pf.xy([(a, b)], return_plot=True)
xym = pf.xy([(a, b), (b, a)], return_plot=True)
xy_colors = pf.xy([(a, b), (a, c), (c, c)],
modes=['markers', 'markers+lines', 'lines'],
colors=[c, 'red', 'blue'],
return_plot=True)
hmb = pf.heatmap_basic([a, b, c], xlabels, ylabels, return_plot=True)
his = pf.histogram(a + b + c, n_bins=5, return_plot=True)
bar = pf.bar(x=a, y=b, labels=xlabels, return_plot=True)
pcp = pf.parallel_coordinates([a, b], cols=xlabels, return_plot=True)
# Layout is compared for the plots which always convert to dataframes,
# as dataframes are not easily encoded by json.dump
vio = pf.violin([a, b, c, b, a, c, b], cols=xlabels, return_plot=True)
scm = pf.scatter_matrix([a, b, c], return_plot=True)
fnamedict = {
"xys": xys,
"xym": xym,
"xy_colors": xy_colors,
"hmb": hmb,
"his": his,
"bar": bar,
"pcp": pcp,
"vio": vio,
"scm": scm
}
for fname, obj in fnamedict.items():
if obj in [vio, scm]:
obj = obj['layout']
with open("template_{}.json".format(fname), "w") as f:
json.dump(obj, f)
if open_plots:
for obj in fnamedict.values():
pf.create_plot(obj, return_plot=False)
print(np.sqrt(mean_squared_error(y_true=y_train,
y_pred=rf_reg.predict(X_train))))
print(rf_reg.score(X_test, y_test))
print(np.sqrt(mean_squared_error(y_true=y_test,
y_pred=rf_reg.predict(X_test))))
from matminer.figrecipes.plot import PlotlyFig
pf_rf = PlotlyFig(x_title='Bulk modulus prediction residual (GPa)',
y_title='Probability',
title='Random forest regression residuals',
mode="offline",
filename="rf_regression_residuals.html")
hist_plot = pf_rf.histogram(data=[y_train-rf_reg.predict(X_train),
y_test-rf_reg.predict(X_test)],
histnorm='probability', colors=['blue', 'red'],
return_plot=True
)
hist_plot["data"][0]['name'] = 'train'
hist_plot["data"][1]['name'] = 'test'
pf_rf.create_plot(hist_plot)
importances = rf.feature_importances_
# included = np.asarray(included)
included = X.columns.values
indices = np.argsort(importances)[::-1]
pf = PlotlyFig(y_title='Importance (%)',
title='Feature by importances',
mode='offline',
filename='Feature_by_importances',
class PlotlyFigTest(PymatgenTest):
def setUp(self):
self.pf = PlotlyFig(**pfkwargs)
self.base_dir = os.path.dirname(os.path.realpath(__file__))
def fopen(self, fname):
fname = self.base_dir + "/" + fname
with open(fname, 'r') as f:
return json.load(f)
def test_xy(self):
# Single trace
xys_test = self.pf.xy([(a, b)], return_plot=True)
xys_true = self.fopen("template_xys.json")
self.assertTrue(xys_test == xys_true)
# Multi trace
xym_test = self.pf.xy([(a, b), (b, a)], return_plot=True)
xym_true = self.fopen("template_xym.json")
self.assertTrue(xym_test == xym_true)
xy_colors_test = self.pf.xy([(a, b), (a, c), (c, c)],
modes=['markers', 'markers+lines', 'lines'],
colors=[c, 'red', 'blue'], return_plot=True)
xy_colors_true = self.fopen("template_xy_colors.json")
self.assertTrue(xy_colors_test == xy_colors_true)
def test_heatmap_basic(self):
hmb_test = self.pf.heatmap_basic([a, b, c], xlabels, ylabels,
return_plot=True)
hmb_true = self.fopen("template_hmb.json")
self.assertTrue(hmb_test == hmb_true)
def test_histogram(self):
his_test = self.pf.histogram(a + b + c, n_bins=5, return_plot=True)
his_true = self.fopen("template_his.json")
self.assertTrue(his_test == his_true)
def test_bar(self):
bar_test = self.pf.bar(x=a, y=b, labels=xlabels, return_plot=True)
bar_true = self.fopen("template_bar.json")
self.assertTrue(bar_test == bar_true)
def test_parallel_coordinates(self):
pcp_test = self.pf.parallel_coordinates([a, b], cols=xlabels,
return_plot=True)
pcp_true = self.fopen("template_pcp.json")
self.assertTrue(pcp_test == pcp_true)
def test_violin(self):
vio_test = \
self.pf.violin([a, b, c, b, a, c, b], cols=xlabels, return_plot=True)[
'layout']
vio_true = self.fopen("template_vio.json")
self.assertTrue(vio_test == vio_true)
def test_scatter_matrix(self):
scm_test = self.pf.scatter_matrix([a, b, c], return_plot=True)['layout']
scm_true = self.fopen("template_scm.json")
self.assertTrue(scm_test == scm_true)
def test_heatmap_df(self):
df = pd.DataFrame(data=np.asarray([ah, bh, ch]).T,
columns=['ah', 'bh', 'ch'])
x_labels = ['low', 'high']
y_labels = ['small', 'large']
hmdf_test = self.pf.heatmap_df(df, x_labels=x_labels,
y_labels=y_labels,
return_plot=True)
hmdf_true = self.fopen("template_hmdf.json")
self.assertTrue(hmdf_test, hmdf_true)
def test_trianlge(self):
df = pd.DataFrame(np.random.rand(50, 3), columns=list('qwe'))
triangle_test = self.pf.triangle(df[['q', 'w', 'e']], return_plot=True)
triangle_true = self.fopen("template_triangle.json")
self.assertTrue(triangle_test, triangle_true)
class PlotlyFigTest(PymatgenTest):
def setUp(self):
self.pf = PlotlyFig(**pfkwargs)
self.base_dir = os.path.dirname(os.path.realpath(__file__))
def fopen(self, fname):
fname = self.base_dir + "/" + fname
with open(fname, 'r') as f:
return json.load(f)
def test_xy(self):
# Single trace
xys_test = self.pf.xy([(a, b)], return_plot=True)
xys_true = self.fopen("template_xys.json")
self.assertTrue(xys_test == xys_true)
# Multi trace
xym_test = self.pf.xy([(a, b), (b, a)], return_plot=True)
xym_true = self.fopen("template_xym.json")
self.assertTrue(xym_test == xym_true)
xy_colors_test = self.pf.xy(
[(a, b), (a, c), (c, c)],
modes=['markers', 'markers+lines', 'lines'],
colors=[c, 'red', 'blue'],
return_plot=True)
xy_colors_true = self.fopen("template_xy_colors.json")
self.assertTrue(xy_colors_test == xy_colors_true)
def test_heatmap_basic(self):
hmb_test = self.pf.heatmap_basic([a, b, c],
xlabels,
ylabels,
return_plot=True)
hmb_true = self.fopen("template_hmb.json")
self.assertTrue(hmb_test == hmb_true)
def test_histogram(self):
his_test = self.pf.histogram(a + b + c, n_bins=5, return_plot=True)
his_true = self.fopen("template_his.json")
self.assertTrue(his_test == his_true)
def test_bar(self):
bar_test = self.pf.bar(x=a, y=b, labels=xlabels, return_plot=True)
bar_true = self.fopen("template_bar.json")
self.assertTrue(bar_test == bar_true)
def test_parallel_coordinates(self):
pcp_test = self.pf.parallel_coordinates([a, b],
cols=xlabels,
return_plot=True)
pcp_true = self.fopen("template_pcp.json")
self.assertTrue(pcp_test == pcp_true)
def test_violin(self):
vio_test = \
self.pf.violin([a, b, c, b, a, c, b], cols=xlabels, return_plot=True)[
'layout']
vio_true = self.fopen("template_vio.json")
self.assertTrue(vio_test == vio_true)
def test_scatter_matrix(self):
scm_test = self.pf.scatter_matrix([a, b, c],
return_plot=True)['layout']
scm_true = self.fopen("template_scm.json")
self.assertTrue(scm_test == scm_true)
def test_heatmap_df(self):
a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
b = [2, 4, 6, 8, 10, 2, 4, 6, 8, 10]
c = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
df = pd.DataFrame(data=np.asarray([a, b, c]).T,
columns=['a', 'b', 'c'])
x_labels = ['low', 'high']
y_labels = ['small', 'large']
self.pf.heatmap_df(df,
x_labels=x_labels,
y_labels=y_labels,
return_plot=True)
class PlotlyFigTest(PymatgenTest):
def setUp(self):
self.pf = PlotlyFig(**pfkwargs)
self.base_dir = os.path.dirname(os.path.realpath(__file__))
def fopen(self, fname):
fname = self.base_dir + "/" + fname
with open(fname, 'r') as f:
return json.load(f)
def test_xy(self):
# Single trace
xys_test = self.pf.xy([(a, b)], return_plot=True)
xys_test['data'] = [p.to_plotly_json() for p in xys_test['data']]
xys_true = self.fopen("template_xys.json")
self.assertTrue(xys_test == xys_true)
# Multi trace
xym_test = self.pf.xy([(a, b), (b, a)], return_plot=True)
xym_test['data'] = [p.to_plotly_json() for p in xym_test['data']]
xym_true = self.fopen("template_xym.json")
self.assertTrue(xym_test == xym_true)
xy_colors_test = self.pf.xy(
[(a, b), (a, c), (c, c)],
modes=['markers', 'markers+lines', 'lines'],
colors=[c, 'red', 'blue'],
return_plot=True)
xy_colors_test['data'] = [
p.to_plotly_json() for p in xy_colors_test['data']
]
xy_colors_true = self.fopen("template_xy_colors.json")
self.assertTrue(xy_colors_test == xy_colors_true)
def test_heatmap_basic(self):
hmb_test = self.pf.heatmap_basic([a, b, c],
xlabels,
ylabels,
return_plot=True)
hmb_test['data'] = [p.to_plotly_json() for p in hmb_test['data']]
hmb_true = self.fopen("template_hmb.json")
self.assertEqual(hmb_test, hmb_true)
def test_histogram(self):
his_test = self.pf.histogram(a + b + c, n_bins=5, return_plot=True)
his_test['data'] = [p.to_plotly_json() for p in his_test['data']]
his_true = self.fopen("template_his.json")
self.assertTrue(his_test == his_true)
def test_bar(self):
bar_test = self.pf.bar(x=a, y=b, labels=xlabels, return_plot=True)
bar_test['data'] = [p.to_plotly_json() for p in bar_test['data']]
bar_true = self.fopen("template_bar.json")
self.assertTrue(bar_test == bar_true)
def test_parallel_coordinates(self):
pcp_test = self.pf.parallel_coordinates([a, b],
cols=xlabels,
return_plot=True)
pcp_test['data'] = [p.to_plotly_json() for p in pcp_test['data']]
pcp_true = self.fopen("template_pcp.json")
self.assertTrue(pcp_test == pcp_true)
def test_violin(self):
vio_test = self.pf.violin([a, b, c, b, a, c, b],
cols=xlabels,
return_plot=True)['layout']
vio_test = vio_test.to_plotly_json()
vio_true = self.fopen("template_vio.json")
# Avoid errors from CircleCI's different plotly config
for vio in [vio_test, vio_true]:
vio["xaxis"]["range"] = [-0.167009, 0.167009]
self.assertDictEqual(vio_test, vio_true)
def test_scatter_matrix(self):
scm_test = self.pf.scatter_matrix([a, b, c],
return_plot=True)['layout']
scm_test = scm_test.to_plotly_json()
scm_true = self.fopen("template_scm.json")
self.assertTrue(scm_test == scm_true)
def test_heatmap_df(self):
df = pd.DataFrame(data=np.asarray([ah, bh, ch]).T,
columns=['ah', 'bh', 'ch'])
x_labels = ['low', 'high']
y_labels = ['small', 'large']
with self.assertWarns(UserWarning):
hmdf_test = self.pf.heatmap_df(df,
x_labels=x_labels,
y_labels=y_labels,
return_plot=True)
hmdf_true = self.fopen("template_hmdf.json")
self.assertTrue(hmdf_test, hmdf_true)
def test_triangle(self):
df = pd.DataFrame(np.random.rand(50, 3), columns=list('qwe'))
triangle_test = self.pf.triangle(df[['q', 'w', 'e']], return_plot=True)
triangle_true = self.fopen("template_triangle.json")
self.assertTrue(triangle_test, triangle_true)
def refresh_json(open_plots=False):
"""
For developer use. Refresh the json files and open plots to see if they
look good. Use this function to set the current PlotlyFig build outputs
as the true values of the tests.
Args:
open_plots (bool): If True, opens all plots generated. Useful if you
want to check the current build outputs to make sure they look good.
If False, just generates the json files and quits.
"""
pf = PlotlyFig(**pfkwargs)
xys = pf.xy([(a, b)], return_plot=True)
xym = pf.xy([(a, b), (b, a)], return_plot=True)
xy_colors = pf.xy([(a, b), (a, c), (c, c)],
modes=['markers', 'markers+lines', 'lines'],
colors=[c, 'red', 'blue'], return_plot=True)
hmb = pf.heatmap_basic([a, b, c], xlabels, ylabels, return_plot=True)
his = pf.histogram(a + b + c, n_bins=5, return_plot=True)
bar = pf.bar(x=a, y=b, labels=xlabels, return_plot=True)
pcp = pf.parallel_coordinates([a, b], cols=xlabels, return_plot=True)
# plotly figures need to be converted jsonable data
xys['data'] = [p.to_plotly_json() for p in xys['data']]
xym['data'] = [p.to_plotly_json() for p in xym['data']]
xy_colors['data'] = [p.to_plotly_json() for p in xy_colors['data']]
hmb['data'] = [p.to_plotly_json() for p in hmb['data']]
his['data'] = [p.to_plotly_json() for p in his['data']]
bar['data'] = [p.to_plotly_json() for p in bar['data']]
pcp['data'] = [p.to_plotly_json() for p in pcp['data']]
# Layout is compared for the plots which always convert to dataframes,
# as dataframes are not easily encoded by json.dump
vio = pf.violin([a, b, c, b, a, c, b], cols=xlabels, return_plot=True)
scm = pf.scatter_matrix([a, b, c], return_plot=True)
# plotly layout needs to be converted jsonable data
vio = {'layout': vio['layout'].to_plotly_json()}
scm = {'layout': scm['layout'].to_plotly_json()}
df = pd.DataFrame(data=np.asarray([ah, bh, ch]).T,
columns=['ah', 'bh', 'ch'])
x_labels = ['low', 'high']
y_labels = ['small', 'large']
# TODO: this plot was not JSON serializable, use a different serialization method for all plots
hmdf = pf.heatmap_df(df, x_labels=x_labels, y_labels=y_labels, return_plot=True)
hmdf['data'] = [p.to_plotly_json() for p in hmdf['data']]
df = pd.DataFrame(np.random.rand(50, 3), columns=list('qwe'))
triangle = pf.triangle(df[['q', 'w', 'e']], return_plot=True)
fnamedict = {"xys": xys, "xym": xym, "xy_colors":xy_colors,
"hmb": hmb, "his": his, "bar": bar,
"pcp": pcp, "vio": vio, "scm": scm,
'triangle': triangle,
'hmdf': hmdf
}
for fname, obj in fnamedict.items():
if fname in ["vio", "scm"]:
obj = obj['layout']
with open("template_{}.json".format(fname), "w") as f:
json.dump(obj, f, cls=MontyEncoder)
if open_plots:
for obj in fnamedict.values():
pf.create_plot(obj, return_plot=False)
class PlotlyFigTest(PymatgenTest):
def setUp(self):
self.pf = PlotlyFig(**pfkwargs)
self.base_dir = os.path.dirname(os.path.realpath(__file__))
def fopen(self, fname):
fname = self.base_dir + "/" + fname
with open(fname, 'r') as f:
return json.load(f)
def test_xy(self):
# Single trace
xys_test = self.pf.xy([(a, b)], return_plot=True)
xys_test['data'] = [p.to_plotly_json() for p in xys_test['data']]
xys_true = self.fopen("template_xys.json")
self.assertTrue(xys_test == xys_true)
# Multi trace
xym_test = self.pf.xy([(a, b), (b, a)], return_plot=True)
xym_test['data'] = [p.to_plotly_json() for p in xym_test['data']]
xym_true = self.fopen("template_xym.json")
self.assertTrue(xym_test == xym_true)
xy_colors_test = self.pf.xy([(a, b), (a, c), (c, c)],
modes=['markers', 'markers+lines', 'lines'],
colors=[c, 'red', 'blue'], return_plot=True)
xy_colors_test['data'] = [p.to_plotly_json() for p in xy_colors_test['data']]
xy_colors_true = self.fopen("template_xy_colors.json")
self.assertTrue(xy_colors_test == xy_colors_true)
def test_heatmap_basic(self):
hmb_test = self.pf.heatmap_basic([a, b, c], xlabels, ylabels,
return_plot=True)
hmb_test['data'] = [p.to_plotly_json() for p in hmb_test['data']]
hmb_true = self.fopen("template_hmb.json")
self.assertTrue(hmb_test == hmb_true)
def test_histogram(self):
his_test = self.pf.histogram(a + b + c, n_bins=5, return_plot=True)
his_test['data'] = [p.to_plotly_json() for p in his_test['data']]
his_true = self.fopen("template_his.json")
self.assertTrue(his_test == his_true)
def test_bar(self):
bar_test = self.pf.bar(x=a, y=b, labels=xlabels, return_plot=True)
bar_test['data'] = [p.to_plotly_json() for p in bar_test['data']]
bar_true = self.fopen("template_bar.json")
self.assertTrue(bar_test == bar_true)
def test_parallel_coordinates(self):
pcp_test = self.pf.parallel_coordinates([a, b], cols=xlabels,
return_plot=True)
pcp_test['data'] = [p.to_plotly_json() for p in pcp_test['data']]
pcp_true = self.fopen("template_pcp.json")
self.assertTrue(pcp_test == pcp_true)
def test_violin(self):
vio_test = self.pf.violin(
[a, b, c, b, a, c, b], cols=xlabels, return_plot=True)['layout']
vio_test = vio_test.to_plotly_json()
vio_true = self.fopen("template_vio.json")
# Avoid errors from CircleCI's different plotly config
for vio in [vio_test, vio_true]:
vio["xaxis"]["range"] = [-0.167009, 0.167009]
self.assertDictEqual(vio_test, vio_true)
def test_scatter_matrix(self):
scm_test = self.pf.scatter_matrix([a, b, c], return_plot=True)['layout']
scm_test = scm_test.to_plotly_json()
scm_true = self.fopen("template_scm.json")
self.assertTrue(scm_test == scm_true)
def test_heatmap_df(self):
df = pd.DataFrame(data=np.asarray([ah, bh, ch]).T,
columns=['ah', 'bh', 'ch'])
x_labels = ['low', 'high']
y_labels = ['small', 'large']
with self.assertWarns(UserWarning):
hmdf_test = self.pf.heatmap_df(df, x_labels=x_labels,
y_labels=y_labels,
return_plot=True)
hmdf_true = self.fopen("template_hmdf.json")
self.assertTrue(hmdf_test, hmdf_true)
def test_triangle(self):
df = pd.DataFrame(np.random.rand(50, 3), columns=list('qwe'))
triangle_test = self.pf.triangle(df[['q', 'w', 'e']], return_plot=True)
triangle_true = self.fopen("template_triangle.json")
self.assertTrue(triangle_test, triangle_true)
