Пример #1
0
def main():
    import time
    start_time = time.time()
    for seed in range(10):
        random.seed(seed)
        stabiter = 10000
        runiter = 1000
        grn = GRN(delta=1)

        #grn.read_genome("moo.dat")
        grn.build_genes()
        grn.add_extra("EXTRA_sineval", 0.0, [0] * 32)
        grn.precalc_matrix()
        grn.regulate_matrix(stabiter)

        onff = 0
        for i in range(0, 50):
            if i % 10 == 0:
                if onff == 1:
                    onff = 0
                else:
                    onff = 1

            inputval = onff
            extra_vals = {'sineval': inputval}
            grn.set_extras(extra_vals)
            grn.regulate_matrix(runiter)

        for conc in grn.conc_list:
            print conc[-1]
        filename = "conc" + str(seed)
        graph.plot_2d(grn.conc_list, filename)
    print "took", str(time.time() - start_time)
Пример #2
0
def multicore():
    delta = 20
    #set up the evo strategy
    best_list, mut_list = [], []
    evo = popstrat.Evostrategy(5000, 50)
    children = evo.iterate(evo.pop)

    nodes = ("*",)
    job_server = pp.Server(8, ppservers=nodes)
    print "Starting pp with", job_server.get_ncpus(), "workers"

    start_time = time.time()

    for i in range(50):
        run_time = time.time()
        jobs = [(child, job_server.submit(run_grn, 
                                          (child['genome'], 
                                           delta),
                                           (),
                                           ("grn","numpy","math")))
                                           for child in children]
        for child, result in jobs:
            results, conclist = result()
            bestidx = results.index(max(results))
            child['fitness'] = results[bestidx]

        #plotting the best with colors
        children = evo.iterate(children)
        bestgenome = evo.pop[-1]['genome']
        bestresult, conclist = run_grn(bestgenome, delta)
        bestidx = bestresult.index(max(bestresult))
        filename = "best_gen_"+str("%03d" % i)
        print filename

        colors = []
        simplist = []
        for idx, result in enumerate(bestresult):
            if idx == len(bestresult)-1:
                simplist.append(conclist[idx])
                colors.append('k')
            elif idx == bestidx:
                colors.append('g')
                simplist.append(conclist[idx])
            # elif result == 0:
            #     colors.append('b')
            # else:
            #     colors.append('r')
        graph.plot_2d(simplist, filename, colors)

        print "gen:", evo.gen_count, "fitness:", evo.pop[-1]['fitness']

        if evo.adaptive:
            evo.adapt_mutation()

        best_list.append(evo.pop[-1]['fitness'])
        mut_list.append(evo.mut_rate)

    mutfile = open('mutrate.txt','a')
    mutfile.write(str(mut_list)+'\n')
    mutfile.close()
Пример #3
0
def main():
    """Read data, train on data, test on data, BAM"""
    esn = ESN(input_size=1, hidden_size=100, output_size=1)
    test_damping(esn, 200)

    #create inputs and training data
    #data = datagen.mackeyglass(900, trunc=300) * 0.5
    data = loadtxt('varsine.dat')
    inputs = empty(300)
    inputs.fill(0.0)
    tmp = empty(300)
    tmp.fill(0.5)
    inputs = hstack((inputs, tmp))
    tmp.fill(1.0)
    inputs = hstack((inputs, tmp))
    graph.plot_2d([inputs, data],"data")
    #train and test the esn
    train_out = esn.train(data, inputs)
    test_out = esn.test(data, inputs)
    graph.plot_2d([train_out, data[100:900]], "train_out")
    graph.plot_2d([test_out, data], "test_out")
    #plot residuals
    train_res = residual(train_out, data[100:])
    test_res = residual(test_out, data)
    graph.plot_2d([train_res],"train_residual")
    graph.plot_2d([test_res],"test_residual")

    #calculate mean square error
    print "Train MSE", mse(train_out, data[100:])
    print "Test MSE", mse(test_out, data)
Пример #4
0
def main():
    """Read data, train on data, test on data, BAM""" 
    esn = ESN(input_size=1, hidden_size=100, output_size=1)
    test_damping(esn, 200)

    #create inputs and training data
    #data = datagen.mackeyglass(900, trunc=300) * 0.5
    data = loadtxt('varsine.dat')
    inputs = empty(300)
    inputs.fill(0.0)
    tmp = empty(300)
    tmp.fill(0.5)
    inputs = hstack((inputs, tmp))
    tmp.fill(1.0)
    inputs = hstack((inputs, tmp))
    graph.plot_2d([inputs,data],"data")
    #train and test the esn
    train_out = esn.train(data, inputs)
    test_out = esn.test(data, inputs)
    graph.plot_2d([train_out, data[100:900]], "train_out")
    graph.plot_2d([test_out, data], "test_out")
    #plot residuals
    train_res = residual(train_out, data[100:])
    test_res = residual(test_out, data)
    graph.plot_2d([train_res],"train_residual")
    graph.plot_2d([test_res],"test_residual")

    #calculate mean square error
    print "Train MSE", mse(train_out, data[100:])
    print "Test MSE", mse(test_out, data)
Пример #5
0
 def graph_fields(self):
     """for all companies"""
     for key in self.fields:
         results_list = []
         for record in self.table:
             result = []
             for column in self.fields[key]:
                 result.append(record[column])
             results_list.append(result)
         graph.plot_2d(results_list, key)
Пример #6
0
def main():
    """comparison code"""
    import random

    random.seed(1)
    genome = [random.randint(0, 1) for _ in range(0, 5000)]
    results, conc_list = run_grn(genome, delta=1, syncsize=1, offset=10)

    if len(conc_list) > 1:
        graph.plot_2d(conc_list, "testdata" + str(1))
Пример #7
0
def main():
    """comparison code"""
    import random

    random.seed(1)
    genome = [random.randint(0, 1) for _ in range(0, 5000)]
    results, conc_list = run_grn(genome, delta=1, syncsize=1, offset=10)

    if len(conc_list) > 1:
        graph.plot_2d(conc_list, "testdata"+str(1))
Пример #8
0
def main():
    """comparison code"""
    import random

    random.seed(1)
    genome = [random.randint(0, 1) for _ in range(0, 5000)]
    results, conc_list = run_grn(genome, delta=1, syncsize=100, offset=10)
    minresult = 126 - max(results)
    print "bestfit:", minresult
    if len(conc_list) > 1:
        graph.plot_2d(conc_list, "sinedata"+str(1))
Пример #9
0
    def train(self, target, inputs, trim=100):
        """Calculate weights between hidden layer and output layer for
        a given time series, uses pseudo-inverse training step"""
        acts = zeros((len(target), self.hidden_size))
        summed_acts = []

        #create initial state for the hidden nodes
        for i in range(len(acts[0])):
            acts[0][i] = (random()*2)-1

        # create the activations
        for i in range(1, len(target)):
            # turn target into array
            targ, inp = array([target[i-1]]), array([inputs[i-1]])
            # dotting target with back weights as the teacher signal
            activation = tanh(dot(acts[i-1], self.weights['hidden'])+
                              dot(self.weights['back'], targ)+
                              dot(self.weights['input'], inp))
            # leaky integrator: prev state effects current state
            acts[i] = ((1-self.alpha) * acts[i-1])
            acts[i] += self.alpha * activation

        #trim out the initial 100 activations as they are unstable
        target = target[trim:]
        inputs = inputs[trim:]
        acts = acts[trim:, :]

        #store activations and plot
        self.acts = acts
        graph.plot_2d(acts.T, "training_activations")

        #add the inputs to the activations
        acts = vstack((acts.T, inputs)).T

        # Pseudo-inverse to train the output and setting weights
        tinv = arctanh(target)
        clf = linear_model.RidgeCV(alphas=[0.01, 0.1, 1.0, 10.0])
        #clf = linear_model.Ridge(alpha=0.5)
        #clf = linear_model.LassoCV()
        clf.fit(acts, tinv)
        self.weights['out'] = linear_model.ridge_regression(acts, tinv, 
                                                            alpha=.15)
        self.weights['out'] = clf.coef_
        #self.weights['out'] = linalg.lstsq(acts, tinv)[0]
        #residual = dot(acts, self.weights['out']) - tinv

        graph.bar_plot(self.weights['out'], "weights")

        # checking the output against previous activations
        train_out = []
        for act in acts:
            output = tanh(dot(act, self.weights['out']))
            train_out.append(output)
        return train_out
Пример #10
0
def graph_fields(table, fields):
    for field in fields:
        print "graphing", field['name']
        results_list = []
        for record in table:
            result = []
            for column in field['cols']:
                result.append(record[column])
            results_list.append(result)
        
        graph.plot_2d(results_list, "graphs/"+field['name'])
Пример #11
0
def main():
    """comparison code"""
    import random

    random.seed(1)
    genome = [random.randint(0, 1) for _ in range(0, 5000)]
    results, conc_list = run_grn(genome, delta=1, syncsize=100, offset=10)
    minresult = 126 - max(results)
    print "bestfit:", minresult
    if len(conc_list) > 1:
        graph.plot_2d(conc_list, "sinedata" + str(1))
Пример #12
0
    def train(self, target, inputs, trim=100):
        """Calculate weights between hidden layer and output layer for
        a given time series, uses pseudo-inverse training step"""
        acts = zeros((len(target), self.hidden_size))
        summed_acts = []
        
        #create initial state for the hidden nodes
        for i in range(len(acts[0])):
            acts[0][i] = (random()*2)-1

        # create the activations
        for i in range(1, len(target)):
            # turn target into array
            targ, inp = array([target[i-1]]), array([inputs[i-1]])
            # dotting target with back weights as the teacher signal
            activation = tanh(dot(acts[i-1],self.weights['hidden'])+
                              dot(self.weights['back'], targ)+
                              dot(self.weights['input'], inp))
            # leaky integrator: prev state effects current state
            acts[i] = ((1-self.alpha) * acts[i-1])
            acts[i] += self.alpha * activation

        #trim out the initial 100 activations as they are unstable
        target = target[trim:]
        inputs = inputs[trim:]
        acts = acts[trim:, :]

        #store activations and plot
        self.acts = acts
        graph.plot_2d(acts.T, "training_activations")

        #add the inputs to the activations
        acts = vstack((acts.T,inputs)).T
        
        # Pseudo-inverse to train the output and setting weights
        tinv = arctanh(target)
        clf = linear_model.RidgeCV(alphas=[0.01, 0.1, 1.0, 10.0])
        #clf = linear_model.Ridge(alpha=0.5)
        #clf = linear_model.LassoCV()
        clf.fit(acts, tinv)
        self.weights['out'] = linear_model.ridge_regression(acts, tinv,alpha=.15)
        self.weights['out'] = clf.coef_
        #self.weights['out'] = linalg.lstsq(acts, tinv)[0]
        #residual = dot(acts, self.weights['out']) - tinv

        graph.bar_plot(self.weights['out'], "weights")

        # checking the output against previous activations
        train_out = []
        for act in acts:
            output = tanh(dot(act, self.weights['out']))
            train_out.append(output)
        return train_out
Пример #13
0
def graph_attrib(table, fields):
    for field in fields:
        print "graphing", field['name']
        results_list = []
        for record in table:
            result = []
            for column in field['cols']:
                result.append(record[column])
            results_list.append(result)

        graph.plot_2d(results_list, field['name'])
        graph.plot_ave(results_list, field['name'])
        graph.boxplot_data(results_list, field['name'])
Пример #14
0
def test_damping(esn, iterations):
    """Checking if the network stabilises"""
    acts = zeros((iterations, esn.hidden_size))
    #set them to random initial activations
    for i in range(len(acts[0])):
        acts[0][i] = (random()*2)-1

    # lets see if it dampens out
    for i in range(1, iterations):
        acts[i] = ((1-esn.alpha) * acts[i-1])
        acts[i] += esn.alpha * tanh(dot(acts[i-1], 
                                         esn.weights['hidden']))
    graph.plot_2d(acts.T, "damped_activations")
Пример #15
0
def test_damping(esn, iterations):
    """Checking if the network stabilises"""
    acts = zeros((iterations, esn.hidden_size))
    #set them to random initial activations
    for i in range(len(acts[0])):
        acts[0][i] = (random()*2)-1

    # lets see if it dampens out
    for i in range(1, iterations):
        acts[i] = ((1-esn.alpha) * acts[i-1])
        acts[i] += esn.alpha * tanh(dot(acts[i-1],
                                         esn.weights['hidden']))
    graph.plot_2d(acts.T, "damped_activations")
Пример #16
0
def main():
    # input not used yet
    esn = ESN(input_size=1, hidden_size=20, output_size=1)
    esn.test_damping(200)
    #gendata = datagen.sine(600) * 0.5
    data = loadtxt('sine2.dat')
    train_data = data[:300]
    test_data = data[:50]

    train_out = esn.train(train_data)
    test_out = esn.test(test_data)
    graph.plot_2d([train_out, data[100:300]], "train_out")
    graph.plot_2d([test_out, data[:50]], "test_out")

    #plot residuals
    train_res = residual(train_out, train_data[100:])
    test_res = residual(test_out, test_data)
    graph.plot_2d([train_res], "train_residual")
    graph.plot_2d([test_res], "test_residual")

    #calculate mse
    train_error = mse(train_out, train_data[100:])
    test_error = mse(test_out, test_data)

    print "Train MSE", train_error
    print "Test MSE", test_error
Пример #17
0
def multicore(filename, delta, popsize, generations):
    #set up the evo strategy
    evo = popstrat.Evostrategy(5000, popsize)
    children = evo.iterate(evo.pop)

    nodes = ("*", )
    job_server = pp.Server(8, ppservers=nodes)
    print "Starting pp with", job_server.get_ncpus(), "workers"

    start_time = time.time()

    for i in range(generations):
        run_time = time.time()
        jobs = [(child,
                 job_server.submit(run_grn, (child['genome'], delta), (),
                                   ("cgrn as grn", "numpy", "math")))
                for child in children]
        for child, result in jobs:
            results, conclist = result()
            bestidx = results.index(max(results))
            child['fitness'] = results[bestidx]

        #plotting the best with colors
        children = evo.iterate(children)
        bestgenome = evo.pop[-1]['genome']
        bestresult, conclist = run_grn(bestgenome, delta)
        bestidx = bestresult.index(max(bestresult))

        colors = []
        simplist = []
        for idx, result in enumerate(bestresult):
            if idx == len(bestresult) - 1:
                simplist.append(conclist[idx])
                colors.append('k')
            elif idx == bestidx:
                colors.append('g')
                simplist.append(conclist[idx])
            else:
                simplist.append(conclist[idx])
                colors.append('r')
        graph.plot_2d(simplist, filename, colors)
        print "gen:", evo.gen_count, "fitness:", evo.pop[-1]['fitness']

        if evo.adaptive:
            evo.adapt_mutation()

        res_file = open(filename, "a")
        res_file.write(str(evo.pop[-1]) + '\n')
        res_file.close()
Пример #18
0
def main():

    grn = GRN()
    grn.read_genome("eoinseed1.txt")
    grn.build_genes()
    #grn.add_gene(0.0, "EXTRA")
    grn.precalc_matrix()
    grn.regulate_matrix(10000, False)
    # for i in range(0,3):
    #     init_concs = []
    #     for conc in grn.conc_list:
    #         init_concs.append(conc[i])
    #     print "ROUND ", i
    #     print init_concs
    graph.plot_2d(grn.conc_list, 0)
Пример #19
0
def simple_grn(graphname):
    size = 5
    iterations = 10
    edges = np.zeros([size, size])
    nodes = np.empty([size])
    result_array = [[] for i in range(size)]
    """
    Initialise the nodes to have equal concentrations and
    initialise the weight array with vals between -1,1
    with stepsize 1
    """
    nodes.fill(1.0 / size)
    weightvals = np.arange(-1, 1.1, 0.1)
    for x in np.nditer(edges, op_flags=['readwrite']):
        #x[...] = float(random.randint(-1,1)) / (size)
        x[...] = round(random.choice(weightvals), 2)

    print "nodes\n", nodes, "\nedges\n", edges

    for itr in range(iterations):
        #nudge a node halfway through
        #if itr == (iterations/2):
        #    nodes[0] = nodes[0] * 0.2

        #calculate concentration changes for the nodes
        change = np.empty(size)
        for i in range(len(nodes)):
            change[i] = np.dot(nodes, edges[i])

        # alter concs and prevent it from going below zero
        print "iter:", itr, "conc:", nodes, "change:", change
        nodes = np.add(nodes, change)
        nodes[nodes < 0] = 0.000001

        #normalize
        #        total = sum(nodes)
        #        nodes = np.divide(nodes,total)

        #record concentrations
        for i in range(size):
            result_array[i].append(nodes[i])

    graph.plot_2d(result_array, "graph" + str(graphname))
Пример #20
0
def main():
    import time
    if(len(sys.argv) != 2):
        print "Usage: " + sys.argv[0] + " <rseed>"
        sys.exit(1)
    seed = int(sys.argv[1])
    random.seed(seed)

    #read in the compustat data for given companies
    delta = 20
    companies = [] 
    company_list = ['ARCHER-DANIELS-MIDLAND CO', 'ARTHUR J GALLAGHER & CO',
 'ASCENA RETAIL GROUP INC', 'ASTEC INDUSTRIES INC', 'ASTORIA FINANCIAL CORP',
 'BLACKBAUD INC', 'BMC SOFTWARE INC','BOSTON BEER INC  -CL A', 'BRADY CORP',
 'BRIGGS & STRATTON']
    
    database = csvreader.CSVReader('compustat.csv')
    for company in company_list:
        companies.append(database.get_company(company))

    #set up the evo strategy
    best_list, mut_list = [], []
    evo = popstrat.Evostrategy(5000,50)
    children = evo.iterate(evo.pop)

    for i in range(50):
        for child in children:
            start_time = time.time()
            fitness = run_grn(child['genome'], companies, delta)
            child['fitness'] = fitness
            print "fitness:",child['fitness'],"time taken", str(time.time()-start_time)
            
        children = evo.iterate(children)
        if evo.adaptive:
            evo.adapt_mutation()

        best_list.append(evo.pop[-1]['fitness'])
        mut_list.append(evo.mut_rate)

    graph.plot_2d([best_list], 'bestfit')
    graph.plot_2d([mut_list], 'mutrate')
Пример #21
0
def main():
    best_list, mut_list = [], []
    evo = Evostrategy(5000)
    fitness = evo.onemax_fitness(evo.parent['genome'])
    indiv = {'genome':evo.parent['genome'], 'fitness':fitness}
    child = evo.iterate(indiv)

    for i in range(100):
        child['fitness'] = evo.onemax_fitness(child['genome'])
        child = evo.iterate(child)
        print evo.parent['fitness']
        if evo.parent['fitness'] == 5000:
            break
        
        if evo.adaptive:
            evo.adapt_mutation()
        best_list.append(evo.parent['fitness'])
        mut_list.append(evo.mut_rate)

    graph.plot_2d([best_list], 'bestfit')
    graph.plot_2d([mut_list], 'mutrate')
Пример #22
0
def singlecore(filename, delta, popsize, generations):
    """Run serially"""
    #set up the evo strategy
    best_list, mut_list = [], []
    evo = popstrat.Evostrategy(5000, popsize)
    children = evo.iterate(evo.pop)

    for i in range(generations):
        for child in children:
            results, conclist = run_grn(child['genome'], delta)
            bestidx = results.index(max(results))
            child['fitness'] = results[bestidx]
            print "fitness:", child['fitness']

        children = evo.iterate(children)
        bestgenome = evo.pop[-1]['genome']
        results, conclist = run_grn(bestgenome, delta)
        filename = "best_gen_"+str(i)
        graph.plot_2d(conclist, filename)

        if evo.adaptive:
            evo.adapt_mutation()

        best_list.append(evo.pop[-1]['fitness'])
        mut_list.append(evo.mut_rate)

    print "best overall fitness", evo.pop[-1]['fitness']

    graph.plot_2d([best_list], 'bestfit')
    graph.plot_2d([mut_list], 'mutrate')
Пример #23
0
def main():
    # random.seed(2)
    # grn = GRN(delta=1)
    # grn.build_genes()
    # grn.add_extra("EXTRA_sineval", 0.0, [0]*32)
    # grn.precalc_matrix()
    # grn.regulate_matrix(5)

    import time
    start_time = time.time()

    for seed in range(10):
        random.seed(seed)
        stabiter = 10000
        runiter = 1000
        grn = GRN(delta=1)

        grn.build_genes()
        grn.add_extra("EXTRA_sineval", 0.0, [0]*32)
        grn.precalc_matrix()
        grn.regulate_matrix(stabiter)

        onff = 0
        for i in range(0, 50):
            if i % 10 == 0:
                if onff == 1:
                    onff = 0
                else:
                    onff = 1

            inputval = onff
            extra_vals = {'sineval': inputval}
            grn.set_extras(extra_vals)
            grn.regulate_matrix(runiter)

        for conc in grn.conc_list:
            print conc[-1]
        filename = "demo"+str(seed)
        graph.plot_2d(grn.conc_list, filename)
    print "took", str(time.time() - start_time)
Пример #24
0
def singlecore(filename, delta, popsize, generations):
    """Run serially"""
    #set up the evo strategy
    best_list, mut_list = [], []
    evo = popstrat.Evostrategy(5000, popsize)
    children = evo.iterate(evo.pop)

    for i in range(generations):
        for child in children:
            results, conclist = run_grn(child['genome'], delta)
            bestidx = results.index(max(results))
            child['fitness'] = results[bestidx]
            print "fitness:", child['fitness']

        children = evo.iterate(children)
        bestgenome = evo.pop[-1]['genome']
        results, conclist = run_grn(bestgenome, delta)
        filename = "best_gen_" + str(i)
        graph.plot_2d(conclist, filename)

        if evo.adaptive:
            evo.adapt_mutation()

        best_list.append(evo.pop[-1]['fitness'])
        mut_list.append(evo.mut_rate)

    print "best overall fitness", evo.pop[-1]['fitness']

    graph.plot_2d([best_list], 'bestfit')
    graph.plot_2d([mut_list], 'mutrate')
Пример #25
0
    def test_damping(self, iterations):
        """Checking if the network stabilises"""
        numpy.set_printoptions(precision=4, linewidth=2000)
        acts = zeros((iterations, self.hidden_size))

        acts[0] = [
            0.949029602769840, -0.195694633071382, -0.737442723592159,
            0.449467774003339, 0.799036414715420, -0.658597370832685,
            -0.913942617588595, -0.0416815501470254, -0.812127430489660,
            0.300099663301922, 0.904555077842031, -0.0845746012151277,
            0.0737612940120569, -0.867025708396808, -0.0122598328349043,
            -0.164918055240550, -0.415485899463317, -0.420672124930247,
            0.507691993375378, -0.806408576103972
        ]

        # lets see if it dampens out
        for i in range(1, iterations):
            #acts[i] = ((1-self.alpha) * acts[i-1])
            #acts[i] += self.alpha * tanh(dot(acts[i-1],
            #                                 self.weights['hidden']))
            product = dot(acts[i - 1], self.weights['hidden'].T)
            #            print "product",product
            #            print "tanh", tanh(product)
        graph.plot_2d(acts.T, "damped_activations")
Пример #26
0
def multicore(filename, syncsize, offset, delta, popsize, generations):
    """ Uses parallel python to evaluate, PP can also be used to
    distribute evaluations to machines accross the network"""
    #set up the evo strategy

    evo = popstrat.Evostrategy(5000, popsize)
    children = evo.iterate(evo.pop)

    nodes = ("*",)
    job_server = pp.Server(ncpus=8, ppservers=nodes)
    print "Starting pp with", job_server.get_ncpus(), "workers"

    for _ in range(generations):
        jobs = [(child, job_server.submit(run_grn,
                                          (child['genome'], delta,
                                           syncsize, offset),
                                           (),
                                           ("cgrn as grn","numpy","math")))
                                           for child in children]
        for child, result in jobs:
            results, conclist = result()
            bestidx = results.index(max(results))
            child['fitness'] = results[bestidx]

        print "gen:", evo.gen_count, "fitness:", evo.pop[-1]['fitness']
        children = evo.iterate(children)

        if evo.adaptive:
            evo.adapt_mutation()

        res_file = open(filename,"a")
        res_file.write(str(evo.pop[-1])+'\n')
        res_file.close()

    restopname = filename+".rest"
    #plotting the best with colors
    bestgenome = evo.pop[-1]['genome']
    bestresult, conclist = run_grn(bestgenome, delta, syncsize, offset, restopname)

    bestidx = bestresult.index(max(bestresult))
    fitness = round(max(bestresult), 1)
    colors = []

    for idx, result in enumerate(bestresult):
        # draw the input in black
        if idx == len(bestresult)-1:
            colors.append('k')
        # draw the best in green
        elif idx == bestidx:
            colors.append('g')
        # draw p_genes in red
        elif result > 0:
            colors.append('r')
        # draw TFs in blue
        else:
            colors.append('b')

    print "colors", colors
    graphname = filename.split('/')[2]
    graphname = graphname[:-4] + "-F" + str(fitness)
    graph.plot_2d(conclist, graphname, colors, (0, 1))
Пример #27
0
    def train(self, target, trim=100):
        """Calculate weights between hidden layer and output layer for
        a given time series, uses pseudo-inverse training step"""
        acts = zeros((len(target), self.hidden_size))
        summed_acts = []

        acts[0] = [
            0.949029602769840, -0.195694633071382, -0.737442723592159,
            0.449467774003339, 0.799036414715420, -0.658597370832685,
            -0.913942617588595, -0.0416815501470254, -0.812127430489660,
            0.300099663301922, 0.904555077842031, -0.0845746012151277,
            0.0737612940120569, -0.867025708396808, -0.0122598328349043,
            -0.164918055240550, -0.415485899463317, -0.420672124930247,
            0.507691993375378, -0.806408576103972
        ]

        # create the activations
        self.weights['back'] = self.weights['back'].T
        for i in range(1, len(target)):
            # turn target into array, should it be -1?
            t = array([target[i - 1]])

            # dotting target with back weights as the teacher signal
            activation = tanh(
                dot(acts[i - 1], self.weights['hidden'].T) +
                dot(self.weights['back'], t))
            #decay activation by alpha
            acts[i] = ((1 - self.alpha) * acts[i - 1])
            acts[i] += self.alpha * activation
            #print i-1, acts[i-1]

        #trim out the initial activations as they are unstable
        target = target[trim:]
        acts = acts[trim:, :]

        #store activations and plot
        self.acts = acts

        graph.plot_2d(acts.T, "sample_activations")
        #print "last",acts[-1]
        # Pseudo-inverse to train the output and setting weights
        tinv = arctanh(target)
        pinv = linalg.pinv(acts)
        aconj = acts.conjugate()
        tconj = tinv.conjugate()
        pinvaconj = linalg.pinv(aconj)

        numpy.set_printoptions(precision=4, linewidth=2000)

        # print "Pseudo inverse"
        #for row in aconj:
        #     print row

        print "acts", aconj.shape, "targ", tconj.shape
        #self.weights['out'] = dot(pinv, tinv)
        #self.weights['out'] = dot(pinvaconj,tconj)
        self.weights['out'] = linalg.lstsq(aconj, tconj)[0]
        print "\nnumpy lstsq", self.weights['out']

        #self.weights['out'] = linalg.lstsq(aconj,tconj)[0]
        #self.weights['out'] = scialg.lsqr(aconj,tconj)[0]

        #self.weights['out'] = array([-2.62751866452261,0.911724638334178,0,0,0,-9.47053869171588,0,0,-3.90801067449960,0,7.05096786026327,11.5512880240272,7.35498461772589,-0.221961288369604,0,0,0.681830006046591,0,0,-0.458162995895149])

        print "\nnew weights", self.weights['out']
        graph.bar_plot(self.weights['out'], "weights")

        # checking the output against previous activations
        train_out = []
        for act in acts:
            output = tanh(dot(act, self.weights['out']))
            train_out.append(output)
        return train_out
Пример #28
0
 def graph_company(self, company_name):
     """all fields for a given company"""
     data = self.get_company(company_name)
     for key in data:
         graph.plot_2d([data[key]], company_name + ' ' + key)
Пример #29
0
def main():
    # random.seed(2)
    # stabiter = 10000
    # runiter = 1000
    # grn = GRN(delta=1)

    # grn.build_genes()
    # grn.add_extra("EXTRA_sineval", 0.0, [0]*32)
    # grn.precalc_matrix()
    # grn.regulate_matrix(stabiter)

    # onff = 0
    # for i in range(0, 10):
    #     if i % 10 == 0:
    #         if onff == 1:
    #             onff = 0
    #         else:
    #             onff = 1

    #     extra_vals = {'sineval': onff}
    #     grn.set_extras(extra_vals)
    #     grn.regulate_matrix(10)

    # for i in range(len(grn.conc_list[0])):
    #     concs = []
    #     for j in range(len(grn.conc_list)):
    #         concs.append(grn.conc_list[j][i])
    #     print concs

    import time
    start_time = time.time()

    for seed in range(10):
        random.seed(seed)
        stabiter = 10000
        runiter = 1000
        grn = GRN(delta=1)

        grn.build_genes()
        grn.add_extra("EXTRA_sineval", 0.0, [0] * 32)
        grn.precalc_matrix()
        grn.regulate_matrix(stabiter)

        onff = 0
        for i in range(0, 50):
            if i % 10 == 0:
                if onff == 1:
                    onff = 0
                else:
                    onff = 1

            inputval = onff
            extra_vals = {'sineval': inputval}
            grn.set_extras(extra_vals)
            grn.regulate_matrix(runiter)

        print "rows", len(grn.conc_list), "cols", len(grn.conc_list[0])
        for conc in grn.conc_list:
            print conc[-1]
        filename = "demo" + str(seed)
        graph.plot_2d(grn.conc_list, filename)
    print "took", str(time.time() - start_time)
Пример #30
0
def multicore(filename, syncsize, offset, delta, popsize, generations):
    """ Uses parallel python to evaluate, PP can also be used to
    distribute evaluations to machines accross the network"""
    #set up the evo strategy

    evo = popstrat.Evostrategy(5000, popsize)
    children = evo.iterate(evo.pop)

    nodes = ("*", )
    job_server = pp.Server(ncpus=8, ppservers=nodes)
    print "Starting pp with", job_server.get_ncpus(), "workers"

    for _ in range(generations):
        jobs = [(child,
                 job_server.submit(run_grn,
                                   (child['genome'], delta, syncsize, offset),
                                   (), ("cgrn as grn", "numpy", "math")))
                for child in children]
        for child, result in jobs:
            results, conclist = result()
            bestidx = results.index(max(results))
            child['fitness'] = results[bestidx]

        print "gen:", evo.gen_count, "fitness:", evo.pop[-1]['fitness']
        children = evo.iterate(children)

        if evo.adaptive:
            evo.adapt_mutation()

        res_file = open(filename, "a")
        res_file.write(str(evo.pop[-1]) + '\n')
        res_file.close()

    restopname = filename + ".rest"
    #plotting the best with colors
    bestgenome = evo.pop[-1]['genome']
    bestresult, conclist = run_grn(bestgenome, delta, syncsize, offset,
                                   restopname)

    bestidx = bestresult.index(max(bestresult))
    fitness = round(max(bestresult), 1)
    colors = []

    for idx, result in enumerate(bestresult):
        # draw the input in black
        if idx == len(bestresult) - 1:
            colors.append('k')
        # draw the best in green
        elif idx == bestidx:
            colors.append('g')
        # draw p_genes in red
        elif result > 0:
            colors.append('r')
        # draw TFs in blue
        else:
            colors.append('b')

    print "colors", colors
    graphname = filename.split('/')[2]
    graphname = graphname[:-4] + "-F" + str(fitness)
    graph.plot_2d(conclist, graphname, colors, (0, 1))