Esempio n. 1
0
def run_log_regression():

    nb_in_sample = 100
    nb_out_of_sample = 100000
    nb_runs = 100
    nb_epochs = 0
    nb_Eout = 0
    lr = 0.01
    eps = 0.01

    for i in range(nb_runs):
        # generate random function
        l = randomline()
        f = target_random_function(l)
        # generate in sample data and out of sample data
        data_in_sample = data(nb_in_sample)
        data_out_of_sample = data(nb_out_of_sample)
        # create training set structure [[w0,w1,...],target_value]
        t_set_in = build_training_set_fmultipleparams(data_in_sample,f)
        t_set_out = build_training_set_fmultipleparams(data_out_of_sample,f)
        # run logistic regression in sample
        epochs,w = log_regression_sgd(t_set_in,eps,lr)
        # compute the out of sample error given the previously compute weights.
        e_out = log_regression_compute_Eout(t_set_out,w)

        print "Run: %s - epochs: %s"%(i, epochs)
        print "Eout: %s"%(e_out)

        nb_Eout += e_out
        nb_epochs += epochs

    print 'Number of runs:%s'%(nb_runs)
    print "Avg epochs: %s"%(nb_epochs / nb_runs*1.0)
    print "Avg Eout: %s"%(nb_Eout / nb_runs*1.0)
Esempio n. 2
0
def run_log_regression():

    nb_in_sample = 100
    nb_out_of_sample = 100000
    nb_runs = 100
    nb_epochs = 0
    nb_Eout = 0
    lr = 0.01
    eps = 0.01

    for i in range(nb_runs):
        # generate random function
        l = randomline()
        f = target_random_function(l)
        # generate in sample data and out of sample data
        data_in_sample = data(nb_in_sample)
        data_out_of_sample = data(nb_out_of_sample)
        # create training set structure [[w0,w1,...],target_value]
        t_set_in = build_training_set_fmultipleparams(data_in_sample, f)
        t_set_out = build_training_set_fmultipleparams(data_out_of_sample, f)
        # run logistic regression in sample
        epochs, w = log_regression_sgd(t_set_in, eps, lr)
        # compute the out of sample error given the previously compute weights.
        e_out = log_regression_compute_Eout(t_set_out, w)

        print "Run: %s - epochs: %s" % (i, epochs)
        print "Eout: %s" % (e_out)

        nb_Eout += e_out
        nb_epochs += epochs

    print 'Number of runs:%s' % (nb_runs)
    print "Avg epochs: %s" % (nb_epochs / nb_runs * 1.0)
    print "Avg Eout: %s" % (nb_Eout / nb_runs * 1.0)
Esempio n. 3
0
def run_linear_regression(N_samples, N_points):
    '''runs on N_samples and with N_points a linear regression
    computes Ein by average of the samples as well as Eout
    '''
    print 'running Linear Regression on %s samples' % str(N_samples)
    print 'Each sample has %s data points' % str(N_points)

    Ein_avg = []
    Eout_avg = []

    for i in range(N_samples):

        d = data(N_points)
        l = randomline()
        f = target_function(l)
        t_set = build_training_set(d, f)

        wlin, X, y = linear_regression(N_points, t_set)

        Ein = compute_Ein(wlin, X, y)
        Ein_avg.append(Ein)

        Eout = compute_Eout(wlin, f, N_points)
        Eout_avg.append(Eout)

    print_avg('Ein', Ein_avg)
    print_avg('Eout', Eout_avg)
Esempio n. 4
0
def run_linear_regression(N_samples,N_points):
    '''runs on N_samples and with N_points a linear regression
    computes Ein by average of the samples as well as Eout
    '''
    print 'running Linear Regression on %s samples' %str(N_samples)
    print 'Each sample has %s data points' %str(N_points)

    Ein_avg = []
    Eout_avg = []

    for i in range(N_samples):

        d = data(N_points)
        l = randomline()
        f = target_function(l)
        t_set = build_training_set(d,f)

        wlin,X,y = linear_regression(N_points,t_set)

        Ein = compute_Ein(wlin,X,y)
        Ein_avg.append(Ein)

        Eout = compute_Eout(wlin,f,N_points)
        Eout_avg.append(Eout)
        
    print_avg('Ein',Ein_avg)
    print_avg('Eout',Eout_avg)
def get_current_pos():
    savefile = open('current_pos.txt', 'w')
    data = inst.query('SOURce:SCENario:LOG?')
    savefile.write(data)
    savefile.close()
    pos = (tools.data('current_pos.txt'))
    return pos

#print(get_current_pos())
#print(inst.query('SOURce:SCENario:LOG?'))

#done = tools.data('spectracom_data.txt')
#print(done)
Esempio n. 6
0
def generate_t_set(N, f=None):
    '''
    Generate a training set of N = 1000 points on X = [1; 1] * [1; 1] with uniform
    probability of picking each x that belongs X . Generate simulated noise by 
    fipping the sign of a random 10% subset of the generated training set
    '''
    d = data(N)
    if f is None:
        f = lambda x: sign(x[0]**2 + x[1]**2 - 0.6)

    t_set = build_training_set_fmultipleparams(d, f)
    t_set = t_set_errorNoise(t_set, N / 10)

    return t_set, f
Esempio n. 7
0
def generate_t_set(N,f=None):
    '''
    Generate a training set of N = 1000 points on X = [1; 1] * [1; 1] with uniform
    probability of picking each x that belongs X . Generate simulated noise by 
    fipping the sign of a random 10% subset of the generated training set
    '''
    d = data(N)
    if f is None:
        f = lambda x: sign(x[0]**2 + x[1]**2 -0.6)
    
    t_set = build_training_set_fmultipleparams(d,f)
    t_set = t_set_errorNoise(t_set,N/10)
        
    return t_set,f
Esempio n. 8
0
def compute_Eout(wlin, f, N_points):
    'number of out-of-sample points misclassifed / total number of out-of-sample points'

    d = data(N_points)
    t_set = build_training_set(d, f)

    X_matrix = input_data_matrix(t_set)
    y_vector = target_vector(t_set)

    g_vector = dot(X_matrix, wlin)
    for i in range(len(g_vector)):
        g_vector[i] = sign(g_vector[i])

    vEout = g_vector - y_vector
    nEout = 0
    for i in range(len(vEout)):
        if vEout[i] != 0:
            nEout = nEout + 1
    Eout = nEout / (len(vEout) * 1.0)
    return Eout
Esempio n. 9
0
def compute_Eout(wlin,f,N_points):
    'number of out-of-sample points misclassifed / total number of out-of-sample points'
    
    d = data(N_points)
    t_set = build_training_set(d,f)
    
    X_matrix = input_data_matrix(t_set)
    y_vector = target_vector(t_set)
    
    g_vector = dot(X_matrix,wlin)
    for i in range(len(g_vector)):
        g_vector[i] = sign(g_vector[i])
    
    vEout = g_vector - y_vector
    nEout = 0
    for i in range(len(vEout)):
        if vEout[i]!=0:
            nEout = nEout + 1
    Eout = nEout/(len(vEout)*1.0)
    return Eout
Esempio n. 10
0
def run_lr_and_pla(N_samples, N_points):
    '''runs on N_samples and with N_points a linear regresion
    then from the weight vector runs PLA algorithm
    compute the average number of iterations of PLA with this w vector
    '''
    print 'running Linear Regression on %s samples' %N_samples
    print 'Each samples has %s data points' %N_points
    
    iteration_avg = []
    for i in range(N_samples):

        d = data(N_points)
        l = randomline()
        f = target_function(l)
        t_set = build_training_set(d,f)
        
        wlin,X,y = linear_regression(N_points,t_set)
        
        w_pla,iteration = PLA(N_points,wlin,f,t_set)
        iteration_avg.append(iteration)
    
    print_avg('Number of iterations',iteration_avg)
Esempio n. 11
0
def run_lr_and_pla(N_samples, N_points):
    '''runs on N_samples and with N_points a linear regresion
    then from the weight vector runs PLA algorithm
    compute the average number of iterations of PLA with this w vector
    '''
    print 'running Linear Regression on %s samples' % N_samples
    print 'Each samples has %s data points' % N_points

    iteration_avg = []
    for i in range(N_samples):

        d = data(N_points)
        l = randomline()
        f = target_function(l)
        t_set = build_training_set(d, f)

        wlin, X, y = linear_regression(N_points, t_set)

        w_pla, iteration = PLA(N_points, wlin, f, t_set)
        iteration_avg.append(iteration)

    print_avg('Number of iterations', iteration_avg)
Esempio n. 12
0
def run_PLA(N_samples, N_points):
    samples = []  # vector of 1 clasified, 0 misclassified
    iterations = []  #vector of iterations needed for each PLA
    b_misclassified = False
    diff = []  #vector of difference average between f and g

    for i in range(N_samples):
        # run PLA in sample
        d = data(N_points)
        l = randomline()
        f = target_function(l)
        t_set = build_training_set(d, f)
        w = [0, 0, 0]  #Start the PLA with the weight vector w being all zeros

        w, iteration = PLA(N_points, w, f, t_set)

        iterations.append(iteration)
        # check if points are classified or not
        for i in range(len(t_set)):
            point = t_set[i][0]
            s = h(w, point)
            yn = t_set[i][1]
            if yn != s:
                samples.append(0)
                b_misclassified = True
                break

        # check difference between f and g
        diff.append(evaluate_diff_f_g(f, w))
        if not b_misclassified: samples.append(1)

        b_misclassified = False

    print 'number of samples misclassified: %s ' % samples.count(0)
    print 'number of classified samples: %s ' % samples.count(1)
    print 'number of iteration avg: %s ' % (str(
        sum(iterations) / len(iterations) * 1.0))
    print 'average of difference in function g: %s' % (sum(diff) /
                                                       (len(diff) * 1.0))
Esempio n. 13
0
def run_PLA(N_samples,N_points):
    samples = []# vector of 1 clasified, 0 misclassified
    iterations = []#vector of iterations needed for each PLA
    b_misclassified = False
    diff = []#vector of difference average between f and g

    for i in range(N_samples):
        # run PLA in sample
        d = data(N_points)
        l = randomline()
        f = target_function(l)
        t_set = build_training_set(d,f)
        w = [0,0,0]

        w,iteration = PLA(N_points,w,f,t_set)

        iterations.append(iteration)
        # check if points are classified or not
        for i in range(len(t_set)):
            point = t_set[i][0]
            s = h(w,point)
            yn = t_set[i][1]
            if yn != s:
                samples.append(0)
                b_misclassified = True
                break

        # check difference between f and g
        diff.append(evaluate_diff_f_g(f,w))
        if not b_misclassified: samples.append(1)

        b_misclassified = False

    print 'number of samples misclassified: %s ' % samples.count(0)
    print 'number of classified samples: %s ' % samples.count(1)
    print 'number of iteration avg: %s ' % (str(sum(iterations)/len(iterations)*1.0))
    print 'average of difference in function g: %s' % ( sum(diff)/(len(diff)*1.0) )
Esempio n. 14
0
__author__ = 'tobie'

import tools, math
from matplotlib import pyplot as plt

# Open files we need
spec =open('spectracom_data.txt', 'r')
ublox = open('ublox_data.txt', 'r')

# take back information we need ie [time, Lat, Long, Alt]
speclist = tools.data('spectracom_data.txt')
ubloxlist = tools.data('ublox_data.txt')
print(speclist)
print(ubloxlist)

def synchronisation(speclist, ubloxlist):
    # to compare information sent and received, they must be synchronized
    new_spec =[]
    new_ublox = []
    for i in range(len(speclist)):
        for j in range(len(ubloxlist)):
            if speclist[i][0][0:6] == ubloxlist[j][0][0:6]:
                new_spec.append(speclist[i])
                new_ublox.append(ubloxlist[j])
    return (new_spec, new_ublox)

new_spec = synchronisation(speclist, ubloxlist)[0]
new_ublox = synchronisation(speclist, ubloxlist)[1]
print(new_spec)
print(new_ublox)
Esempio n. 15
0
def player(id):
    return data(models.Player.query.filter(models.Player.id == id).one())
Esempio n. 16
0
def match(id):
    m = models.Match.query.filter(models.Match.id == id).one()
    if request.method == 'GET':
        return data(m)
    if request.method == 'PUT':
        return modify_resource(m)
Esempio n. 17
0
def tournament(id):
    return data(models.Tournament.query.filter(models.Tournament.id == id).one())
Esempio n. 18
0
def run_pla_vs_svm(nbruns=1, N=10):
    solvers.options['show_progress'] = False

    d = []
    l = 0
    f = 0
    t_set = []
    y = []
    svm_vs_pla = []
    for i in range(nbruns):
        onBothSides = False
        while (not onBothSides):
            d = data(N)
            l = randomline()
            f = target_function(l)
            t_set = build_training_set(d, f)
            y = target_vector(t_set)
            if (1 in y) and (-1 in y):
                onBothSides = True
            else:
                onBothSides = False
        w = [0, 0, 0]
        w_pla, iteration = PLA(N, w, f, t_set)
        plaEout = evaluate_diff_f_g(f, w_pla)
        X_matrix = input_data_matrix(t_set)
        dimension = len(X_matrix[0])
        #identity matrix of size dim X dim matrix x,I,J,typecode double
        P = spmatrix(1, range(dimension), range(dimension), tc='d')
        #vector of zeros of size dim, typecode double
        q = matrix([0] * (dimension), tc='d')

        mat = []
        for t in t_set:
            y = t[1]
            temp = [x * -1.0 * y for x in t[0]]
            mat.append(temp)

        G = matrix(mat, tc='d')
        G = G.trans()
        # vectors of -1 of size t_set
        h = matrix([-1] * len(t_set), tc='d')
        #http://abel.ee.ucla.edu/cvxopt/examples/tutorial/qp.html
        qp_sln = solvers.qp(P, q, G, h)
        wsvm = list(qp_sln['x'])
        # number of support vectors you can get at each run
        count_sv = 0
        for t in t_set:
            wsvm = array(wsvm)
            x = array(t[0])
            y = t[1]
            res = fabs(y * dot(wsvm, x) - 1)
            if res < 0.001:
                count_sv = count_sv + 1
        #print count_sv
        # Eout of svm
        svmEout = computeEout_svm(f, wsvm)
        #print 'svmEout: %s'%svmEout
        if (svmEout < plaEout):
            svm_vs_pla.append([True, count_sv])
        else:
            svm_vs_pla.append([False, count_sv])

    print "svm win pla %f" % (len(filter(lambda a: a[0] is True, svm_vs_pla)) *
                              1.0 / N)
    percent_svm_won = len([r[0] for r in svm_vs_pla if r[0] is True
                           ]) * 1.0 / len(svm_vs_pla)
    print "question 9: svm beat pla %f percent of the time" % (
        percent_svm_won * 100)

    avg_sv = sum([a[1] for a in svm_vs_pla]) * 1.0 / len(svm_vs_pla)
    print "avg sv:", avg_sv
Esempio n. 19
0
def run_pla_vs_svm(nbruns = 1, N = 10):
    solvers.options['show_progress'] = False
    
    d = []
    l = 0
    f = 0
    t_set = []
    y = []
    svm_vs_pla = []
    for i in range(nbruns):
        onBothSides = False
        while(not onBothSides):
            d = data(N)
            l = randomline()
            f = target_function(l)
            t_set = build_training_set(d,f)
            y = target_vector(t_set)
            if (1 in y) and (-1 in y):
                onBothSides = True
            else:
                onBothSides = False
        w = [0,0,0]
        w_pla,iteration = PLA(N,w,f,t_set)
        plaEout = evaluate_diff_f_g(f,w_pla)
        X_matrix = input_data_matrix(t_set)
        dimension = len(X_matrix[0])
        #identity matrix of size dim X dim matrix x,I,J,typecode double
        P = spmatrix(1, range(dimension), range(dimension), tc='d')
        #vector of zeros of size dim, typecode double
        q = matrix([0]*(dimension), tc='d')

        mat = []
        for t in t_set:
            y = t[1]
            temp = [x * -1.0*y for x in t[0]]
            mat.append(temp) 
        
        G = matrix(mat, tc='d')
        G = G.trans()
        # vectors of -1 of size t_set
        h = matrix([-1]*len(t_set), tc='d')
        #http://abel.ee.ucla.edu/cvxopt/examples/tutorial/qp.html
        qp_sln = solvers.qp(P, q, G, h)
        wsvm = list(qp_sln['x'])
        # number of support vectors you can get at each run
        count_sv = 0
        for t in t_set:
            wsvm = array(wsvm)
            x = array(t[0])
            y = t[1]
            res = fabs(y*dot(wsvm,x)-1)
            if res < 0.001:
                count_sv = count_sv + 1
        #print count_sv
        # Eout of svm
        svmEout = computeEout_svm(f,wsvm)
        #print 'svmEout: %s'%svmEout
        if(svmEout < plaEout):
            svm_vs_pla.append([True,count_sv])
        else:
            svm_vs_pla.append([False,count_sv])

    print "svm win pla %f" % (len(filter(lambda a: a[0] is True, svm_vs_pla))*1.0/N) 
    percent_svm_won = len([r[0] for r in svm_vs_pla if r[0] is True])*1.0/len(svm_vs_pla)
    print "question 9: svm beat pla %f percent of the time" % (percent_svm_won*100)

    avg_sv = sum([a[1] for a in svm_vs_pla])*1.0/len(svm_vs_pla) 
    print "avg sv:", avg_sv