def main():
#'test'
import plot
n=10000 #number of steps
x=np.linspace(0,4, n)
y= np.array([])
cos=np.array([])
sign = SignHyst(line_up=1, line_down=-1, up=2, down = -2, last_x =-0.01, last_t = -0.01)
for t in x:
q= 4*functions.sin(t)
y=np.append(y,sign.get_response_operezenie(t,q))
cos = np.append(cos,q)
plot.draw_plot(x,y,'t','y','test')
plot.draw_plot(cos,y,'q','y','test')
def main():
'test'
import plot
n = 1000 #number of steps
x = np.linspace(0, 10, n)
y = np.array([])
cos = np.array([])
blash = Backlash(trashold=functions.sin(x[0]))
for t in x:
q = functions.sin(t)
y = np.append(y, blash.get_response(t, q))
cos = np.append(cos, q)
for t in range(10):
print(
f'ask time {t}, fun {functions.sin(t)} get blash is {blash.get_response(t,functions.sin(t))}'
)
plot.draw_plot(x, y, 't', 'y', 'test')
plot.draw_plot(cos, y, 'q', 'y', 'test')
def main1(phase_trace=False, transition=False, phase_plane=False):
'''Решение уравнения и построения графика'''
if phase_plane == True:
equa = EquationClass.Equation.get_instance()
solve = second_ode_solver(set_function_system, equa.ic,
[equa.time_start, equa.time_end], equa.step)
t, y = solve.t, solve.y
if equa.size == 1:
del equa
plot.draw_plot(t, y[0], 't, с', 'x1, значение',
'Решение уравнения')
elif equa.size == 2:
dots = equa.dots
equa.dot_window = new_winF(dots, 3)
del equa
plot.draw_plot(y[0], y[1], 'x1, значение', 'x2, значение',
'Фазовая траектория')
else:
g = equa.G
l1 = equa.l1
l2 = equa.l2
dots = equa.dots
equa.dot_window = new_winF(dots, 4)
plot.draw_3d_plot(y[0], y[1], y[2], 'x1, значение', 'x2, значение',
'x3, значение', 'Фазовое пространство', g, l1,
l2, dots)
return
else:
equa = EquationClass.Equation.get_instance()
equa.array = np.array([])
equa.ardx = []
solve = second_ode_solver(set_function_2rank, (equa.y0, equa.dy0),
[equa.time_start, equa.time_end], equa.step)
t, y = solve.t, solve.y
EquationClass.Equation.created = False
del equa
if transition:
plot.draw_plot(t, y[0], 't, с', 'y, значение', 'Решение уравнения')
if phase_plane:
plot.draw_3d_plot(y[0], y[1], y[2], 'y, значение', 'dy, значение',
'd2y, значение', 'Фазовая плоскость')
if phase_trace:
plot.draw_plot(y[0], y[1], 'y, значение', 'dy, значение',
'Фазовая траектория')
def main(phase_trace=False, transition=False, phase_plane=False):
'''Решение уравнения и построения графика'''
if phase_plane == True: # Если запущено построение фазовой плоскости
equa = EquationClass.Equation.get_instance(
) # Находим обьект уравнения содержащий функции и переменные
solve = second_ode_solver(set_function_system, equa.ic,
[equa.time_start, equa.time_end],
equa.step) # Интегрируем
t, y = solve.t, solve.y # Записуем результат интегрирования
if equa.size == 1: # Если система первого порядка рисуем переходной процесс
del equa
plot.draw_plot(t, y[0], 't, с', 'x1, значение',
'Решение уравнения')
elif equa.size == 2: # Если система второго порядка рисуем фазовую траекторию
dots = equa.dots
equa.dot_window = new_winF(dots, 3)
del equa
plot.draw_plot(y[0], y[1], 'x1, значение', 'x2, значение',
'Фазовая траектория')
else: # Иначе рисуем фазовую плоскость
g = equa.G
l1 = equa.l1
l2 = equa.l2
dots = equa.dots
equa.dot_window = new_winF(dots, 4)
plot.draw_3d_plot(y[0], y[1], y[2], 'x1, значение', 'x2, значение',
'x3, значение', 'Фазовое пространство', g, l1,
l2, dots)
return
else: # Если решается фазовая траектория
equa = EquationClass.Equation.get_instance(
) # Находим обьект уравнения содержащий функции и переменные
solve = second_ode_solver(set_function_2rank, (equa.y0, equa.dy0),
[equa.time_start, equa.time_end],
equa.step) # Интегрируем
t, y = solve.t, solve.y # Записуем результат интегрирования
EquationClass.Equation.created = False # Удаляем уравнение
del equa
if transition: # Если рисуем переходной процесс
plot.draw_plot(t, y[0], 't, с', 'y, значение', 'Решение уравнения')
if phase_trace: # Если рисуем фазовую траекторию
plot.draw_plot(y[0], y[1], 'y, значение', 'dy, значение',
'Фазовая траектория')
def main():
parser = argparse.ArgumentParser('parameters')
parser.add_argument('--epochs',
type=int,
default=100,
help='number of epochs, (default: 100)')
parser.add_argument('--p',
type=float,
default=0.75,
help='graph probability, (default: 0.75)')
parser.add_argument(
'--c',
type=int,
default=78,
help='channel count for each node, 109, 154 (default: 154)')
parser.add_argument(
'--k',
type=int,
default=4,
help=
'each node is connected to k nearest neighbors in ring topology, (default: 4)'
)
parser.add_argument(
'--m',
type=int,
default=5,
help=
'number of edges to attach from a new node to existing nodes, (default: 5)'
)
parser.add_argument(
'--graph-mode',
type=str,
default="WS",
help="random graph, (Example: ER, WS, BA), (default: WS)")
parser.add_argument('--node-num',
type=int,
default=32,
help="Number of graph node (default n=32)")
parser.add_argument('--learning-rate',
type=float,
default=1e-1,
help='learning rate, (default: 1e-1)')
parser.add_argument('--batch-size',
type=int,
default=100,
help='batch size, (default: 100)')
parser.add_argument(
'--model-mode',
type=str,
default="CIFAR10",
help=
'CIFAR10, CIFAR100, SMALL_REGIME, REGULAR_REGIME, (default: CIFAR10)')
parser.add_argument(
'--dataset-mode',
type=str,
default="CIFAR10",
help=
'Which dataset to use? (Example, CIFAR10, CIFAR100, MNIST), (default: CIFAR10)'
)
parser.add_argument('--load-model', type=bool, default=False)
parser.add_argument('--is-train', type=bool, default=True)
args = parser.parse_args()
train_loader, test_loader = load_data(args)
if args.load_model:
model = Model(args.node_num, args.p, args.c, args.c, args.graph_mode,
args.model_mode, args.dataset_mode,
args.is_train).to(device)
filename = "c_" + str(args.c) + "_p_" + str(
args.p
) + "_graph_mode_" + args.graph_mode + "_dataset_" + args.dataset_mode
checkpoint = torch.load('./checkpoint/' + filename + 'ckpt.t7')
model.load_state_dict(checkpoint['model'])
epoch = checkpoint['epoch']
acc = checkpoint['acc']
print("Load Model Accuracy: ", acc, "Load Model end epoch: ", epoch)
else:
model = Model(args.node_num, args.p, args.c, args.c, args.graph_mode,
args.model_mode, args.dataset_mode,
args.is_train).to(device)
optimizer = optim.SGD(model.parameters(),
lr=args.learning_rate,
weight_decay=5e-4,
momentum=0.9)
criterion = nn.CrossEntropyLoss().to(device)
epoch_list = []
test_acc_list = []
train_acc_list = []
train_loss_list = []
max_test_acc = 0
if not os.path.isdir("reporting"):
os.mkdir("reporting")
start_time = time.time()
with open(
"./reporting/" + "c_" + str(args.c) + "_p_" + str(args.p) +
"_graph_mode_" + args.graph_mode + "_dataset_" +
args.dataset_mode + ".txt", "w") as f:
for epoch in range(1, args.epochs + 1):
# scheduler = CosineAnnealingLR(optimizer, epoch)
epoch_list.append(epoch)
train_loss, train_acc = train(model, train_loader, optimizer,
criterion, epoch, args)
test_acc = test(model, test_loader)
test_acc_list.append(test_acc)
train_loss_list.append(train_loss)
train_acc_list.append(train_acc)
print('Test set accuracy: {0:.3f}%'.format(test_acc))
f.write("[Epoch {0:3d}] Test set accuracy: {1:.3f}%".format(
epoch, test_acc))
f.write("\n ")
if max_test_acc < test_acc:
print('Saving..')
state = {
'model': model.state_dict(),
'acc': test_acc,
'epoch': epoch,
}
if not os.path.isdir('checkpoint'):
os.mkdir('checkpoint')
filename = "c_" + str(args.c) + "_p_" + str(
args.p
) + "_graph_mode_" + args.graph_mode + "_dataset_" + args.dataset_mode
torch.save(state, './checkpoint/' + filename + 'ckpt.t7')
max_test_acc = test_acc
draw_plot(epoch_list, train_loss_list, train_acc_list,
test_acc_list)
print("Training time: ", time.time() - start_time)
f.write("Training time: " + str(time.time() - start_time))
f.write("\n")
)
method = read_method(stdin)
print("Условия корректности метода:")
print(methods_requirements[method])
print("Выберите функцию и задайте коэффициенты:\n" \
"* polynomial - ax^n + bx^(n-1) + ... + c\n"
"* function - a * sin(bx) + c * cos(dx) + f * exp(gx) + h*log2(jx) + polynomial")
func = read_function(stdin)
print("Введите необходимую точность:")
precision = read_precision(stdin)
print("Введите интервал:")
interval = read_interval(stdin)
result = table = None
while (True):
try:
draw_plot(func, interval)
if (method == Method.CHORD):
if isinstance(func, Polynomial):
result, iterations = solve_polynomial(
func, interval, precision)
else:
result, iterations = chord_solve(func, interval, precision)
table = PrettyTable(
['№ шага', 'a', 'b', 'x', 'f(a)', 'f(b)', 'f(x)', '|a-b|'])
for row in iterations:
table.add_row(create_chord_method_row(func, row))
if (method == Method.SECANT):
result, iterations = secant_solve(func, interval, precision)
table = PrettyTable([
'№ шага', 'x_{k-1}', 'f(x_{k-1})', 'x_k', 'f(x_k)',
'x_{k+1}', 'f(x_{k+1})', '|x_k-x_{k+1}|'
classifier = bpnn.BPNN([[2,3,3,2],[bpnn.tanh,bpnn.tanh,bpnn.tanh]], 'none')
optimizer = bpnn.Optimizer(classifier)
optimizer.lr = 1
optimizer.lr_decay = bpnn.Learning_rate_decay.none
optimizer.lr_k = 0.1
optimizer.momentum_type = bpnn.Momentum.none
optimizer.mu = 0.9
optimizer.reg_type = bpnn.Regularization.none
optimizer.reg = 0.005
classifier.useOpt(optimizer)
train_loss_list, train_acc_list = classifier.train(X, y, epoch=79,batch_size=50)
plot.draw_plot(list(range(len(train_acc_list))), train_acc_list, "acc", 'epoch', 'acc', "acc.png")
sc.visualize(X, y , classifier)
# xs, acc_list, labels = [], [], []
# for i in range(5):
# classifier = bpnn.BPNN([[2,3 + i,3,2],[bpnn.tanh,bpnn.tanh,bpnn.unact]])
# train_loss_list, train_acc_list = classifier.train(X, y, lr=1, epoch=50, batch_size=20)
# acc_list.append(train_acc_list)
# xs.append([i for i in range(len(train_acc_list))])
# labels.append("layer1 node: " + str(i+3))
# plot.draw_plots(xs, acc_list, labels, ["red", "blue", "green", "yellow", "orange"], "acc", "epoch", "acc", "acc.png")
# layer1nodes = [i+2 for i in range(10)]
# lrs = [i/10 for i in range(1, 21)]
# z = []
def _draw_plots(self, observer):
width, height = self.surf.get_rect().size
plot_width = width - Plotter.text_width
id = observer.id
ts = self.particles[id]["ts"]
xs = self.particles[id]["xs"]
ys = self.particles[id]["ys"]
vxs = self.particles[id]["vxs"]
vys = self.particles[id]["vys"]
axs = self.particles[id]["axs"]
ays = self.particles[id]["ays"]
p_x0 = Plotter.text_width
p_x1 = p_x0 + (plot_width // 2)
p_w = plot_width // 2
p_h = height // 3
draw_plot(self.surf, pygame.Rect(p_x0, 0, p_w, p_h), ts, xs,
"x over time")
draw_plot(self.surf, pygame.Rect(p_x1, 0, p_w, p_h), ts, ys,
"y over time")
draw_plot(self.surf, pygame.Rect(p_x0, p_h, p_w, p_h), ts, vxs,
"Vx over time")
draw_plot(self.surf, pygame.Rect(p_x1, p_h, p_w, p_h), ts, vys,
"Vy over time")
draw_plot(self.surf, pygame.Rect(p_x0, p_h * 2, p_w, p_h), ts, axs,
"Ax over time")
draw_plot(self.surf, pygame.Rect(p_x1, p_h * 2, p_w, p_h), ts, ays,
"Ay over time")
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import pandas as pd
import plot
import data
import args
if __name__ == '__main__':
args = args.parse_arg()
data = data.Data(args.fname)
lat, lng = 54.68, 19.7
data.add_columns(data.calc_teos10_columns(lat, lng))
data.save_to_file('out.csv')
if args.show or args.save:
plot.draw_plot(data.data, args.x_column, args.y_column, args.x_range,
args.y_range, args.show, args.save)
