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))
