def plot_sf(number_of_nodes_list, averaging, topology_radius, number_of_gws, packet_rate, packet_size, simulation_duration, traffic_type): sf_list = [ PacketSf.SF_7, PacketSf.SF_8, PacketSf.SF_9, PacketSf.SF_10, PacketSf.SF_11, PacketSf.SF_12, PacketSf.SF_Lowest, PacketSf.SF_Random ] sf_pdr_figure = SimulationFigure(number_of_nodes_list, [sf.name for sf in sf_list]) sf_energy_figure = SimulationFigure(number_of_nodes_list, [sf.name for sf in sf_list]) for sf in sf_list: sys.stdout.write('\n{} '.format(sf)) sys.stdout.flush() for number_of_nodes in number_of_nodes_list: sys.stdout.write('.') sys.stdout.flush() simulation_result_sum = SimulationResult() for repeat in range(averaging): topology = Topology.create_random_topology( number_of_nodes=number_of_nodes, radius=topology_radius, number_of_gws=number_of_gws, node_traffic_proportions=traffic_type) simulation = Simulation( topology=topology, packet_rate=packet_rate, packet_size=packet_size, simulation_duration=simulation_duration, sf=sf) simulation_result_sum += simulation.run() sf_pdr_figure.plot_data[sf.name].append( float(simulation_result_sum.pdr) / averaging) sf_energy_figure.plot_data[sf.name].append( float(simulation_result_sum.txEnergyConsumption) / averaging) sf_pdr_figure.get_plot(xlabel='Number of nodes', ylabel='PDR (%)', ylim_bottom=0, xlim_left=0, xlim_right=1000) plt.legend(loc='upper right', fontsize='small', title='SF', ncol=2) plt.savefig('output/sf_pdr_r{}_g{}_p{}_s{}.png'.format( topology_radius, number_of_gws, packet_rate, simulation_duration), dpi=200, transparent=True) sf_energy_figure.get_plot(xlabel='Number of nodes', ylabel='Transmit energy consumption (J)', ylim_bottom=0, xlim_left=0, xlim_right=1000) plt.legend(loc='upper left', fontsize='small', title='SF', ncol=2) plt.savefig('output/sf_energy_r{}_g{}_p{}_s{}.png'.format( topology_radius, number_of_gws, packet_rate, simulation_duration), dpi=200, transparent=True)
def plot_pr(number_of_nodes_list, averaging, topology_radius, number_of_gws, packet_size, simulation_duration, traffic_type): packet_rate_list = [0.005, 0.01, 0.02, 0.04, 0.08] pr_pdr_figure = SimulationFigure(number_of_nodes_list, packet_rate_list) pr_energy_figure = SimulationFigure(number_of_nodes_list, packet_rate_list) for packet_rate in packet_rate_list: sys.stdout.write('\n{} '.format(packet_rate)) sys.stdout.flush() for number_of_nodes in number_of_nodes_list: sys.stdout.write('.') sys.stdout.flush() simulation_result_sum = SimulationResult() for repeat in range(averaging): topology = Topology.create_random_topology( number_of_nodes=number_of_nodes, radius=topology_radius, number_of_gws=number_of_gws, node_traffic_proportions=traffic_type) simulation = Simulation( topology=topology, packet_rate=packet_rate, packet_size=packet_size, simulation_duration=simulation_duration, sf=PacketSf.SF_Lowest) simulation_result_sum += simulation.run() pr_pdr_figure.plot_data[packet_rate].append( float(simulation_result_sum.pdr) / averaging) pr_energy_figure.plot_data[packet_rate].append( float(simulation_result_sum.txEnergyConsumption) / averaging) pr_pdr_figure.get_plot(xlabel='Number of nodes', ylabel='PDR (%)', ylim_bottom=0, xlim_left=0, xlim_right=1000) plt.legend(fontsize='small', title='Packet Rate (pps)') plt.savefig('output/pr_pdr_r{}_g{}_s{}.png'.format(topology_radius, number_of_gws, simulation_duration), dpi=200, transparent=True) pr_energy_figure.get_plot(xlabel='Number of nodes', ylabel='Transmit energy consumption (J)', ylim_bottom=0, xlim_left=0, xlim_right=1000) plt.legend(fontsize='small', title='Packet Rate (pps)') plt.savefig('output/pr_energy_r{}_g{}_s{}.png'.format( topology_radius, number_of_gws, simulation_duration), dpi=200, transparent=True)
def prediction_accuracy(averaging, number_of_gws, packet_rate, packet_size, simulation_duration, traffic_type): for radius in [3000, 5000, 7000, 10000]: for number_of_nodes in [100, 500, 1000]: prediction_dt_acc_averaging_sum = 0 prediction_svm_acc_averaging_sum = 0 topology = Topology.create_random_topology( number_of_nodes=number_of_nodes, radius=radius, number_of_gws=number_of_gws, node_traffic_proportions=traffic_type) for repeat in range(averaging): simulation = Simulation( topology=topology, packet_rate=packet_rate, packet_size=packet_size, simulation_duration=simulation_duration, sf=PacketSf.SF_Random) simulation_result = simulation.run() # simulation.show_results() # simulation.write_to_file('output/sim_r{}_n{}_g{}_p{}_s{}.png'.format(radius, number_of_nodes, number_of_gws, packet_rate, simulation_duration)) X_train, X_test, y_train, y_test = simulation.get_training_data( test_size=0.2) DT_classifier = DecisionTreeClassifier(class_weight='balanced') DT_classifier.fit(X_train, y_train) y_pred = DT_classifier.predict(X_test) prediction_dt_acc_averaging_sum += accuracy_score( y_test, y_pred) * 100 # print(classification_report(y_test, y_pred)) # print(confusion_matrix(y_test, y_pred, labels=[1, 2, 3])) SVM_classifier = svm.SVC(class_weight='balanced', gamma='auto') SVM_classifier.fit(X_train, y_train) y_pred = SVM_classifier.predict(X_test) prediction_svm_acc_averaging_sum += accuracy_score( y_test, y_pred) * 100 # print(classification_report(y_test, y_pred)) # print(confusion_matrix(y_test, y_pred, labels=[1, 2, 3])) print('number_of_nodes={}, radius={}'.format( number_of_nodes, radius)) print('accuracy SVM={:.1f}, DTC={:.1f}'.format( prediction_svm_acc_averaging_sum / averaging, prediction_dt_acc_averaging_sum / averaging))
print(' SF assignment method: {}'.format(args.sf)) if PacketSf[args.sf] == PacketSf.SF_Smart: print(' Smart SF classifier: {}'.format(args.classifier)) print(' Simulation duration: {} seconds'.format(args.duration)) print(' Packet rate: {} packet per second'.format(args.packetRate)) print(' Packet interval: {} seconds'.format(1/args.packetRate)) print(' Packet size: {} bytes'.format(args.packetSize)) print(' Percentage of periodic nodes {}: {}'.format([type.name for type in TrafficType], args.nodeTraffic)) print(' Random number generator seed: {}'.format(args.seed)) print(' Events log path: {}'.format(args.event)) print(' Verbose level: {}'.format(args.verbose)) if args.seed: random.seed(args.seed) topology = Topology.create_random_topology(number_of_nodes=args.node, radius=args.radius, number_of_gws=args.gateway, node_traffic_proportions=args.nodeTraffic) sfPredictor = None if PacketSf[args.sf] == PacketSf.SF_Smart: simulation = Simulation(topology=topology, packet_rate=args.packetRate, packet_size=args.packetSize, simulation_duration=args.duration, sf=PacketSf.SF_Random) simulation.run() X_train, X_test, y_train, y_test = simulation.get_training_data(test_size=0.2) classifier = None if args.classifier == 'DTC': classifier = DecisionTreeClassifier(class_weight='balanced') elif args.classifier == 'SVM': classifier = svm.SVC(class_weight='balanced', gamma='auto') classifier.fit(X_train, y_train) y_pred = classifier.predict(X_test)
def plot_prediction(number_of_nodes_list, averaging, topology_radius, number_of_gws, packet_rate, packet_size, simulation_duration, traffic_type): prediction_name_list = [ PacketSf.SF_Random.name, 'SF_Smart_DTC', 'SF_Smart_SVM', PacketSf.SF_Lowest.name ] prediction_pdr_figure = SimulationFigure(number_of_nodes_list, prediction_name_list) prediction_energy_figure = SimulationFigure(number_of_nodes_list, prediction_name_list) for number_of_nodes in number_of_nodes_list: random_simulation_result_sum = SimulationResult() prediction_dt_simulation_result_sum = SimulationResult() prediction_svm_simulation_result_sum = SimulationResult() lowest_simulation_result_sum = SimulationResult() sys.stdout.write('.') sys.stdout.flush() topology = Topology.create_random_topology( number_of_nodes=number_of_nodes, radius=topology_radius, number_of_gws=number_of_gws, node_traffic_proportions=traffic_type) for repeat in range(averaging): simulation = Simulation(topology=topology, packet_rate=packet_rate, packet_size=packet_size, simulation_duration=simulation_duration, sf=PacketSf.SF_Random) random_simulation_result_sum += simulation.run() X_train, X_test, y_train, y_test = simulation.get_training_data( test_size=0) DT_classifier = DecisionTreeClassifier(class_weight='balanced') DT_classifier.fit(X_train, y_train) SVM_classifier = svm.SVC(class_weight='balanced', gamma='auto') SVM_classifier.fit(X_train, y_train) simulation = Simulation(topology=topology, packet_rate=packet_rate, packet_size=packet_size, simulation_duration=simulation_duration, sf=PacketSf.SF_Smart, sfPredictor=DT_classifier.predict) prediction_dt_simulation_result_sum += simulation.run() simulation = Simulation(topology=topology, packet_rate=packet_rate, packet_size=packet_size, simulation_duration=simulation_duration, sf=PacketSf.SF_Smart, sfPredictor=SVM_classifier.predict) prediction_svm_simulation_result_sum += simulation.run() simulation = Simulation(topology=topology, packet_rate=packet_rate, packet_size=packet_size, simulation_duration=simulation_duration, sf=PacketSf.SF_Lowest) lowest_simulation_result_sum += simulation.run() prediction_pdr_figure.plot_data[PacketSf.SF_Random.name].append( float(random_simulation_result_sum.pdr) / averaging) prediction_pdr_figure.plot_data['SF_Smart_DTC'].append( float(prediction_dt_simulation_result_sum.pdr) / averaging) prediction_pdr_figure.plot_data['SF_Smart_SVM'].append( float(prediction_svm_simulation_result_sum.pdr) / averaging) prediction_pdr_figure.plot_data[PacketSf.SF_Lowest.name].append( float(lowest_simulation_result_sum.pdr) / averaging) prediction_energy_figure.plot_data[PacketSf.SF_Random.name].append( float(random_simulation_result_sum.txEnergyConsumption) / averaging) prediction_energy_figure.plot_data['SF_Smart_DTC'].append( float(prediction_dt_simulation_result_sum.txEnergyConsumption) / averaging) prediction_energy_figure.plot_data['SF_Smart_SVM'].append( float(prediction_svm_simulation_result_sum.txEnergyConsumption) / averaging) prediction_energy_figure.plot_data[PacketSf.SF_Lowest.name].append( float(lowest_simulation_result_sum.txEnergyConsumption) / averaging) prediction_pdr_figure.get_plot(xlabel='Number of nodes', ylabel='PDR (%)', xlim_left=0, xlim_right=1000) plt.legend(loc='upper right', fontsize='small', title='SF') plt.savefig('output/prediction_pdr_r{}_g{}_p{}_s{}.png'.format( topology_radius, number_of_gws, packet_rate, simulation_duration), dpi=200, transparent=True) prediction_energy_figure.get_plot(xlabel='Number of nodes', ylabel='Transmit energy consumption (J)', xlim_left=0, xlim_right=1000) plt.legend(loc='upper left', fontsize='small', title='SF') plt.savefig('output/prediction_energy_r{}_g{}_p{}_s{}.png'.format( topology_radius, number_of_gws, packet_rate, simulation_duration), dpi=200, transparent=True)
def prediction_pdr(averaging, number_of_gws, packet_rate, packet_size, simulation_duration, traffic_type): for radius in [3000, 5000, 7000, 10000]: for number_of_nodes in [100, 500, 1000]: prediction_dt_pdr_averaging_sum = 0 prediction_svm_pdr_averaging_sum = 0 lowest_pdr_averaging_sum = 0 topology = Topology.create_random_topology( number_of_nodes=number_of_nodes, radius=radius, number_of_gws=number_of_gws, node_traffic_proportions=traffic_type) for repeat in range(averaging): simulation = Simulation( topology=topology, packet_rate=packet_rate, packet_size=packet_size, simulation_duration=simulation_duration, sf=PacketSf.SF_Random) simulation_result = simulation.run() X_train, X_test, y_train, y_test = simulation.get_training_data( test_size=0) DT_classifier = DecisionTreeClassifier(class_weight='balanced') DT_classifier.fit(X_train, y_train) SVM_classifier = svm.SVC(class_weight='balanced', gamma='auto') SVM_classifier.fit(X_train, y_train) simulation = Simulation( topology=topology, packet_rate=packet_rate, packet_size=packet_size, simulation_duration=simulation_duration, sf=PacketSf.SF_Smart, sfPredictor=DT_classifier.predict) simulation_result = simulation.run() prediction_dt_pdr_averaging_sum += simulation_result.pdr simulation = Simulation( topology=topology, packet_rate=packet_rate, packet_size=packet_size, simulation_duration=simulation_duration, sf=PacketSf.SF_Smart, sfPredictor=SVM_classifier.predict) simulation_result = simulation.run() prediction_svm_pdr_averaging_sum += simulation_result.pdr simulation = Simulation( topology=topology, packet_rate=packet_rate, packet_size=packet_size, simulation_duration=simulation_duration, sf=PacketSf.SF_Lowest) simulation_result = simulation.run() lowest_pdr_averaging_sum += simulation_result.pdr print('number_of_nodes={}, radius={}'.format( number_of_nodes, radius)) print('pdr L={:.1f}, SWM={:.1f}, DTC={:.1f}'.format( lowest_pdr_averaging_sum / averaging, prediction_svm_pdr_averaging_sum / averaging, prediction_dt_pdr_averaging_sum / averaging))