Python EuclideanDistance.init Examples

Example #1

def converter_multidimensionalscaling_modular(data):
    try:
        from shogun.Features import RealFeatures
        from shogun.Converter import MultidimensionalScaling
        from shogun.Distance import EuclideanDistance

        features = RealFeatures(data)

        distance_before = EuclideanDistance()
        distance_before.init(features, features)

        converter = MultidimensionalScaling()
        converter.set_target_dim(2)
        converter.set_landmark(False)
        embedding = converter.apply(features)

        distance_after = EuclideanDistance()
        distance_after.init(embedding, embedding)

        distance_matrix_after = distance_after.get_distance_matrix()
        distance_matrix_before = distance_before.get_distance_matrix()

        return numpy.linalg.norm(distance_matrix_after - distance_matrix_before
                                 ) / numpy.linalg.norm(distance_matrix_before)
    except ImportError:
        print('No Eigen3 available')

Example #2

File: converter_multidimensionalscaling_modular.py Project: Argram/shogun

def converter_multidimensionalscaling_modular (data):
	try:
		from shogun.Features import RealFeatures
		from shogun.Converter import MultidimensionalScaling
		from shogun.Distance import EuclideanDistance
		
		features = RealFeatures(data)
			
		distance_before = EuclideanDistance()
		distance_before.init(features,features)

		converter = MultidimensionalScaling()
		converter.set_target_dim(2)
		converter.set_landmark(False)
		embedding = converter.apply(features)

		distance_after = EuclideanDistance()
		distance_after.init(embedding,embedding)

		distance_matrix_after = distance_after.get_distance_matrix()
		distance_matrix_before = distance_before.get_distance_matrix()

		return numpy.linalg.norm(distance_matrix_after-distance_matrix_before)/numpy.linalg.norm(distance_matrix_before) < 1e-6
	except ImportError:
		print('No Eigen3 available')

Example #3

File: distance_director_euclidian_modular.py Project: pluskid/shogun

def distance_director_euclidean_modular(fm_train_real=traindat, fm_test_real=testdat, scale=1.2):

    from shogun.Distance import EuclideanDistance
    from modshogun import Time

    feats_train = RealFeatures(fm_train_real)
    feats_train.io.set_loglevel(0)
    feats_train.parallel.set_num_threads(1)
    feats_test = RealFeatures(fm_test_real)

    distance = EuclideanDistance()
    distance.init(feats_train, feats_test)

    ddistance = DirectorEuclideanDistance()
    ddistance.init(feats_train, feats_test)

    print "dm_train"
    t = Time()
    dm_train = distance.get_distance_matrix()
    t1 = t.cur_time_diff(True)

    print "ddm_train"
    t = Time()
    ddm_train = ddistance.get_distance_matrix()
    t2 = t.cur_time_diff(True)

    print "dm_train", dm_train
    print "ddm_train", ddm_train

    return dm_train, ddm_train

Example #4

def distance_director_euclidean_modular(fm_train_real=traindat,
                                        fm_test_real=testdat,
                                        scale=1.2):

    from shogun.Distance import EuclideanDistance
    from modshogun import Time

    feats_train = RealFeatures(fm_train_real)
    feats_train.io.set_loglevel(0)
    feats_train.parallel.set_num_threads(1)
    feats_test = RealFeatures(fm_test_real)

    distance = EuclideanDistance()
    distance.init(feats_train, feats_test)

    ddistance = DirectorEuclideanDistance()
    ddistance.init(feats_train, feats_test)

    print "dm_train"
    t = Time()
    dm_train = distance.get_distance_matrix()
    t1 = t.cur_time_diff(True)

    print "ddm_train"
    t = Time()
    ddm_train = ddistance.get_distance_matrix()
    t2 = t.cur_time_diff(True)

    print "dm_train", dm_train
    print "ddm_train", ddm_train

    return dm_train, ddm_train

Example #5

File: distance_euclidian_modular.py Project: AlexBinder/shogun

def distance_euclidean_modular (fm_train_real=traindat,fm_test_real=testdat):

	from shogun.Features import RealFeatures
	from shogun.Distance import EuclideanDistance

	feats_train=RealFeatures(fm_train_real)
	feats_test=RealFeatures(fm_test_real)

	distance=EuclideanDistance(feats_train, feats_train)

	dm_train=distance.get_distance_matrix()
	distance.init(feats_train, feats_test)
	dm_test=distance.get_distance_matrix()

	return distance,dm_train,dm_test

Example #6

File: distance_euclidian_modular.py Project: ratschlab/shogun

def distance_euclidean_modular(fm_train_real=traindat, fm_test_real=testdat):

    from shogun.Features import RealFeatures
    from shogun.Distance import EuclideanDistance

    feats_train = RealFeatures(fm_train_real)
    feats_test = RealFeatures(fm_test_real)

    distance = EuclideanDistance(feats_train, feats_train)

    dm_train = distance.get_distance_matrix()
    distance.init(feats_train, feats_test)
    dm_test = distance.get_distance_matrix()

    return distance, dm_train, dm_test

Example #7

File: distance_director_euclidean_modular.py Project: monalisag/shogun

def distance_director_euclidean_modular(fm_train_real=traindat,
                                        fm_test_real=testdat,
                                        scale=1.2):
    try:
        from shogun.Distance import DirectorDistance
    except ImportError:
        print("recompile shogun with --enable-swig-directors")
        return

    class DirectorEuclideanDistance(DirectorDistance):
        def __init__(self):
            DirectorDistance.__init__(self, True)

        def distance_function(self, idx_a, idx_b):
            seq1 = self.get_lhs().get_feature_vector(idx_a)
            seq2 = self.get_rhs().get_feature_vector(idx_b)
            return numpy.linalg.norm(seq1 - seq2)

    from shogun.Distance import EuclideanDistance
    from modshogun import Time

    feats_train = RealFeatures(fm_train_real)
    #feats_train.io.set_loglevel(MSG_DEBUG)
    feats_train.parallel.set_num_threads(1)
    feats_test = RealFeatures(fm_test_real)

    distance = EuclideanDistance()
    distance.init(feats_train, feats_test)

    ddistance = DirectorEuclideanDistance()
    ddistance.init(feats_train, feats_test)

    #print  "dm_train"
    t = Time()
    dm_train = distance.get_distance_matrix()
    #t1=t.cur_time_diff(True)

    #print  "ddm_train"
    t = Time()
    ddm_train = ddistance.get_distance_matrix()
    #t2=t.cur_time_diff(True)

    #print "dm_train", dm_train
    #print "ddm_train", ddm_train

    return dm_train, ddm_train

Example #8

File: distance_director_euclidean_modular.py Project: changguanghua/shogun

def distance_director_euclidean_modular (fm_train_real=traindat,fm_test_real=testdat,scale=1.2):
	try:
		from shogun.Distance import DirectorDistance
	except ImportError:
		print "recompile shogun with --enable-swig-directors"
		return

	class DirectorEuclideanDistance(DirectorDistance):
		def __init__(self):
			DirectorDistance.__init__(self, True)
		def distance_function(self, idx_a, idx_b):
			seq1 = self.get_lhs().get_feature_vector(idx_a)
			seq2 = self.get_rhs().get_feature_vector(idx_b)
			return numpy.linalg.norm(seq1-seq2)

	from shogun.Distance import EuclideanDistance
	from modshogun import Time

	feats_train=RealFeatures(fm_train_real)
	feats_train.io.set_loglevel(0)
	feats_train.parallel.set_num_threads(1)
	feats_test=RealFeatures(fm_test_real)

	distance=EuclideanDistance()
	distance.init(feats_train, feats_test)

	ddistance=DirectorEuclideanDistance()
	ddistance.init(feats_train, feats_test)

	print  "dm_train"
	t=Time()
	dm_train=distance.get_distance_matrix()
	t1=t.cur_time_diff(True)

	print  "ddm_train"
	t=Time()
	ddm_train=ddistance.get_distance_matrix()
	t2=t.cur_time_diff(True)	

	print "dm_train", dm_train
	print "ddm_train", ddm_train

	return dm_train, ddm_train