def test_step(batch_size, data_transform, dataset_folder, model, test_data):
model.train(False)
test_score = 0
for batch_index in range(0, len(test_data), batch_size):
batch = test_data[batch_index:batch_index + batch_size]
input = []
tags = []
for img_name, _tag in batch:
img = Image.open(f'{dataset_folder}/{img_name}.jpg').convert('RGB')
try:
input.append(data_transform(img).numpy())
except:
print(f"Wrong image {img_name}")
continue
tags.append(int(_tag))
input = numpy.array(input).astype(numpy.float32)
tags = numpy.array(tags).astype(numpy.long)
input = Variable(torch.from_numpy(input), requires_grad=True)
tags = Variable(torch.from_numpy(tags), requires_grad=False)
if CUDA_ENABLED:
input = input.cuda()
tags = tags.cuda()
output = model(input)
_, preds = torch.max(output.data, 1)
_, true_tags = torch.max(tags.data, 0)
test_score += torch.sum(preds == true_tags)
print(f"Test score {test_score / len(test_data) * 100}%")
def imgshow(images, classes):
import matplotlib.pyplot as plt
inp = images.numpy().transpose((1, 2, 0))
mean = numpy.array([0.485, 0.456, 0.406])
std = numpy.array([0.229, 0.224, 0.225])
inp = std * inp + mean
inp = numpy.clip(inp, 0, 1)
plt.imshow(inp)
plt.title(classes)
def generate_response(model_path, data_folder, csv_out):
model = create_net(model_path)
transform = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
images = [
f"{i}.jpg" for i in range(11100)
if os.path.isfile(f"{data_folder}/{i}.jpg")
]
with open(csv_out, "w") as out:
writer = csv.writer(out)
for i in range(0, 11100, 35):
try:
batch_images = [
transform(
Image.open(f'{data_folder}/{img_name}').convert(
'RGB')).numpy() for img_name in images[i:i + 35]
]
except IOError:
continue
if not batch_images:
break
array = numpy.array(batch_images).astype(numpy.float32)
input_data = Variable(torch.from_numpy(array))
if CUDA_ENABLED:
input_data = input_data.cuda()
outs = model(input_data)
image_names = [img_name.split(".")[0] for img_name in images[i:i + 35]]
_, preds = torch.max(outs.data, 1)
rows = []
for i in range(len(image_names)):
row = image_names[i], int(preds[i])
print(row)
rows.append(row)
with open(csv_out, "a") as out:
writer = csv.writer(out)
writer.writerows(rows)
def train_step(batch_size, criterion, data_transform, dataset_folder,
exp_lr_scheduler, model, optimizer, train_data):
# exp_lr_scheduler.step()
model.train(True)
epoch_score = 0
epoch_loss = 0
total_elements = 0
for batch_index in range(0, len(train_data), batch_size):
batch = train_data[batch_index:batch_index + batch_size]
input = []
tags = []
for img_name, _tag in batch:
img = Image.open(f'{dataset_folder}/{img_name}.jpg').convert('RGB')
try:
input.append(data_transform(img).numpy())
except:
print(f"Wrong image {img_name}")
continue
tags.append(int(_tag))
if tags[-1] == 2:
continue
input.append(data_transform(img).numpy())
tags.append(int(_tag))
# print(f"{batch_index} - [{img_name}|{TAGS_TRANSLATION[_tag]}] ({input[-1].shape})")
input = numpy.array(input).astype(numpy.float32)
tags = numpy.array(tags).astype(numpy.long)
input = Variable(torch.from_numpy(input), requires_grad=True)
tags = Variable(torch.from_numpy(tags), requires_grad=False)
if CUDA_ENABLED:
input = input.cuda()
tags = tags.cuda()
optimizer.zero_grad()
output = model(input)
loss = criterion(output, tags)
loss.backward()
optimizer.step()
_, preds = torch.max(output.data, 1)
true_tags = tags.data
batch_ac = 0
for i in range(len(true_tags)):
batch_ac += 1 if preds[i] == true_tags[i] else 0
batch_loss = loss.item()
elements = len(tags)
total_elements += elements
print(
f"Batch {batch_index // batch_size} - Ac: {batch_ac / elements} Loss: {batch_loss / elements}"
)
print(f"{preds.cpu().numpy()}\n{true_tags.cpu().numpy()}")
epoch_score += batch_ac
epoch_loss += batch_loss
print(f"Epoch score {epoch_score / total_elements * 100}%")
print(f"Epoch loss {epoch_loss / total_elements * 100}%")
def GgenerationHTML(_reseau):
"""
Génère l'html de l'affichage à partir d'un réseau
Algorithme tiré de l'exemple : https://plot.ly/python/network-graphs/
L'affichage est décomposée. Ainsi les arcs puis les noeuds sont affichés en trois parties : les dominants et
les non dominants, ainsi que les déconnectés
:param _reseau : Reseau, le réseau à traiter
:return String, le code HTML
"""
_log.Linfo("Début ## Generateur.GgenerationHTML")
# Récupération, pour commencer, l'ensemble des noeuds déconnectés
from Moteur.Simulateur import Simulateur
_simulateur = Simulateur(None)
# On test si on est dans le cas du cycle 0, si c'est le cas on cherche si la fin de vie est atteinte avec la
# méthode adéquate
from Controleur.Statistiques import Statistiques
_statistiques = Statistiques()
if len(_statistiques.S_cycles) == 0 or max(
_statistiques.S_cycles) == 0:
_intervalle = 0
else:
_intervalle = -1
_, _ensemble_deconnecte = _simulateur.SfinDeVieAtteinte(
_reseau, _intervalle)
# ==============================================================================================================
# Paramétrage des arcs
# ==============================================================================================================
colors = []
colors_dominant = []
_arcs = []
_arcs_dominants = []
# Choix des couleurs en premier.
# Les arcs de l'ensemble dominant sont rouges, les autres bleus clairs
# Les arcs déconnectés de l'ensemble dominant sont noirs, les autres gris
# Auss idécomposition des arcs en deux partis, ceux de l'ensemble dominant et les autres
for _arc in _reseau.R_graphe.edges():
if _arc in _reseau.R_ensemble_dominant.edges():
_arcs_dominants.append(_arc)
if _arc[0] in _ensemble_deconnecte or _arc[
1] in _ensemble_deconnecte:
colors_dominant.append("black")
else:
colors_dominant.append("red")
else:
_arcs.append(_arc)
if _arc[0] in _ensemble_deconnecte or _arc[
1] in _ensemble_deconnecte:
colors.append("gray")
else:
colors.append("#A9D0F5")
# Données des arcs non dominants à afficher
edge_trace = [
dict(type='scatter',
x=[
_reseau.R_graphe.node[edge[0]]['pos'][0],
_reseau.R_graphe.node[edge[1]]['pos'][0]
],
y=[
_reseau.R_graphe.node[edge[0]]['pos'][1],
_reseau.R_graphe.node[edge[1]]['pos'][1]
],
mode='lines',
line=dict(width=2, color=colors[c]))
for c, edge in enumerate(_arcs)
]
# Données des arcs dominants à afficher
edge_trace_dominant = [
dict(type='scatter',
x=[
_reseau.R_graphe.node[edge[0]]['pos'][0],
_reseau.R_graphe.node[edge[1]]['pos'][0]
],
y=[
_reseau.R_graphe.node[edge[0]]['pos'][1],
_reseau.R_graphe.node[edge[1]]['pos'][1]
],
mode='lines',
line=dict(width=2, color=colors_dominant[c]))
for c, edge in enumerate(_arcs_dominants)
]
# ==============================================================================================================
# Paramétrage des noeuds
# ==============================================================================================================
_nodes_pos = []
_nodes_pos_dominant = []
_nodes_pos_deconnectes = []
# Décomposition des arcs en trois parties, les noeuds dominants, les déconnectés et le reste
for _noeud in _reseau.R_graphe.nodes():
if _reseau.R_graphe.node[_noeud]['role'] != Roles.PUIT:
if _noeud in _ensemble_deconnecte:
_nodes_pos_deconnectes.append([
_reseau.R_graphe.node[_noeud]['pos'][0],
_reseau.R_graphe.node[_noeud]['pos'][1]
])
elif _noeud in _reseau.R_ensemble_dominant.nodes():
_nodes_pos_dominant.append([
_reseau.R_graphe.node[_noeud]['pos'][0],
_reseau.R_graphe.node[_noeud]['pos'][1]
])
else:
_nodes_pos.append([
_reseau.R_graphe.node[_noeud]['pos'][0],
_reseau.R_graphe.node[_noeud]['pos'][1]
])
_nodes_pos = numpy.array(_nodes_pos)
_nodes_pos_dominant = numpy.array(_nodes_pos_dominant)
_nodes_pos_deconnectes = numpy.array(_nodes_pos_deconnectes)
# Données des noeuds à afficher
_x, _y = [], []
for _pos in _nodes_pos:
_x.append(_pos[0])
_y.append(_pos[1])
node_trace = dict(
type='scatter',
x=_x,
y=_y,
hoverinfo='text',
text=[],
mode='markers',
marker=dict(
showscale=True,
cmax=FenetreCreation.FCobtenirCapaciteMaxBatterie(),
cmin=0,
# colorscale options
# 'Greys' | 'YlGnBu' | 'Greens' | 'YlOrRd' | 'Bluered' | 'RdBu' |
# 'Reds' | 'Blues' | 'Picnic' | 'Rainbow' | 'Portland' | 'Jet' |
# 'Hot' | 'Blackbody' | 'Earth' | 'Electric' | 'Viridis' |
colorscale='Reds',
reversescale=True,
color=[],
size=10,
colorbar=dict(thickness=15,
title='Niveau de la batterie',
xanchor='left',
titleside='right')))
# Données des noeuds dominants à afficher
_x, _y = [], []
for _pos in _nodes_pos_dominant:
_x.append(_pos[0])
_y.append(_pos[1])
node_trace_dominant = dict(
type='scatter',
x=_x,
y=_y,
hoverinfo='text',
text=[],
mode='markers',
marker=dict(
showscale=False,
cmax=FenetreCreation.FCobtenirCapaciteMaxBatterie(),
cmin=0,
# colorscale options
# 'Greys' | 'YlGnBu' | 'Greens' | 'YlOrRd' | 'Bluered' | 'RdBu' |
# 'Reds' | 'Blues' | 'Picnic' | 'Rainbow' | 'Portland' | 'Jet' |
# 'Hot' | 'Blackbody' | 'Earth' | 'Electric' | 'Viridis' |
colorscale='Reds',
reversescale=True,
color=[],
size=10,
colorbar=dict(thickness=15,
title='Niveau de la batterie',
xanchor='left',
titleside='right'),
line=dict(width=2, color="red")))
# Données des noeuds déconnectés à afficher
_x, _y = [], []
for _pos in _nodes_pos_deconnectes:
_x.append(_pos[0])
_y.append(_pos[1])
if len(_nodes_pos_deconnectes) > 0:
node_trace_deconnecte = dict(
type='scatter',
x=_x,
y=_y,
hoverinfo='text',
text=[],
mode='markers',
marker=dict(
showscale=False,
# colorscale options
# 'Greys' | 'YlGnBu' | 'Greens' | 'YlOrRd' | 'Bluered' | 'RdBu' |
# 'Reds' | 'Blues' | 'Picnic' | 'Rainbow' | 'Portland' | 'Jet' |
# 'Hot' | 'Blackbody' | 'Earth' | 'Electric' | 'Viridis' |
colorscale='Reds',
reversescale=True,
color=[],
size=10,
line=dict(width=0)))
else:
node_trace_deconnecte = []
# Si il n'y a pas de données à afficher dans les noeuds, l'échelle de couleurs ne s'affiche pas.
# On fait donc en sorte que l'échelle des noeuds dominants s'affiche à la place.
if len(_nodes_pos) == 0:
node_trace_dominant["marker"]["showscale"] = True
_texte_puit = ""
# Ajout des informations pour l'affichage d'informations supplémentaires
# - Le texte qui s'affiche au survole d'un noeud avec la souris
# - la couleur du noeud
for node, adjacencies in enumerate(_reseau.R_graphe.adjacency()):
# Le puit est dessiné en violet et les capteurs en nuance de couleur en fonction du niveau de leur batterie
# Sont affichés au passage de la souris :
# - Le prochain noeud vers lequel envoyer les données
# - l'énergie restante (si ce n'est pas un puit, si c'est le cas sa couleur est mise en violet). Si il
# n'a plus d'énergie, sa couleur est mise en noir
# - le nombre de capteurs adjacent (si c'est le puit)
if _reseau.R_graphe.node[node]['role'] == Roles.PUIT:
_texte_puit = "Passerelle | " + str(len(
adjacencies[1])) + " capteurs adjacents"
else:
node_info = "Capteur n°" + str(node) + " | " + \
"Nv batterie : " + str(int(_reseau.R_graphe.node[node]['batterie'])) + " | " + \
"Route : " + str(_reseau.R_graphe.node[node]['route'])
if node in _ensemble_deconnecte:
if _reseau.R_graphe.nodes()[node]['batterie'] > 0:
node_trace_deconnecte['marker']['color'] += tuple(
['gray'])
else:
node_trace_deconnecte['marker']['color'] += tuple(
['black'])
node_trace_deconnecte['text'] += tuple([node_info])
elif node in _reseau.R_ensemble_dominant:
node_trace_dominant['marker']['color'] += tuple(
[_reseau.R_graphe.node[node]['batterie']])
node_trace_dominant['text'] += tuple([node_info])
else:
node_trace['marker']['color'] += tuple(
[_reseau.R_graphe.node[node]['batterie']])
node_trace['text'] += tuple([node_info])
# Le puit à afficher différemment
_puits_trace = []
for _noeud in _reseau.R_graphe.nodes():
if _reseau.R_graphe.node[_noeud]['role'] == Roles.PUIT:
_puits_trace.append(
dict(type='scatter',
x=[_reseau.R_graphe.node[_noeud]['pos'][0]],
y=[_reseau.R_graphe.node[_noeud]['pos'][1]],
hoverinfo='text',
text=_texte_puit,
mode='markers',
marker=dict(showscale=False,
colorscale='Greys',
reversescale=True,
color='yellow',
symbol=['pentagon'],
size=20,
line=dict(width=2, color="red"))))
# On concatène l'ensemble des données, arcs et noeuds, à afficher. L'affiche est supperposé de gauche à droite
if len(_nodes_pos_deconnectes) > 0:
_datas = edge_trace + [node_trace] + edge_trace_dominant + [
node_trace_deconnecte
] + [node_trace_dominant] + _puits_trace
else:
_datas = edge_trace + [node_trace] + edge_trace_dominant + [
node_trace_dominant
] + _puits_trace
# La création de la figure finale à afficher
fig = go.Figure(data=_datas,
layout=go.Layout(title='',
titlefont=dict(size=16),
showlegend=False,
hovermode='closest',
margin=dict(b=20, l=5, r=5, t=40),
annotations=[
dict(text="",
showarrow=False,
xref="paper",
yref="paper",
x=0.005,
y=-0.002)
],
xaxis=dict(showgrid=False,
zeroline=False,
showticklabels=False),
yaxis=dict(showgrid=False,
zeroline=False,
showticklabels=False)))
# Pour finir génération du html
html = plotly.offline.plot(fig, auto_open=False, output_type='div')
return """<html><head><meta charset="utf-8" /></head><body><script type="text/javascript">window.PlotlyConfig =
{MathJaxConfig: 'local'};</script>""" \
+ html \
+ """<script type="text/javascript">window.addEventListener("resize", function(){Plotly.Plots.resize(docu