How to use seaborn - 10 common examples

help='draw 2D box')
    parser.add_argument('--draw_bev', default=False, action='store_true',
                        help='draw Birds eye view')
    args = parser.parse_args()
    args.select_seq = [args.select_seq] if isinstance(args.select_seq,
                                                      int) else args.select_seq

    print(' '.join(sys.argv))

    return args


args = parse_args()

# Global Variable
sns.set(style="darkgrid")
FONT = cv2.FONT_HERSHEY_SIMPLEX
FOURCC = cv2.VideoWriter_fourcc(*'mp4v')
OUTPUT_PATH = cfg.OUTPUT_PATH
FOV_H = 60
NEAR_CLIP = 0.15

if args.dataset == 'gta':
    W = cfg.GTA.W  # 1920
    H = cfg.GTA.H  # 1080
    resW = W // 2
    resH = H // 2
    FOCAL_LENGTH = cfg.GTA.FOCAL_LENGTH  # 935.3074360871937
else:
    W = cfg.KITTI.W # 1248
    H = cfg.KITTI.H # 384
    resW = W

def plotHistogram(values, xlabel=None, ylabel=None, title=None, xmin=None, xmax=None,
                  extra=None, extraColor='grey', extraLoc='right',
                  hist=True, showCI=False, showMean=False, showMedian=False,
                  color=None, shade=False, kde=True, show=True, filename=None):

    fig = plt.figure()

    style    = "white"
    colorSet = "Set1"
    sns.set_style(style)
    sns.set_palette(colorSet, desat=0.6)
    red, blue, green, purple = sns.color_palette(colorSet, n_colors=4)

    color = blue if color is None else color
    count = values.count()
    bins  = count // 10 if count > 150 else (count // 5 if count > 50 else (count // 2 if count > 20 else None))
    sns.distplot(values, hist=hist, bins=bins, kde=kde, color=color, kde_kws={'shade': shade})

    #sns.axlabel(xlabel=xlabel, ylabel=ylabel)
    if xlabel:
        plt.xlabel(xlabel) # , size='large')
    if ylabel:
        plt.ylabel(ylabel) # , size='large')

    sns.despine()

def plot_umap(trainer):
    latent_seq, latent_fish = trainer.get_latent()
    latent2d = umap.UMAP().fit_transform(np.concatenate([latent_seq, latent_fish]))
    latent2d_seq = latent2d[: latent_seq.shape[0]]
    latent2d_fish = latent2d[latent_seq.shape[0] :]

    data_seq, data_fish = [p.gene_dataset for p in trainer.all_dataset]

    colors = sns.color_palette(n_colors=30)
    plt.figure(figsize=(25, 10))
    ax = plt.subplot(1, 3, 1)
    ax.scatter(*latent2d_seq.T, color="r", label="seq", alpha=0.5, s=0.5)
    ax.scatter(*latent2d_fish.T, color="b", label="osm", alpha=0.5, s=0.5)
    ax.legend()

    ax = plt.subplot(1, 3, 2)
    labels = data_seq.labels.ravel()
    for i, label in enumerate(data_seq.cell_types):
        ax.scatter(
            *latent2d_seq[labels == i].T,
            color=colors[i],
            label=label[:12],
            alpha=0.5,
            s=5
        )

mmsb_degree = np.load('figures/mmsb_sparse_degree.npy')
kron_degree = np.load('figures/kron_degree.npy')
ba_degree = np.load('figures/ba_degree.npy')

real_clustering = np.load('figures/real_clustering.npy')
graphrnn_rnn_clustering = np.load('figures/graphrnn_rnn_clustering.npy')
graphrnn_mlp_clustering = np.load('figures/graphrnn_mlp_clustering.npy')
mmsb_clustering = np.load('figures/mmsb_sparse_clustering.npy')
kron_clustering = np.load('figures/kron_clustering.npy')
ba_clustering = np.load('figures/ba_clustering.npy')


plt.switch_backend('agg')

sns.set()
sns.set_style("ticks")
sns.set_context("poster",font_scale=1.4,rc={"lines.linewidth": 3.5})

fig = plt.figure()
plt.ylim(0, 0.1)
plt.xlim(0, 50)
plt.tight_layout()
current_size = fig.get_size_inches()
fig.set_size_inches(current_size[0]*1.5, current_size[1]*1.5)
degree_plot = sns.distplot(real_degree,hist=False,rug=False,norm_hist=True,label='Real')
degree_plot = sns.distplot(ba_degree,hist=False,rug=False,norm_hist=True,label='B-A')
degree_plot = sns.distplot(kron_degree,hist=False,rug=False,norm_hist=True,label='Kronecker')
degree_plot = sns.distplot(mmsb_degree,hist=False,rug=False,norm_hist=True,label='MMSB')
degree_plot = sns.distplot(graphrnn_mlp_degree,hist=False,rug=False,norm_hist=True,label='GraphRNN-S')
degree_plot = sns.distplot(graphrnn_rnn_degree,hist=False,rug=False,norm_hist=True,label='GraphRNN')

degree_plot.set(xlabel='degree', ylabel='probability density')

print("Prob exactly 2: " + str(prob_exactly_2))
    print("Prob exactly 1: " + str(prob_exactly_1))
    print("Prob never uninterpretable: " + str(prob_exactly_0))




"""attn_perf_overlap_for_model('yahoo')
attn_perf_overlap_for_model('imdb')
attn_perf_overlap_for_model('amazon')
attn_perf_overlap_for_model('yelp')"""


try:
    sns.set(font_scale=1.5)
    sns.set_style("whitegrid")
except:
    pass


def make_2x2_2boxplot_set(list1_of_two_vallists_to_boxplot, list2_of_two_vallists_to_boxplot,
                          list3_of_two_vallists_to_boxplot, list4_of_two_vallists_to_boxplot, list_of_colorlabels,
                          list_of_two_color_tuples, labels_for_4_boxplot_sets):
    pass


def make_4_4boxplot_set(list1_of_four_vallists_to_boxplot, list2_of_four_vallists_to_boxplot,
                        list3_of_four_vallists_to_boxplot, list4_of_four_vallists_to_boxplot, list_of_colorlabels,
                        list_of_four_color_tuples, labels_for_4_boxplot_sets):
    pass

def draw_group_boxplot(name_list,data_list1,data_list2, label ='Dice Score',titile=None, fpth=None ):
    df = get_df_from_list(name_list,data_list1,data_list2)
    df = df[['Group', 'Longitudinal', 'Cross-subject']]
    dd = pd.melt(df, id_vars=['Group'], value_vars=['Longitudinal', 'Cross-subject'], var_name='task')
    fig, ax = plt.subplots(figsize=(15, 8))
    sn=sns.boxplot(x='Group', y='value', data=dd, hue='task', palette='Set2',ax=ax)
    #sns.palplot(sns.color_palette("Set2"))
    sn.set_xlabel('')
    sn.set_ylabel(label)
    # plt.xticks(rotation=45)
    ax.yaxis.grid(True)
    leg=plt.legend(prop={'size': 18},loc=4)
    leg.get_frame().set_alpha(0.2)
    for item in ([ax.title, ax.xaxis.label, ax.yaxis.label] +
                 ax.get_xticklabels() + ax.get_yticklabels()):
        item.set_fontsize(20)
    for tick in ax.get_xticklabels():
        tick.set_rotation(30)
    if fpth is not None:
        plt.savefig(fpth,dpi=500, bbox_inches = 'tight')
        plt.close('all')
    else:

np.linalg.norm(p_hat - dcsbm_P) ** 2
# heatmap(dcsbe.p_mat_, inner_hier_labels=labels)
# heatmap(dcsbm_P, inner_hier_labels=labels)
import seaborn as sns


plt.figure()
sns.scatterplot(
    x=latent[:, 0], y=latent[:, 1], hue=dcsbe.vertex_assignments_, linewidth=0
)

#%%
from graspy.embed import LaplacianSpectralEmbed, AdjacencySpectralEmbed

plt.style.use("seaborn-white")
sns.set_palette("Set1")
plt.figure(figsize=(10, 10))
sns.set_context("talk", font_scale=1.5)
sns.scatterplot(x=latent[:, 0], y=latent[:, 1], hue=labels, linewidth=0)
plt.axis("square")
ase = AdjacencySpectralEmbed(n_components=2)
lse = LaplacianSpectralEmbed(n_components=2, form="R-DAD", regularizer=1)
ase_latent = ase.fit_transform(graph)
lse_latent = lse.fit_transform(graph)

plt.figure(figsize=(10, 10))
sns.scatterplot(x=ase_latent[:, 0], y=ase_latent[:, 1], hue=labels, linewidth=0)
plt.axis("square")

plt.figure(figsize=(10, 10))
sns.scatterplot(x=lse_latent[:, 0], y=lse_latent[:, 1], hue=labels, linewidth=0)
plt.axis("square")

# A PSD matrix can be created as follows, though is not used in the test.
        # H = H @ H.t()
        eigenvalues = A.symeig(H)[0]
        spectrum_norm = A.max(eigenvalues)
        H /= spectrum_norm

        K = 1024
        n_vec = 1
        eigs = matrix_ops.lanczos_spectrum_approx(H, 100, K, n_vec)
        eig_ref = A.symeig(H)[0]
        import seaborn as sns
        from matplotlib import pyplot as plt
        import pandas as pd
        plt.figure()
        sns.distplot(A.eval(eig_ref), bins=50, norm_hist=True, kde=False)
        sns.lineplot(data=pd.DataFrame(A.eval(eigs), index=np.linspace(-1, 1, K)) )
        plt.savefig("lanczos_wigner.jpg")

dataset.isna().sum()

dataset = dataset.dropna()

origin = dataset.pop('Origin')

dataset['USA'] = (origin == 1)*1.0
dataset['Europe'] = (origin == 2)*1.0
dataset['Japan'] = (origin == 3)*1.0
dataset.tail()

train_dataset = dataset.sample(frac=0.8, random_state=0)
test_dataset = dataset.drop(train_dataset.index)

sns.pairplot(
    train_dataset[["MPG", "Cylinders", "Displacement", "Weight"]], diag_kind="kde")


train_stats = train_dataset.describe()
train_stats.pop("MPG")
train_stats = train_stats.transpose()
train_stats

train_labels = train_dataset.pop('MPG')
test_labels = test_dataset.pop('MPG')


def norm(x):
  return (x - train_stats['mean']) / train_stats['std']

from __future__ import print_function

import argparse
import sys
import os
import toolshed as ts
sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
from itertools import groupby, cycle
from operator import itemgetter
import matplotlib
matplotlib.use('Agg')
from matplotlib import pyplot as plt
try:
    import seaborn as sns
    sns.set_context("paper")
    sns.set_style("dark", {'axes.linewidth': 1})
except ImportError:
    pass
import numpy as np
from cpv._common import bediter, get_col_num, genomic_control

def chr_cmp(a, b):
    a, b = a[0], b[0]
    a = a.lower().replace("_", ""); b = b.lower().replace("_", "")
    achr = a[3:] if a.startswith("chr") else a
    bchr = b[3:] if b.startswith("chr") else b

    try:
        return cmp(int(achr), int(bchr))
    except ValueError:
        if achr.isdigit() and not bchr.isdigit(): return -1
        if bchr.isdigit() and not achr.isdigit(): return 1