def task31(): training, testing, _ = generate_data_task31(lambda x: square(np.sin(x)), 0) #training, testing = generate_data_task31(lambda x:square(np.sin(x)), 0.1) rbf_nodes = get_radial_coordinates(0) centroids = Fixed(rbf_nodes['nodes']) sigma = 1.0 RadialBasisNetwork = Network(X=training['X'], Y=training['Y'], sigma=1.0, hidden_nodes=rbf_nodes['N'], centroids=Fixed(rbf_nodes['nodes']), initializer=RandomNormal()) RadialBasisNetwork.train(epochs=1, optimizer=LeastSquares(), epoch_shuffle=True) prediction, residual_error = RadialBasisNetwork.predict( testing['X'], testing['Y']) print('residual_error', residual_error) plt.plot(testing['X'], testing['Y'], label='True') plt.plot(testing['X'], np.where(prediction >= 0, 1, -1), label='Prediction') plt.ylabel('sign(sin(2x))') plt.xlabel('x') plt.scatter(rbf_nodes['nodes'], np.zeros(rbf_nodes['nodes'].size)) plt.legend() plot_centroids_1d(centroids, sigma) plt.show()
def get_leaders_and_outermosts(): guys = Reader.read_lines("datasets/enron/enron_guys.txt") guys = {int(nid) : email for nid, email in guys} global_leaders, global_outermosts = defaultdict(list), defaultdict(list) for month in xrange(1, 13): n = Network('datasets/enron/timeslots/{:02d}-filtered2.edges'.format(month), is_directed=False, use_communities=True) communities = set(flatten_list(n.communities.values())) month_leaders, month_outermosts = set(), set() for c in communities: n.filter_community([c]) leaders, outermosts = RoleMining(n).find_roles() [month_leaders.add(leader) for leader in leaders] [month_outermosts.add(outer) for outer in outermosts] n.unfilter_graph() for l, c in month_leaders: global_leaders[l].append((month,c)) for o, c in month_outermosts: global_outermosts[o].append((month, c)) print for id, months in global_outermosts.items(): if guys[id] in the_losers: print guys[id], months
def task32(): training, testing, testing_clean = generate_data_task31( lambda x: np.sin(x), 0.1) sigma = [0.1, 0.3, 0.5, 1.0, 1.3] tests = [1, 2, 3, 4] # weak, tighter, random for t in tests: rbf_nodes = get_radial_coordinates(t) centroids = Fixed(rbf_nodes['nodes']) for sig in sigma: RadialBasisNetwork = Network(X=training['X'], Y=training['Y'], sigma=sig, hidden_nodes=rbf_nodes['N'], centroids=centroids, initializer=RandomNormal(std=0.1)) data = RadialBasisNetwork.train( epochs=10000, epoch_shuffle=True, #optimizer=LeastSquares()) optimizer=DeltaRule(eta=0.001)) prediction_noisy, residual_error_noisy = RadialBasisNetwork.predict( testing['X'], testing['Y']) prediction_clean, residual_error_clean = RadialBasisNetwork.predict( testing_clean['X'], testing_clean['Y']) print('residual error', residual_error_clean) print('residual error (noisy)', residual_error_noisy) plt.clf() plt.plot(testing['X'], testing['Y'], label='True') plt.plot(testing['X'], prediction_noisy, label='Prediction (noise)') #plt.plot(testing_clean['X'], prediction_clean, label='Prediction (no noise)') #plt.ylabel('sign(sin(2x))') plt.ylabel('sin(2x)') plt.xlabel('x') plt.scatter(rbf_nodes['nodes'], np.zeros(rbf_nodes['nodes'].size)) plt.legend(loc='upper right') plot_centroids_1d(centroids, sig) path = './figures/task3.2/sin(2x)_sig=' + str( sig) + '_set=' + rbf_nodes['name'] plt.savefig(path + '.png') print(data['config']) save_data( data['config'] + '\n\nresidual error (noisy)=' + str(residual_error_noisy) + '\nresidual error clean=' + str(residual_error_clean), path + '.txt')
def __init__(self): self.words = [] self.labels = [] self.docs_x = [] self.docs_y = [] self.stemmer = LancasterStemmer() self.data = [] self.training = [] self.output = [] self.out_empty=[] self.model=[] self.count=-1 self.say="" self.Network=Network()
def test_longest_route(self): n = Network() json_file = 'C:\Users\ShravanB\Documents\College\CS242\CSAir\data\CSAir.json' f = open(json_file, 'r') data = json.loads(f.read()) n.create_metros(data['metros']) n.create_routes(data['routes']) longest_route = "Longest Route: SYD - LAX \nDistance: 12051" self.assertEqual(n.get_longest_route(), longest_route)
def test_avg_city(self): n = Network() json_file = 'C:\Users\ShravanB\Documents\College\CS242\CSAir\data\CSAir.json' f = open(json_file, 'r') data = json.loads(f.read()) n.create_metros(data['metros']) n.create_routes(data['routes']) avg_city = "Average City Population: 11796143" self.assertEqual(n.get_average_size(), avg_city)
def test_avg_route(self): n = Network() json_file = 'C:\Users\ShravanB\Documents\College\CS242\CSAir\data\CSAir.json' f = open(json_file, 'r') data = json.loads(f.read()) n.create_metros(data['metros']) n.create_routes(data['routes']) avg_route = "Average Route Distance: 2300" self.assertEqual(n.get_average_route(), avg_route)
def test_shortest_route(self): n = Network() json_file = 'C:\Users\ShravanB\Documents\College\CS242\CSAir\data\CSAir.json' f = open(json_file, 'r') data = json.loads(f.read()) n.create_metros(data['metros']) n.create_routes(data['routes']) shortest_route = "Shortest Route: WAS - NYC \nDistance: 334" self.assertEqual(n.get_shortest_route(), shortest_route)
def test_biggest_city(self): n = Network() json_file = 'C:\Users\ShravanB\Documents\College\CS242\CSAir\data\CSAir.json' f = open(json_file, 'r') data = json.loads(f.read()) n.create_metros(data['metros']) n.create_routes(data['routes']) small_city = "Smallest Population: Essen - 589900 people" self.assertEqual(n.get_smallest_city(), small_city)
def test_city_hub(self): n = Network() json_file = 'C:\Users\ShravanB\Documents\College\CS242\CSAir\data\CSAir.json' f = open(json_file, 'r') data = json.loads(f.read()) n.create_metros(data['metros']) n.create_routes(data['routes']) metro_hub = "Number of Routes : 6\n" \ "Istanbul\n" \ "Hong Kong" self.assertEqual(n.get_city_hubs(), metro_hub)
def test_url(self): n = Network() json_file = 'C:\Users\ShravanB\Documents\College\CS242\CSAir\data\CSAir.json' f = open(json_file, 'r') data = json.loads(f.read()) n.create_metros(data['metros']) n.create_routes(data['routes']) url = "http://www.gcmap.com/mapui?P=SCL-LIM,+LIM-MEX,+LIM-BOG," \ "+MEX-LAX,+MEX-CHI,+MEX-MIA,+MEX-BOG,+BOG-MIA,+BOG-SAO,+BOG-BUE," \ "+BUE-SAO,+SAO-MAD,+SAO-LOS,+LOS-KRT,+LOS-FIH,+FIH-KRT,+FIH-JNB," \ "+JNB-KRT,+KRT-CAI,+CAI-ALG,+CAI-IST,+CAI-BGW,+CAI-RUH,+ALG-MAD," \ "+ALG-PAR,+ALG-IST,+MAD-NYC,+MAD-LON,+MAD-PAR,+LON-NYC,+LON-ESS," \ "+LON-PAR,+PAR-ESS,+PAR-MIL,+MIL-ESS,+MIL-IST,+ESS-LED,+LED-MOW," \ "+LED-IST,+MOW-THR,+MOW-IST,+IST-BGW,+BGW-THR,+BGW-KHI,+BGW-RUH," \ "+THR-DEL,+THR-KHI,+THR-RUH,+RUH-KHI,+KHI-DEL,+KHI-BOM,+DEL-CCU," \ "+DEL-MAA,+DEL-BOM,+BOM-MAA,+MAA-CCU,+MAA-BKK,+MAA-JKT,+CCU-HKG," \ "+CCU-BKK,+BKK-HKG,+BKK-SGN,+BKK-JKT,+HKG-SHA,+HKG-TPE,+HKG-MNL," \ "+HKG-SGN,+SHA-PEK,+SHA-ICN,+SHA-TYO,+SHA-TPE,+PEK-ICN,+ICN-TYO," \ "+TYO-SFO,+TYO-OSA,+OSA-TPE,+TPE-MNL,+MNL-SFO,+MNL-SYD,+MNL-SGN," \ "+SGN-JKT,+JKT-SYD,+SYD-LAX,+LAX-SFO,+LAX-CHI,+SFO-CHI,+CHI-YYZ," \ "+CHI-ATL,+ATL-WAS,+ATL-MIA,+MIA-WAS,+WAS-YYZ,+WAS-NYC,+NYC-YYZ,+" self.assertEqual(n.get_url(), url)
newLine = [] for i in range(0, len(tokens)): newLine.append(float(tokens[i])) learnData.append(newLine) for line in lines[84:]: tokens = line.split(',') newLine = [] for i in range(0, len(tokens)): newLine.append(float(tokens[i])) testData.append(newLine) return (learnData, testData) if __name__ == '__main__': ''' P1.Build a system that approximates the quality of a concrete mixture based on the used ingredients. Input variables: 7 Output variables: 3 ''' learnData, testData = getData("C:\\_MyFiles\\_FMI\\Workspace\\AI\\Lab5\\files\\data.data") net = Network(7, 3, [4]) net.learn(LEARN_RATE, learnData) err = net.run(testData) err[0] = int(err[0]) err[1] = int(err[1]) err[2] = int(err[2]) print('\nSLUMP, FLOW, 28-day Compressive Strength = ' + str(err))
if e.buttons() == Qt.LeftButton: self.move(self.pos() + e.globalPos() - self.clickPosition) self.clickPosition = e.globalPos() e.accept() #Change this when turning this to exe def Finish(): system('taskkill /f /im java.exe') QCoreApplication.instance().quit() self.ui.frame.mouseMoveEvent = moveWindow self.ui.pushButton_2.clicked.connect(Finish) self.ui.textEdit.setText("Start talking with the bot") self.ui.pushButton.clicked.connect(lambda: Clicked(bot)) def mousePressEvent(self, event): self.clickPosition = event.globalPos() if __name__ == "__main__": Net= Network() Network.RunServer() Talk.delete() bot = Bot() bot.read() bot.stem() bot.modelsetup() bot.setup() app = QApplication(sys.argv) window = Winner(bot,Net) sys.exit(app.exec_())
def task333(): training, testing = ballistic_data() #plt.scatter(testing['X'][:,0], testing['Y'][:,0], label='col1') #plt.scatter(testing['X'][:,1], testing['Y'][:,1], label='col2') #plt.legend() #plt.show() N_hidden_nodes = 10 sigma = 0.1 eta = 0.1 eta_hidden = 0.02 centroids = LeakyCL(matrix=np.empty( (training['X'].shape[1], N_hidden_nodes)), space=[-0.1, 0.9], eta=eta_hidden) RadialBasisNetwork = Network(X=training['X'], Y=training['Y'], sigma=sigma, hidden_nodes=N_hidden_nodes, centroids=centroids, initializer=RandomNormal(std=0.1)) data = RadialBasisNetwork.train( epochs=2000, epoch_shuffle=True, #optimizer=LeastSquares()) optimizer=DeltaRule(eta=eta)) prediction, residual_error = RadialBasisNetwork.predict( testing['X'], testing['Y']) print('residual error:', residual_error) path = './figures/task3.3/ballist_N=' + str( N_hidden_nodes) + '_eta=' + str(eta) + '_sigma=' + str(sigma) padding = 0.1 min = prediction[:, 0].min() - padding if prediction[:, 0].min( ) < testing['Y'][:, 0].min() else testing['Y'][:, 0].min() - padding max = prediction[:, 0].max() + padding if prediction[:, 0].max( ) > testing['Y'][:, 0].max() else testing['Y'][:, 0].max() + padding plt.clf() plt.axis([min, max, min, max]) plt.plot([min, max], [min, max], '--k', linewidth=1, dashes=(5, 10)) plt.scatter(prediction[:, 0], testing['Y'][:, 0], marker='x') plt.title('Angle/Distance') plt.ylabel('True') plt.xlabel('Predicted') plt.savefig(path + '_angledistance.png') padding = 0.1 min = prediction[:, 1].min() - padding if prediction[:, 1].min( ) < testing['Y'][:, 1].min() else testing['Y'][:, 1].min() - padding max = prediction[:, 1].max() + padding if prediction[:, 1].max( ) > testing['Y'][:, 1].max() else testing['Y'][:, 1].max() + padding plt.clf() plt.axis([min, max, min, max]) plt.plot([min, max], [min, max], '--k', linewidth=1, dashes=(5, 10)) plt.scatter(prediction[:, 1], testing['Y'][:, 1], marker='x') plt.title('Velocity/Height') plt.ylabel('True') plt.xlabel('Predicted') plt.savefig(path + '_velocityheight.png') print(data['config']) save_data(data['config'] + '\n\nresidual error=' + str(residual_error), path + '.txt') plt.clf() plt.plot(np.arange(0, len(data['t_loss'])), data['t_loss'], label='training loss') plt.xlabel('Epochs') plt.ylabel('Total approximation error') plt.legend(loc='upper right') plt.savefig(path + '_learning.png')
def task33(): N_units = [{ 'N': 8, 'name': 'Tight', 'sigma': 0.5 }, { 'N': 12, 'name': 'task31', 'sigma': 1.0 }] noise = [0, 0.1] for std in noise: training, testing, testing_clean = generate_data_task31( lambda x: np.sin(x), std) for hidden_layer in N_units: #centroids = VanillaCL(np.empty((training['X'].shape[1], hidden_layer['N'])), space=[0, 2*np.pi], eta=0.001) centroids = LeakyCL(np.empty( (training['X'].shape[1], hidden_layer['N'])), space=[0, 2 * np.pi], eta=0.001) RadialBasisNetwork = Network(X=training['X'], Y=training['Y'], sigma=hidden_layer['sigma'], hidden_nodes=hidden_layer['N'], centroids=centroids, initializer=RandomNormal(std=0.1)) data = RadialBasisNetwork.train( epochs=10000, epoch_shuffle=True, #optimizer=LeastSquares()) optimizer=DeltaRule(eta=0.001)) prediction_noisy, residual_error_noisy = RadialBasisNetwork.predict( testing['X'], testing['Y']) prediction_clean, residual_error_clean = RadialBasisNetwork.predict( testing_clean['X'], testing_clean['Y']) print('residual error', residual_error_clean) print('residual error (noisy)', residual_error_noisy) plt.clf() plt.plot(testing['X'], testing['Y'], label='True') plt.plot(testing['X'], prediction_noisy, label='Prediction (noise)') #plt.plot(testing_clean['X'], prediction_clean, label='Prediction (no noise)') #plt.ylabel('sign(sin(2x))') plt.ylabel('sin(2x)') plt.xlabel('x') plt.scatter(centroids.get_matrix(), np.zeros(hidden_layer['N']).reshape(-1, 1).T) plt.legend(loc='upper right') plot_centroids_1d(centroids, hidden_layer['sigma']) #plt.show() path = './figures/task3.3/sin(2x)_sigma=' + str( hidden_layer['sigma'] ) + '_set=' + hidden_layer['name'] + '_noise=' + str(std) plt.savefig(path + '.png') print(data['config']) save_data( data['config'] + '\n\nresidual error (noisy)=' + str(residual_error_noisy) + '\nresidual error clean=' + str(residual_error_clean), path + '.txt') plt.clf() plt.plot(np.arange(0, len(data['t_loss'])), data['t_loss'], label='training loss') plt.xlabel('Epochs') plt.ylabel('Total approximation error') plt.legend(loc='upper right') plt.savefig(path + '_learning.png')
def test_mediators(self): n = Network("datasets/test/test_cbc.edges", is_directed=False, communities_file="datasets/test/test_cbc.communities") n.print_communities() n.get_mediators_NBC()
import numpy as np #TODO: put the network to "the edge of chaos" N = 30 # number of neurons dt = 0.1 # granularity of time T = 12000 # ms to run the network for T_steps = int(T / dt) # time steps to run the network for variables_to_monitor = [] #['v'] neurons = [IzhikevichNeuron() for i in range(N)] enf_nrns = [0, 1, 2, N - 1] # the list of indices of the enforced neurons synapses = connect_reservoir(neurons, inps=enf_nrns[:3], outs=enf_nrns[3:], prob=0.3) net = Network(dt, neurons, synapses, variables_to_monitor) # generate template input and output spike trains which repeats every T/10 timesteps ist1 = PoissonSpikeTrain(T / 10).generate(11) # in Hz ist2 = PoissonSpikeTrain(T / 10).generate(15) ist3 = PoissonSpikeTrain(T / 10).generate(13) ost = PoissonSpikeTrain(T / 10).generate(14) input_spike_train1 = np.hstack([ist1 + i * (T / 10) for i in range(20)]) input_spike_train2 = np.hstack([ist2 + i * (T / 10) for i in range(20)]) input_spike_train3 = np.hstack([ist3 + i * (T / 10) for i in range(20)]) output_spike_train = np.hstack([ost + i * (T / 10) for i in range(20)]) # fix the evolution of specified neurons and force them to spike at with the specified patterns net.enforce_neurons(enf_nrns, [ input_spike_train1, input_spike_train2, input_spike_train3, output_spike_train
class Bot: def __init__(self): self.words = [] self.labels = [] self.docs_x = [] self.docs_y = [] self.stemmer = LancasterStemmer() self.data = [] self.training = [] self.output = [] self.out_empty=[] self.model=[] self.count=-1 self.say="" self.Network=Network() def read(self): with open("src/models/intents.json") as f: self.data=load(f) def dump(self): with open("src/models/data.pickle", "wb") as f: dump((self.words, self.labels, self.training, self.output), f) def stem(self): for intent in self.data["intents"]: for pattern in intent["patterns"]: wrds = word_tokenize(pattern) self.words.extend(wrds) self.docs_x.append(wrds) self.docs_y.append(intent["tag"]) if intent["tag"] not in self.labels: self.labels.append(intent["tag"]) self.words = [self.stemmer.stem(w.lower()) for w in self.words if w != "?"] self.words = sorted(list(set(self.words))) self.labels = sorted(self.labels) def modelsetup(self): self.out_empty = [0 for _ in range(len(self.labels))] for x, doc in enumerate(self.docs_x): bag = [] wrds = [self.stemmer.stem(w.lower()) for w in doc] for w in self.words: if w in wrds: bag.append(1) else: bag.append(0) output_row = self.out_empty[:] output_row[self.labels.index(self.docs_y[x])] = 1 self.training.append(bag) self.output.append(output_row) self.training = array(self.training) self.output = array(self.output) self.dump() def setup(self): ops.reset_default_graph() net = input_data(shape=[None, len(self.training[0])]) net = fully_connected(net, 10) net = fully_connected(net, 10) net = fully_connected(net, len(self.output[0]), activation="softmax") net = regression(net) self.model = DNN(net) if exists("src/models/model.tflearn.index"): self.model.load("src/models/model.tflearn") else: self.model.fit(self.training, self.output, n_epoch=1000, batch_size=8, show_metric=True) self.model.save("src/models/model.tflearn") def indexWord(self,x,word): x=x.split(" ") ch="" for i in x: if i.find(word)!=-1: ch=i return ch def bag_of_words(self,s, words): bag = [0 for _ in range(len(words))] translate=[] s_words = word_tokenize(s) s_words = [self.stemmer.stem(word.lower()) for word in s_words] for se in s_words: for i, w in enumerate(words): if w == se: bag[i] = 1 if se not in words and se not in translate: translate.append(se) return array(bag),translate def chat(self,x,ui): try: self.count+=1 predinp,translate=self.bag_of_words(x, self.words) if translate: translate=self.indexWord(str(x),translate[0]) print(translate) results = self.model.predict([predinp]) results_index = argmax(results) tag = self.labels[results_index] except Exception as e: print(e) try: if results[0][results_index] > 0.4: for tg in self.data["intents"]: if tg['tag'] == tag: responses = tg['responses'] self.say=choice(responses) if self.say=="Looking up": self.say=self.Network.Connect(translate.upper()) ui.textEdit.setText(self.say) else: ui.textEdit.setText(self.say) else: self.say="Sorry i can't understand i am still learning try again." ui.textEdit.setText(self.say) except Exception as e: print(e)
#!/usr/bin/env python3 from src.TextCorpus import TextCorpus from src.Text import Text from src.Network import Network from src.rule_set import english import os current_dir = os.path.dirname(os.path.abspath(__file__)) text_filename = os.path.join( current_dir, 'datasets/bbc-news/news/tech/call-for-action-on-internet-scam.txt') print('Analyzing ' + text_filename) corpus = TextCorpus(os.path.join(current_dir, 'datasets/bbc-news.json')) text = Text(corpus, open(text_filename, mode='r', encoding='utf-8').read()) print('Text of ' + str(len(text.terms)) + ' terms with average score of ' + str(text.avg_score)) net = Network(english) net.merge(text) net.save_graph('output/test') net.log_to_html() print('Graph saved to test-edges.xlsx!')
# ___________________________________________________________NETWORK INIT # Variables initialization # --------------------------------------------------- epoch = 1500 # setting training iterations learning_rate = 0.3 # setting learning rate layer1neurons = 8 # number of hidden layers neurons layer2neurons = 8 # number of hidden layers neurons layer3neurons = 8 # number of hidden layers neurons inputlayer_neurons = features_array_n.shape[ 1] # number of features in data set # --------------------------------------------------- # create the network with inputs, and desired outputs nn = Network(features_array_n, target_array, layer1neurons, layer2neurons, layer3neurons) # iterate epoch numbers of times for i in range(epoch): nn.feedforward() # run feedforward nn.backpropagate(learning_rate) # run feedback nn.mse(nn.output, target_lst) # compute mse print(str(i) + "/" + str(epoch)) # output which epoch the computer is at # print("output") # print(nn.output) # ___________________________________________________________RESULT PROCESSING print(nn.mse_lst)
def run_cegar_guy_way(nnet_reader_object, which_acas_output, number_of_layers_to_transfer_into_cegar_layer): # merge all arnodes in all the layers the user wishes to apply cegar too network = Network(nnet_reader_object, which_acas_output) network.preprocess_more_layers( number_of_layers_to_transfer_into_cegar_layer + 1) network.forward_activate_more_layers( number_of_layers_to_transfer_into_cegar_layer + 1) network.fully_activate_more_layers( number_of_layers_to_transfer_into_cegar_layer) while True: try: layer_number, table_number, list_of_keys_of_arnodes_to_merge = network.decide_best_arnodes_to_merge( ) network.merge_list_of_arnodes(layer_number, table_number, list_of_keys_of_arnodes_to_merge) except: break while True: result = network.check_if_network_is_sat_or_unsat() if result == network.CODE_FOR_SAT: print('SAT') break elif result == network.CODE_FOR_UNSAT: print('UNSAT') break # we have a spurious counter example layer_number, table_number, key_in_table, partition_of_arnode_inner_nodes = network.decide_best_arnodes_to_merge( ) network.split_arnode(layer_number, table_number, key_in_table, partition_of_arnode_inner_nodes)
def run_cegar_naive(nnet_reader_object, which_acas_output): """ naive algorithm abstracts all the way and only then starts to refine back """ network = Network(nnet_reader_object, which_acas_output) network.fully_activate_the_entire_network() # merge all arnodes while True: try: layer_number, table_number, list_of_keys_of_arnodes_to_merge = network.decide_best_arnodes_to_merge( ) network.merge_list_of_arnodes(layer_number, table_number, list_of_keys_of_arnodes_to_merge) except: break while True: result = network.check_if_network_is_sat_or_unsat() if result == network.CODE_FOR_SAT: print('SAT') break elif result == network.CODE_FOR_UNSAT: print('UNSAT') break # we have a spurious counter example layer_number, table_number, key_in_table, partition_of_arnode_inner_nodes = network.decide_best_arnodes_to_merge( ) network.split_arnode(layer_number, table_number, key_in_table, partition_of_arnode_inner_nodes)
from src.Network import Network from src.Neuron import IzhikevichNeuron from src.SpikeTrain import UniformSpikeTrain, PoissonSpikeTrain from src.Synapse import SynapseSTDP from src.plotting_functions import * from matplotlib import pyplot as plt neurons = [IzhikevichNeuron() for i in range(2)] dt = 0.1 T = 20000 # ms to run the network for T_steps = int(T / dt) # time steps to run the network for variables_to_monitor = ['v'] synapses = dict() synapses[0, 1] = SynapseSTDP(neurons[0], neurons[1]) net = Network(dt, neurons, synapses, variables_to_monitor) net.set_plastic_synapses(list_of_tuples=[(0, 1)]) spike_train_uniform = UniformSpikeTrain(T).generate(10) spike_train_poisson = PoissonSpikeTrain(T).generate(10) net.enforce_neurons(indices=[0, 1], spike_trains=[spike_train_uniform, spike_train_poisson]) # net.enforce_neurons(indices=[0], spike_trains=[spike_train_uniform]) net.run(T_steps) fig2 = plot_spikes_and_weights(net) plt.show(block=True)
default=None, type=float, help= 'threshold (TF-IDF value) below which concepts will not be included to the graph' ) args = arg_parser.parse_args() current_dir = os.path.dirname(os.path.abspath(__file__)) df_filename = os.path.normpath( os.path.join(current_dir, 'datasets/bbc-news.json')) texts_path = os.path.normpath(os.path.join(current_dir, 'input')) print('Loading DF metrics from ') corpus = TextCorpus(df_filename) print('Creating English semantic network...') net = Network(english, args.threshold) print('Reading texts from ' + texts_path) for filename in glob.iglob(os.path.join(texts_path, '**/*.*'), recursive=True): text = Text(corpus, open(filename, mode='r', encoding='utf-8').read(), name=re.search('[^\\\/]+$', filename).group(0)) print('Text of ' + str(len(text.terms)) + ' terms with average score of ' + str(text.avg_score)) net.merge(text) net.save_graph('output/output') net.log_to_html() print('Graph saved to ' + current_dir + '/output/output-edges.xlsx (output-nodes.xlsx)!')