//  [python]
def seaborn_plot(self, suffix=""):
        import pandas as pd
        import seaborn as sns
        import matplotlib.pyplot as plt
        import numpy as np
        dfs = []
        regions = {}
        for mode in self.sim_plot_mode_list:
            if mode in ['recon', 'recon_random', 'scratch_encoder_step0', 'encoder_step0', 'dvec_step0']:
                regions[mode] = self.similarity_list_dict[mode]
            else:
                for step in self.step_list:
                    df = pd.DataFrame(self.similarity_list_dict[f'{mode}_step{step}'], columns=['Similarity'])
                    df['Approach'] = mode
                    df['Adaptation Steps'] = step
                    dfs.append(df)
                    # dataset[f'{mode}_{step}'] = self.similarity_list_dict[f'{mode}_step{step}']
        dfs = pd.concat(dfs)

        fig, ax = plt.subplots(figsize=(4.8, 4.2))
        ax = sns.tsplot(x='Adaptation Steps', y='Similarity', unit='Approach', data=dfs, ax=ax)
        plt.show()
        return
        exit()
        xmin, xmax = ax.get_xlim()

        # 1. preprocessing the data
        t = np.array(self.step_list)

        print(self.sim_plot_mode_list)
        self.mu_dict = dict()
        for mode in self.sim_plot_mode_list:
            if mode in ['recon', 'recon_random']:
                # self.mu_dict[mode] = np.array([np.mean(self.similarity_list_dict[mode])]*(len(self.step_list)+2))
                continue
            elif mode in ['scratch_encoder_step0', 'encoder_step0', 'dvec_step0']:
                # self.mu_dict[mode] = np.array([np.mean(self.similarity_list_dict[mode])]*(len(self.step_list)))
                continue
            else:
                mu_list = []
                for step in self.step_list:
                    mu_list.append(np.mean(self.similarity_list_dict[f'{mode}_step{step}']))
                self.mu_dict[mode] = np.array(mu_list)


        self.sigma_dict = dict()
        for mode in self.sim_plot_mode_list:
            if mode in ['recon', 'recon_random']:
                self.sigma_dict[mode] = np.array([np.std(self.similarity_list_dict[mode])]*(len(self.step_list)+2))
            elif mode in ['scratch_encoder_step0', 'encoder_step0', 'dvec_step0']:
                self.sigma_dict[mode] = np.array([np.std(self.similarity_list_dict[mode])]*(len(self.step_list)))
            else:
                sigma_list = []
                for step in self.step_list:
                    sigma_list.append(np.std(self.similarity_list_dict[f'{mode}_step{step}']))
                self.sigma_dict[mode] = np.array(sigma_list)
        print(self.mu_dict)
        print(self.sigma_dict)
        # exit()


        # 2. plot
        # fig, ax = plt.subplots(1)
        # fig, ax = plt.subplots(figsize=(4.30, 2.58))
        fig, ax = plt.subplots(figsize=(4.8, 4.2))
        line_list = [None for i in range(len(self.sim_plot_mode_list))]
        for i, mode in enumerate(self.sim_plot_mode_list):
            if mode in ['recon', 'recon_random']:
                pass
            else:
                line_list[i] = ax.errorbar(
                    t, self.mu_dict[mode],
                    yerr=self.sigma_dict[mode], marker='o', lw=1, capsize=2,
                    label=self.sim_plot_legend_list[i], color=self.sim_plot_color_list[i], alpha=0.5
                )
        
        xmin, xmax = ax.get_xlim()

        t_refer = np.concatenate((np.array([self.step_list[0]-100]), t, np.array([self.step_list[-1]+100])),axis=0)
        for i,(mode,color) in enumerate(zip(self.sim_plot_mode_list, self.sim_plot_color_list)):
            if mode not in ['recon', 'recon_random']:
                pass
            else:
                line_list[i], = ax.plot(
                    t_refer, self.mu_dict[mode],
                    label=self.sim_plot_legend_list[i], linestyle='--', alpha=0.5, color=self.sim_plot_color_list[i]
                )
                ax.fill_between(
                    t_refer, self.mu_dict[mode]+self.sigma_dict[mode], self.mu_dict[mode]-self.sigma_dict[mode],
                    facecolor=self.sim_plot_color_list[i], alpha=0.15
                )
        
        # 3. set legend
        handles, labels = ax.get_legend_handles_labels()
        _hl = handles[0::2]+handles[1::2], labels[0::2]+labels[1::2]
        # lgd = plt.legend(loc="center left", bbox_to_anchor=(1.05, 0.5))
        lgd = plt.legend(*_hl, loc="lower center", bbox_to_anchor=(0.5, 1.02), ncol=2, title="Approach")
        # 4. set axis label
        ax.set_xlabel('Adaptation Steps', fontsize=12)
        ax.set_ylabel('Similarity', fontsize=12)
        plt.xticks(fontsize=12)
        plt.yticks(fontsize=12)

        # 5. set axis limit
        plt.xlim((xmin,xmax))

        plt.savefig(f"images/{self.corpus}/errorbar_plot{suffix}.png", format='png', bbox_extra_artists=(lgd,), bbox_inches='tight')
        print(f"images/{self.corpus}/errorbar_plot{suffix}.png")
        # plt.show()
        plt.close()
        from PIL import Image
        im = Image.open(f"images/{self.corpus}/errorbar_plot{suffix}.png")
        im.show()