def test(net, testset_size=2500, batch_size=4):
texts.print_blox("TESTE")
testloader, classes = dm.load_testset_CIFAR10(batch_size)
correct = 0
total = 0
class_correct = list(0. for i in range(10))
class_total = list(0. for i in range(10))
with torch.no_grad():
for i, data in enumerate(testloader, 0):
images, labels = data
outputs = net(images)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
c = (predicted == labels).squeeze()
if (batch_size > 1):
for j in range(batch_size):
label = labels[j]
class_correct[label] += c[j].item()
class_total[label] += 1
else:
label = labels[0]
class_correct[label] += c
class_total[label] += 1
if (i == testset_size - 1):
break
print('Accuracy of the network on the ' + str(testset_size * batch_size) +
' test images: %d%%' % (100 * correct / total))
for i in range(10):
print('Accuracy of %5s: %2d%%' %
(classes[i], 100 * class_correct[i] / class_total[i]))
print()
def printData(op="standard"):
texts.print_blox("DADOS")
matrix = openData(op)
if (type(matrix) == int):
return # Se matrix recebeu um inteiro quer dizer que há um erro no arquivo.
A1, B1, A2, B2 = matrixToSystems(matrix)
printSystem(A1, B1, A2, B2)
def menu(error_message=False):
aux.clear_screen()
a = getDataInputConfigs()
if (a == 0): return
texts.print_blox("CONFIGURAÇÕES")
if (error_message):
aux.error_option()
print("Formato dos dados: ", end="")
if (a == '1'):
aux.printc("purple", "Matrizes e vetores separados em arquivos.\n")
elif (a == '0'):
aux.printc("purple", "Os 2 sistemas em um só arquivo.\n")
options()
def load_model(net):
texts.print_blox("CARREGAR")
path = 'architectures'
# print("PATH: ", os.getcwd())
print("Arquivos encontrados:\n")
files = os.listdir(path)
for i in files:
if (not i.endswith('~')):
aux.printc("lyellow", i)
name = input("\nInsira o nome do arquivo: ")
path = path + '/' + name
if(any(name == i for i in files)):
net.load_state_dict(torch.load(path))
print("Sucesso no carregamento!\n")
else:
aux.printc("red", "O arquivo "+path+" não foi encontrado!\n")
aux.press_enter()
def train(net, epochs, trainset_size=12500, batch_size=4, learning_rate=0.001):
texts.print_blox("TREINO")
# TRAINING:
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=learning_rate, momentum=0.9)
trainloader, classes = dm.load_trainset_CIFAR10(batch_size)
print("Training features:")
print("Images: %i" % (trainset_size * batch_size))
print("Mini-batch size: %i" % (batch_size))
print("Learning rate: %.3f" % (learning_rate))
print("Epochs: %i" % (epochs))
print("")
for epoch in range(epochs): # loop over the dataset multiple times
running_loss = 0.0
acc = 0.0
for i, data in enumerate(trainloader, 0):
inputs, labels = data # get the inputs
optimizer.zero_grad() #zero the parameter gradients
# forward + backward + optimize
outputs = net(inputs)
# print("Labels:", labels)
# print("outputs:", outputs)
acc += (outputs.max(dim=1)[1] == labels).sum()
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
# print statistics
running_loss += loss.item(
) # Returns the value of this tensor as a standard Python number. This only works for tensors with one element.
progressBar.printProgressBar(i,
trainset_size - 1,
prefix='Epoch ' + str(epoch + 1) +
':',
suffix='Complete',
length=50)
if i == trainset_size - 1:
print("Report: ", end='')
print('[Loss: %.3f; Hits: %i; Acc: %.1f%%]' %
(running_loss / trainset_size, acc, float(acc) /
(1.0 * trainset_size * batch_size) * 100.0))
break
print("Finished training!\n")
def menu(error_message=False): aux.clear_screen() texts.print_blox() if(error_message): aux.error_option() options()
def save_model(net):
texts.print_blox("SALVAR")
name = input("Insira o nome com o qual deseja salvar: ")
path = 'architectures/' + name
torch.save(net.state_dict(), path)
print("Salvo com sucesso!\n")
def solve(op="standard"):
# Carregando os dados dos arquivos:
texts.print_blox("RESOLUÇÃO")
matrix = dm.openData(
op) # Se o formato retornado por openData for int, quer dizer que
if (type(matrix) == int):
return # a matriz não foi armazenada adequadamente.
A1, B1, A2, B2 = dm.matrixToSystems(matrix)
# Testes de compatibilidade da matriz:
if (not (math.isSquared(A1) and math.isSquared(A2))
): # Testando se a matriz é quadrada (necessário
printc("red", "As matrizes precisam ser quadradas!"
) # para aplicação de Gauss do nosso caso)
return
if (np.shape(A1)[1] != np.shape(A2)[1]):
printc(
"red",
"As matrizes precisam ter o mesmo número de colunas para a interpolação!"
)
return
if (
not math.diagonalTest(A2)
): # E se a diagonal da matriz 2 não possui elemento muito pequeno (necessário para
printc(
"red",
"A matriz 2 não pode ter elementos nulos ou muito pequenos na diagonal principal!"
) # Gauss-Jacobi)
return
# Calculando os resultados:
precision = dm.getPrecision(op) # Obtém a precisão
if (math.diagonalTest(A1)):
x, iterator_g = math.GaussElimination(
A1.copy(), B1) # Verifica se deve resolver por Gauss
else:
x, iterator_g = math.GaussEliminationPivoting(
A1.copy(), B1) # com ou sem pivotamento (parcial)
p, iterator_gj = math.GaussJacobi(A2, B2, precision)
weak = math.mean(x)
wp = math.NewtonInterpolation(x.copy(), p.copy(), weak.copy(), 2)
# Printando a resolução:
print("")
if (math.diagonalTest(A1)):
print(" -> Solução do sistema 1 (por eliminação de Gauss):")
else:
print(
" -> Solução do sistema 1 (por eliminação de Gauss com pivotamento parcial):"
)
print(" (Pontos amostrais da ponte)\n")
printc("blue", " x: " + str(x))
printc("blue", " Número de iterações: " + str(iterator_g))
printc("blue", " Ponto mais frágil (p): " + str(weak) + '\n')
print(" -> Solução do sistema 2 (com Gauss-Jacobi):")
print(" (Respectivas pressões dos pontos amostrais)\n")
if (math.GaussJacobiConvergence(A2)):
printc("lyellow", " Satisfaz o critério das linhas!")
else:
printc("lred", " Não satisfaz o critério das linhas!")
if (isnan(p[0])):
printc("lred", " Não foi possível resolver o sistema 2.")
printc("lred",
" Consequentemente não resolveu a interpolação.\n")
return
printc("blue", " x: " + str(p))
printc("blue", " Número de iterações: " + str(iterator_gj))
printc("blue", " Precisão: " + str(precision) + '\n')
print(" -> Interpolação quadrática do sistema 2 (com forma de Newton):")
print(" (Aproximação da pressão no ponto mais frágil da ponte)\n")
if (not math.InterpolationCondition(x)):
printc("red", " O vetor x não pode ter valores iguais!\n")
else:
printc("blue", " Pressão de p: " + str(wp) + '\n')