예제 #1
0
def quick_le(seed, n_chains=1):
    # Specify synthetic dataset structure.
    cctypes = [
        'continuous', 'continuous', 'multinomial', 'multinomial', 'continuous'
    ]
    distargs = [None, None, dict(K=9), dict(K=7), None]
    cols_to_views = [0, 0, 0, 1, 1]
    separation = [0.6, 0.9]
    cluster_weights = [[.2, .3, .5], [.9, .1]]

    # Obtain the generated dataset and metadata/
    T, M_c, M_r = sdg.gen_data(cctypes,
                               N_ROWS,
                               cols_to_views,
                               cluster_weights,
                               separation,
                               seed=seed,
                               distargs=distargs,
                               return_structure=True)

    # Create, initialize, and analyze the engine.
    engine = LocalEngine()
    X_L, X_D = engine.initialize(M_c, M_r, T, seed, n_chains=n_chains)

    return T, M_r, M_c, X_L, X_D, engine
예제 #2
0
	def test_proper_set_up_all_continuous(self):
		T, M_c = sdg.gen_data(self.cctypes_all_contiuous,
			self.n_rows,
			self.cols_to_views_good,
			self.cluster_weights_good,
			self.separation_good,
			seed=0,
			distargs=None)

		assert(len(T) == self.n_rows)
		assert(len(T[0]) == len(self.cols_to_views_good))
예제 #3
0
	def test_proper_set_up_mixed(self):
		distargs = [ None, None, dict(K=5), None, dict(K=5)]
		T, M_c = sdg.gen_data(self.cctypes_mixed,
			self.n_rows,
			self.cols_to_views_good,
			self.cluster_weights_good,
			self.separation_good,
			seed=0,
			distargs=distargs)

		assert(len(T) == self.n_rows)
		assert(len(T[0]) == len(self.cols_to_views_good))
예제 #4
0
	def test_different_seeds_should_produce_the_different_data(self):
		distargs = [None]*5
		T1, M_c = sdg.gen_data(self.cctypes_all_contiuous,
			self.n_rows,
			self.cols_to_views_good,
			self.cluster_weights_good,
			self.separation_good,
			seed=0,
			distargs=distargs)

		T2, M_c = sdg.gen_data(self.cctypes_all_contiuous,
			self.n_rows,
			self.cols_to_views_good,
			self.cluster_weights_good,
			self.separation_good,
			seed=12345,
			distargs=distargs)

		A1 = numpy.array(T1)
		A2 = numpy.array(T2)
		
		assert not numpy.all(A1==A2)
예제 #5
0
def quick_le(seed, n_chains=1):
    # Specify synthetic dataset structure.
    cctypes = ['continuous', 'continuous', 'multinomial', 'multinomial',
        'continuous']
    distargs = [None, None, dict(K=9), dict(K=7), None]
    cols_to_views = [0, 0, 0, 1, 1]
    separation = [0.6, 0.9]
    cluster_weights = [[.2, .3, .5],[.9, .1]]

    # Obtain the generated dataset and metadata/
    T, M_c, M_r = sdg.gen_data(cctypes, N_ROWS, cols_to_views, cluster_weights,
        separation, seed=seed, distargs=distargs, return_structure=True)

    # Create, initialize, and analyze the engine.
    engine = LocalEngine(seed=seed)
    X_L, X_D = engine.initialize(M_c, M_r, T, n_chains=n_chains)

    return T, M_r, M_c, X_L, X_D, engine
예제 #6
0
def get_synthetic_data(n_sample, seed=438):
    cols_to_views = [
        0, 0, 0, 0, 0,
        1, 1, 1, 1,
        2, 2, 2,
        3,
        4
    ]
    colnames = [
        'm1', 'c1', 'm2', 'c2', 'm3',
        'm4', 'c3', 'c4', 'm5',
        'c5', 'c6', 'c7',
        'c8',
        'c9'
    ]
    cctypes = [
        'multinomial', 'continuous', 'multinomial', 'continuous', 'multinomial',
        'multinomial', 'continuous', 'continuous', 'multinomial',
        'continuous', 'continuous', 'continuous',
        'continuous',
        'continuous'
    ]
    distargs = [
        dict(K=9), None, dict(K=9), None, dict(K=7),
        dict(K=4), None, None, dict(K=9),
        None, None, None,
        None,
        None
    ]
    component_weights = [
        [.2, .3, .5],
        [.9, .1],
        [.4, .4, .2],
        [.8, .2],
        [.4, .5, .1]
    ]
    separation = [0.8, 0.9, 0.65, 0.7, 0.75]
    synthetic_data = sdg.gen_data(cctypes, n_sample, cols_to_views,
        component_weights, separation, seed, distargs=distargs)
    data = pd.DataFrame(synthetic_data[0])
    data.columns = colnames
    return df_to_table(data)
예제 #7
0
def get_synthetic_data(n_sample, seed=438):
    cols_to_views = [
        0, 0, 0, 0, 0,
        1, 1, 1, 1,
        2, 2, 2,
        3,
        4
    ]
    colnames = [
        'm1', 'c1', 'm2', 'c2', 'm3',
        'm4', 'c3', 'c4', 'm5',
        'c5', 'c6', 'c7',
        'c8',
        'c9'
    ]
    cctypes = [
        'multinomial', 'continuous', 'multinomial', 'continuous', 'multinomial',
        'multinomial', 'continuous', 'continuous', 'multinomial',
        'continuous', 'continuous', 'continuous',
        'continuous',
        'continuous'
    ]
    distargs = [
        dict(K=9), None, dict(K=9), None, dict(K=7),
        dict(K=4), None, None, dict(K=9),
        None, None, None,
        None,
        None
    ]
    component_weights = [
        [.2, .3, .5],
        [.9, .1],
        [.4, .4, .2],
        [.8, .2],
        [.4, .5, .1]
    ]
    separation = [0.8, 0.9, 0.65, 0.7, 0.75]
    synthetic_data = sdg.gen_data(cctypes, n_sample, cols_to_views,
        component_weights, separation, seed, distargs=distargs)
    data = pd.DataFrame(synthetic_data[0])
    data.columns = colnames
    return df_to_table(data)
def check_predictive_sample_improvement(component_model_type, seed=0, show_plot=True):
	""" Shows the error of predictive sample over iterations.
	"""

	num_transitions = 100
	num_samples = 10	
	num_clusters = 2
	separation = .9	# cluster separation
	N = 150
	
	random.seed(seed)
	get_next_seed = lambda : random.randrange(2147483647)

	# generate a single column of data from the component_model 
	cctype = component_model_type.cctype
	T, M_c, struc = sdg.gen_data([cctype], N, [0], [[.5,.5]], [separation], 
				seed=get_next_seed(), distargs=[distargs[cctype]], 
				return_structure=True)

	T_array = numpy.array(T)

	X = numpy.zeros((N,num_transitions))
	KL = numpy.zeros((num_samples, num_transitions))


	support = qtu.get_mixture_support(cctype, component_model_type, 
					struc['component_params'][0], nbins=1000, support=.995)
	true_log_pdf = qtu.get_mixture_pdf(support, component_model_type, 
					struc['component_params'][0],[.5,.5])

	for s in range(num_samples):
		# generate the state
		state = State.p_State(M_c, T, SEED=get_next_seed())

		for i in range(num_transitions):
			# transition
			state.transition()

			# get partitions and generate a predictive column
			X_L = state.get_X_L()
			X_D = state.get_X_D()

			T_inf = sdg.predictive_columns(M_c, X_L, X_D, [0], 
					seed=get_next_seed())

			if cctype == 'multinomial':
				K = distargs[cctype]['K']
				weights = numpy.zeros(numpy.array(K))
				for params in struc['component_params'][0]:
					weights += numpy.array(params['weights'])*(1.0/num_clusters)
				weights *= float(N)
				inf_hist = qtu.bincount(T_inf, bins=list(range(K)))
				err, _ = stats.power_divergence(inf_hist, weights, lambda_='pearson')
				err = numpy.ones(N)*err
			else:
				err = (T_array-T_inf)**2.0

			KL[s,i] = qtu.KL_divergence(component_model_type, 
						struc['component_params'][0], [.5,.5], M_c, X_L, X_D,
						true_log_pdf=true_log_pdf, support=support)

			for j in range(N):
				X[j,i] += err[j]

	X /= num_samples

	# mean and standard error
	X_mean = numpy.mean(X,axis=0)
	X_err = numpy.std(X,axis=0)/float(num_samples)**.5

	KL_mean = numpy.mean(KL, axis=0)
	KL_err = numpy.std(KL, axis=0)/float(num_samples)**.5

	if show_plot:
		pylab.subplot(1,2,1)
		pylab.errorbar(list(range(num_transitions)), X_mean, yerr=X_err)
		pylab.xlabel('iteration')
		pylab.ylabel('error across each data point')
		pylab.title('error of predictive sample over iterations, N=%i' % N)

		pylab.subplot(1,2,2)
		pylab.errorbar(list(range(num_transitions)), KL_mean, yerr=KL_err)
		pylab.xlabel('iteration')
		pylab.ylabel('KL divergence')
		pylab.title('KL divergence, N=%i' % N)

		pylab.show()

	# error should decrease over time
	return X_mean[0] > X_mean[-1] and KL_mean[0] > KL_mean[-1]
def test_kl_divergence_as_a_function_of_N_and_transitions():

    n_clusters = 3
    n_chains = 8
    do_times = 4

    # N_list = [25, 50, 100, 250, 500, 1000, 2000]
    N_list = [25, 50, 100, 175, 250, 400, 500]

    # max_transitions = 500
    max_transitions = 500
    transition_interval = 50
    t_iterations = max_transitions / transition_interval

    cctype = "continuous"
    cluster_weights = [1.0 / float(n_clusters)] * n_clusters
    separation = 0.5

    get_next_seed = lambda: random.randrange(2147483647)

    # data grid
    KLD = numpy.zeros((len(N_list), t_iterations + 1))

    for _ in range(do_times):
        for n in range(len(N_list)):
            N = N_list[n]
            T, M_c, struc = sdg.gen_data(
                [cctype],
                N,
                [0],
                [cluster_weights],
                [separation],
                seed=get_next_seed(),
                distargs=[None],
                return_structure=True,
            )

            M_r = du.gen_M_r_from_T(T)

            # precompute the support and pdf to speed up calculation of KL divergence
            support = qtu.get_mixture_support(
                cctype, ccmext.p_ContinuousComponentModel, struc["component_params"][0], nbins=1000, support=0.995
            )
            true_log_pdf = qtu.get_mixture_pdf(
                support, ccmext.p_ContinuousComponentModel, struc["component_params"][0], cluster_weights
            )

            # intialize a multiprocessing engine
            mstate = mpe.MultiprocessingEngine(cpu_count=8)
            X_L_list, X_D_list = mstate.initialize(M_c, M_r, T, n_chains=n_chains)

            # kl_divergences
            klds = numpy.zeros(len(X_L_list))

            for i in range(len(X_L_list)):
                X_L = X_L_list[i]
                X_D = X_D_list[i]
                KLD[n, 0] += qtu.KL_divergence(
                    ccmext.p_ContinuousComponentModel,
                    struc["component_params"][0],
                    cluster_weights,
                    M_c,
                    X_L,
                    X_D,
                    n_samples=1000,
                    support=support,
                    true_log_pdf=true_log_pdf,
                )

                # run transition_interval then take a reading. Rinse and repeat.
            for t in range(t_iterations):
                X_L_list, X_D_list = mstate.analyze(M_c, T, X_L_list, X_D_list, n_steps=transition_interval)

                for i in range(len(X_L_list)):
                    X_L = X_L_list[i]
                    X_D = X_D_list[i]
                    KLD[n, t + 1] += qtu.KL_divergence(
                        ccmext.p_ContinuousComponentModel,
                        struc["component_params"][0],
                        cluster_weights,
                        M_c,
                        X_L,
                        X_D,
                        n_samples=1000,
                        support=support,
                        true_log_pdf=true_log_pdf,
                    )

    KLD /= float(n_chains * do_times)

    pylab.subplot(1, 3, 1)
    pylab.contourf(list(range(0, max_transitions + 1, transition_interval)), N_list, KLD)
    pylab.title("KL divergence")
    pylab.ylabel("N")
    pylab.xlabel("# transitions")

    pylab.subplot(1, 3, 2)
    m_N = numpy.mean(KLD, axis=1)
    e_N = numpy.std(KLD, axis=1) / float(KLD.shape[1]) ** -0.5
    pylab.errorbar(N_list, m_N, yerr=e_N)
    pylab.title("KL divergence by N")
    pylab.xlabel("N")
    pylab.ylabel("KL divergence")

    pylab.subplot(1, 3, 3)
    m_t = numpy.mean(KLD, axis=0)
    e_t = numpy.std(KLD, axis=0) / float(KLD.shape[0]) ** -0.5
    pylab.errorbar(list(range(0, max_transitions + 1, transition_interval)), m_t, yerr=e_t)
    pylab.title("KL divergence by transitions")
    pylab.xlabel("trasition")
    pylab.ylabel("KL divergence")

    pylab.show()

    return KLD
def test_kl_divergence_as_a_function_of_N_and_transitions():

	n_clusters = 3
	n_chains = 8
	do_times = 4

	# N_list = [25, 50, 100, 250, 500, 1000, 2000]
	N_list = [25, 50, 100, 175, 250, 400, 500]

	# max_transitions = 500
	max_transitions = 500
	transition_interval = 50
	t_iterations = max_transitions/transition_interval

	cctype = 'continuous'
	cluster_weights = [1.0/float(n_clusters)]*n_clusters
	separation = .5

	get_next_seed = lambda : random.randrange(2147483647)

	# data grid
	KLD = numpy.zeros((len(N_list), t_iterations+1))

	for _ in range(do_times):
		for n in range(len(N_list)):
			N = N_list[n]
			T, M_c, struc = sdg.gen_data([cctype], N, [0], [cluster_weights], 
							[separation], seed=get_next_seed(), distargs=[None],
							return_structure=True)

			M_r = du.gen_M_r_from_T(T)

			# precompute the support and pdf to speed up calculation of KL divergence
			support = qtu.get_mixture_support(cctype, 
						ccmext.p_ContinuousComponentModel, 
						struc['component_params'][0], nbins=1000, support=.995)
			true_log_pdf = qtu.get_mixture_pdf(support,
						ccmext.p_ContinuousComponentModel, 
						struc['component_params'][0],cluster_weights)

			# intialize a multiprocessing engine
			mstate = mpe.MultiprocessingEngine(cpu_count=8)
			X_L_list, X_D_list = mstate.initialize(M_c, M_r, T, n_chains=n_chains)

			# kl_divergences
			klds = numpy.zeros(len(X_L_list))

			for i in range(len(X_L_list)):
				X_L = X_L_list[i]
				X_D = X_D_list[i]
				KLD[n,0] += qtu.KL_divergence(ccmext.p_ContinuousComponentModel,
						struc['component_params'][0], cluster_weights, M_c, 
						X_L, X_D, n_samples=1000, support=support, 
						true_log_pdf=true_log_pdf)


			# run transition_interval then take a reading. Rinse and repeat.
			for t in range( t_iterations ):
				X_L_list, X_D_list = mstate.analyze(M_c, T, X_L_list, X_D_list,
							n_steps=transition_interval)

				for i in range(len(X_L_list)):
					X_L = X_L_list[i]
					X_D = X_D_list[i]
					KLD[n,t+1] += qtu.KL_divergence(ccmext.p_ContinuousComponentModel,
							struc['component_params'][0], cluster_weights, M_c, 
							X_L, X_D, n_samples=1000, support=support, 
							true_log_pdf=true_log_pdf)


	KLD /= float(n_chains*do_times)

	pylab.subplot(1,3,1)
	pylab.contourf(list(range(0,max_transitions+1,transition_interval), N_list, KLD))
	pylab.title('KL divergence')
	pylab.ylabel('N')
	pylab.xlabel('# transitions')


	pylab.subplot(1,3,2)
	m_N = numpy.mean(KLD,axis=1)
	e_N = numpy.std(KLD,axis=1)/float(KLD.shape[1])**-.5
	pylab.errorbar(N_list,  m_N, yerr=e_N)
	pylab.title('KL divergence by N')
	pylab.xlabel('N')
	pylab.ylabel('KL divergence')

	pylab.subplot(1,3,3)
	m_t = numpy.mean(KLD,axis=0)
	e_t = numpy.std(KLD,axis=0)/float(KLD.shape[0])**-.5
	pylab.errorbar(list(range(0,max_transitions+1,transition_interval), m_t, yerr=e_t))
	pylab.title('KL divergence by transitions')
	pylab.xlabel('trasition')
	pylab.ylabel('KL divergence')

	pylab.show()

	return KLD
def check_one_feature_mixture(component_model_type, num_clusters=3, show_plot=False, seed=None):
    """

    """
    random.seed(seed)

    N = 300
    separation = .9
    
    get_next_seed = lambda : random.randrange(2147483647)

    cluster_weights = [[1.0/float(num_clusters)]*num_clusters]

    cctype = component_model_type.cctype
    T, M_c, structure = sdg.gen_data([cctype], N, [0], cluster_weights,
                        [separation], seed=get_next_seed(),
                        distargs=[distargs[cctype]],
                        return_structure=True)


    T_list = list(T)
    T = numpy.array(T)
    
    # pdb.set_trace()    
    # create a crosscat state 
    M_c = du.gen_M_c_from_T(T_list, cctypes=[cctype])
    
    state = State.p_State(M_c, T_list)

    # Get support over all component models
    discrete_support = qtu.get_mixture_support(cctype, component_model_type,
                         structure['component_params'][0], nbins=250)
    
    # calculate simple predictive probability for each point
    Q = [(N,0,x) for x in discrete_support]

    # transitions
    state.transition(n_steps=200)

    # get the sample
    X_L = state.get_X_L()
    X_D = state.get_X_D()
    
    # generate samples
    # kstest has doesn't compute the same answer with row and column vectors
    # so we flatten this column vector into a row vector.
    predictive_samples = sdg.predictive_columns(M_c, X_L, X_D, [0],
                            seed=get_next_seed()).flatten(1)
    

    probabilities = su.simple_predictive_probability(M_c, X_L, X_D, []*len(Q), Q)
    
    # get histogram. Different behavior for discrete and continuous types. For some reason
    # the normed property isn't normalizing the multinomial histogram to 1.
    # T = T[:,0]
    if is_discrete[component_model_type.model_type]:
        bins = list(range(len(discrete_support)))
        T_hist = numpy.array(qtu.bincount(T, bins=bins))
        S_hist = numpy.array(qtu.bincount(predictive_samples, bins=bins))
        T_hist = T_hist/float(numpy.sum(T_hist))
        S_hist = S_hist/float(numpy.sum(S_hist))
        edges = numpy.array(discrete_support,dtype=float)
    else:
        T_hist, edges = numpy.histogram(T, bins=min(50,len(discrete_support)), normed=True)
        S_hist, _ =  numpy.histogram(predictive_samples, bins=edges, normed=True)
        edges = edges[0:-1]

    # Goodness-of-fit-tests
    if not is_discrete[component_model_type.model_type]:
        # do a KS tests if the distribution in continuous
        # cdf = lambda x: component_model_type.cdf(x, model_parameters)
        # stat, p = stats.kstest(predictive_samples, cdf)   # 1-sample test
        stat, p = stats.ks_2samp(predictive_samples, T[:,0]) # 2-sample test
        test_str = "KS"
    else:
        # Cressie-Read power divergence statistic and goodness of fit test.
        # This function gives a lot of flexibility in the method <lambda_> used.
        freq_obs = S_hist*N
        freq_exp = numpy.exp(probabilities)*N
        stat, p = stats.power_divergence(freq_obs, freq_exp, lambda_='pearson')
        test_str = "Chi-square"
    
    if show_plot:
        pylab.clf()
        lpdf = qtu.get_mixture_pdf(discrete_support, component_model_type, 
                structure['component_params'][0], [1.0/num_clusters]*num_clusters)
        pylab.axes([0.1, 0.1, .8, .7])
        # bin widths
        width = (numpy.max(edges)-numpy.min(edges))/len(edges)
        pylab.bar(edges, T_hist, color='blue', alpha=.5, width=width, label='Original data', zorder=1)
        pylab.bar(edges, S_hist, color='red', alpha=.5, width=width, label='Predictive samples', zorder=2)

        # plot actual pdf of support given data params
        pylab.scatter(discrete_support, 
            numpy.exp(lpdf), 
            c="blue", 
            edgecolor="none",
            s=100, 
            label="true pdf", 
            alpha=1,
            zorder=3)
                
        # plot predictive probability of support points
        pylab.scatter(discrete_support, 
            numpy.exp(probabilities), 
            c="red", 
            edgecolor="none",
            s=100, 
            label="predictive probability", 
            alpha=1,
            zorder=4)
            
        pylab.legend()

        ylimits = pylab.gca().get_ylim()
        pylab.ylim([0,ylimits[1]])

        title_string = "%i samples drawn from %i %s components: \ninference after 200 crosscat transitions\n%s test: p = %f" \
            % (N, num_clusters, component_model_type.cctype, test_str, round(p,4))

        pylab.title(title_string, fontsize=12)

        filename = component_model_type.model_type + "_mixtrue.png"
        pylab.savefig(filename)
        pylab.close()

    return p
예제 #12
0
def check_one_feature_mixture(component_model_type,
                              num_clusters=3,
                              show_plot=False,
                              seed=None):
    """

    """
    random.seed(seed)

    N = 300
    separation = .9

    get_next_seed = lambda: random.randrange(2147483647)

    cluster_weights = [[1.0 / float(num_clusters)] * num_clusters]

    cctype = component_model_type.cctype
    T, M_c, structure = sdg.gen_data([cctype],
                                     N, [0],
                                     cluster_weights, [separation],
                                     seed=get_next_seed(),
                                     distargs=[distargs[cctype]],
                                     return_structure=True)

    T_list = list(T)
    T = numpy.array(T)

    # pdb.set_trace()
    # create a crosscat state
    M_c = du.gen_M_c_from_T(T_list, cctypes=[cctype])

    state = State.p_State(M_c, T_list)

    # Get support over all component models
    discrete_support = qtu.get_mixture_support(
        cctype,
        component_model_type,
        structure['component_params'][0],
        nbins=250)

    # calculate simple predictive probability for each point
    Q = [(N, 0, x) for x in discrete_support]

    # transitions
    state.transition(n_steps=200)

    # get the sample
    X_L = state.get_X_L()
    X_D = state.get_X_D()

    # generate samples
    # kstest has doesn't compute the same answer with row and column vectors
    # so we flatten this column vector into a row vector.
    predictive_samples = sdg.predictive_columns(
        M_c, X_L, X_D, [0], seed=get_next_seed()).flatten(1)

    probabilities = su.simple_predictive_probability(M_c, X_L, X_D,
                                                     [] * len(Q), Q)

    # get histogram. Different behavior for discrete and continuous types. For some reason
    # the normed property isn't normalizing the multinomial histogram to 1.
    # T = T[:,0]
    if is_discrete[component_model_type.model_type]:
        bins = list(range(len(discrete_support)))
        T_hist = numpy.array(qtu.bincount(T, bins=bins))
        S_hist = numpy.array(qtu.bincount(predictive_samples, bins=bins))
        T_hist = T_hist / float(numpy.sum(T_hist))
        S_hist = S_hist / float(numpy.sum(S_hist))
        edges = numpy.array(discrete_support, dtype=float)
    else:
        T_hist, edges = numpy.histogram(T,
                                        bins=min(50, len(discrete_support)),
                                        normed=True)
        S_hist, _ = numpy.histogram(predictive_samples,
                                    bins=edges,
                                    normed=True)
        edges = edges[0:-1]

    # Goodness-of-fit-tests
    if not is_discrete[component_model_type.model_type]:
        # do a KS tests if the distribution in continuous
        # cdf = lambda x: component_model_type.cdf(x, model_parameters)
        # stat, p = stats.kstest(predictive_samples, cdf)   # 1-sample test
        stat, p = stats.ks_2samp(predictive_samples, T[:, 0])  # 2-sample test
        test_str = "KS"
    else:
        # Cressie-Read power divergence statistic and goodness of fit test.
        # This function gives a lot of flexibility in the method <lambda_> used.
        freq_obs = S_hist * N
        freq_exp = numpy.exp(probabilities) * N
        stat, p = stats.power_divergence(freq_obs, freq_exp, lambda_='pearson')
        test_str = "Chi-square"

    if show_plot:
        pylab.clf()
        lpdf = qtu.get_mixture_pdf(discrete_support, component_model_type,
                                   structure['component_params'][0],
                                   [1.0 / num_clusters] * num_clusters)
        pylab.axes([0.1, 0.1, .8, .7])
        # bin widths
        width = (numpy.max(edges) - numpy.min(edges)) / len(edges)
        pylab.bar(edges,
                  T_hist,
                  color='blue',
                  alpha=.5,
                  width=width,
                  label='Original data',
                  zorder=1)
        pylab.bar(edges,
                  S_hist,
                  color='red',
                  alpha=.5,
                  width=width,
                  label='Predictive samples',
                  zorder=2)

        # plot actual pdf of support given data params
        pylab.scatter(discrete_support,
                      numpy.exp(lpdf),
                      c="blue",
                      edgecolor="none",
                      s=100,
                      label="true pdf",
                      alpha=1,
                      zorder=3)

        # plot predictive probability of support points
        pylab.scatter(discrete_support,
                      numpy.exp(probabilities),
                      c="red",
                      edgecolor="none",
                      s=100,
                      label="predictive probability",
                      alpha=1,
                      zorder=4)

        pylab.legend()

        ylimits = pylab.gca().get_ylim()
        pylab.ylim([0, ylimits[1]])

        title_string = "%i samples drawn from %i %s components: \ninference after 200 crosscat transitions\n%s test: p = %f" \
            % (N, num_clusters, component_model_type.cctype, test_str, round(p,4))

        pylab.title(title_string, fontsize=12)

        filename = component_model_type.model_type + "_mixtrue.png"
        pylab.savefig(filename)
        pylab.close()

    return p