def svr():
#Resultados para a taxa de entrega
n = 30
flag = 1
cam = "C:/Users/joyce/Documents/joyce/dados-tcc/"
cam2 = "C:/Users/joyce/Documents/joyce/programsimulations/extraction_data/"
a = '0.1'
b = ['50', '60', '70', '80', '90', '95', '100']
c = '256'
data_simulations, icmin, icmax = de.data_formulation(n, flag, cam, a, b, c)
# x representa o dataset de treino e possui 23 colunas sem o atributo alvo
data_x = data_simulations.iloc[:, 0:3].values
# y representa o atributo alvo de x
data_y = data_simulations.iloc[:, 3:4].values
random.seed(1)
x_train, x_test, y_train, y_test = train_test_split(data_x,
data_y,
test_size=0.2,
random_state=0)
# Escalonamento de dados
scaler_train_x = StandardScaler()
scaler_train_y = StandardScaler()
scaler_test_x = StandardScaler()
scaler_test_y = StandardScaler()
u = scaler_test_x.fit_transform(x_test)
x = scaler_train_x.fit_transform(x_train)
y = scaler_train_y.fit_transform(y_train)
v = scaler_test_y.fit_transform(y_test)
#Uso de PCA no conjunto de teste para exibicao dos resultados de forma grafica
pca = PCA(n_components=1)
set_test = pca.fit_transform(u)
#Treinamento da SVR
svr = ml.optimize_parameters(SVR(), x, y, ml.definitions_algorithms('SVR'))
svr = SVR(kernel=svr['kernel'], gamma=svr['gamma'], C=svr['C'])
score, error, svr = ml.experiment_folds2('svr', svr, x, y)
print("Resultados após treinamento dos algoritmos")
print("Média do score -> ", score)
print("Média do erro -> ", error)
print("Modelo ->", svr)
#Pacote - 256
scaler_train_x = StandardScaler()
scaler_train_y = StandardScaler()
x1 = scaler_train_x.fit_transform(data_x)
y1 = scaler_train_y.fit_transform(data_y)
#Uso de PCA no conjunto de teste para exibicao dos resultados de forma grafica
pca = PCA(n_components=1)
set_test = pca.fit_transform(x1)
#Carregamento do modelo
print("Valores da simulação - conjunto de validação -> \n",
scaler_train_y.inverse_transform(y1))
simu1 = sorted(scaler_train_y.inverse_transform(y1))
print("Valores da predição - SVR -> \n",
sorted(scaler_train_y.inverse_transform(svr.predict(x1))))
pred1 = sorted(scaler_train_y.inverse_transform(svr.predict(x1)))
#Comparação entre valores da simulação e valores preditos - Taxa de entrega
vali = np.array(sorted([(x1[0], y1[0])
for x1, y1 in zip(set_test, simu1)]))
predi1 = np.array(sorted([(x1[0], y1) for x1, y1 in zip(set_test, pred1)]))
icmin = np.array(icmin)
icmax = np.array(icmax)
min = vali[:, 1] - icmin
max = icmax - vali[:, 1]
#Pacote de 512
c2 = '512'
data_simulations2, icmin2, icmax2 = de.data_formulation(
n, flag, cam, a, b, c2)
# x representa o dataset de treino e possui 23 colunas sem o atributo alvo
data_x2 = data_simulations2.iloc[:, 0:3].values
# y representa o atributo alvo de x
data_y2 = data_simulations2.iloc[:, 3:4].values
random.seed(1)
x_train2, x_test2, y_train2, y_test2 = train_test_split(data_x2,
data_y2,
test_size=0.2,
random_state=0)
# Escalonamento de dados
scaler_train_x2 = StandardScaler()
scaler_train_y2 = StandardScaler()
scaler_test_x2 = StandardScaler()
scaler_test_y2 = StandardScaler()
u2 = scaler_test_x2.fit_transform(x_test2)
x2 = scaler_train_x2.fit_transform(x_train2)
y2 = scaler_train_y2.fit_transform(y_train2)
v2 = scaler_test_y2.fit_transform(y_test2)
#Uso de PCA no conjunto de teste para exibicao dos resultados de forma grafica
pca2 = PCA(n_components=1)
set_test2 = pca2.fit_transform(u2)
#Treinamento da SVR
svr2 = ml.optimize_parameters(SVR(), x2, y2,
ml.definitions_algorithms('SVR'))
svr2 = SVR(kernel=svr2['kernel'], gamma=svr2['gamma'], C=svr2['C'])
score2, error2, svr2 = ml.experiment_folds2('svr', svr2, x2, y2)
print("Resultados após treinamento dos algoritmos")
print("Média do score -> ", score2)
print("Média do erro -> ", error2)
print("Modelo ->", svr2)
scaler_train_x2 = StandardScaler()
scaler_train_y2 = StandardScaler()
x3 = scaler_train_x2.fit_transform(data_x2)
y3 = scaler_train_y2.fit_transform(data_y2)
#Uso de PCA no conjunto de teste para exibicao dos resultados de forma grafica
pca2 = PCA(n_components=1)
set_test2 = pca2.fit_transform(x3)
#Carregamento do modelo
print("Valores da simulação - conjunto de validação -> \n",
scaler_train_y2.inverse_transform(y3))
simu2 = sorted(scaler_train_y2.inverse_transform(y3))
print("Valores da predição - SVR -> \n",
sorted(scaler_train_y2.inverse_transform(svr2.predict(x3))))
pred2 = sorted(scaler_train_y2.inverse_transform(svr2.predict(x3)))
#Comparação entre valores da simulação e valores preditos - Taxa de entrega
vali2 = np.array(
sorted([(x3[0], y3[0]) for x3, y3 in zip(set_test2, simu2)]))
predi2 = np.array(sorted([(x3[0], y3)
for x3, y3 in zip(set_test2, pred2)]))
icmin2 = np.array(icmin2)
icmax2 = np.array(icmax2)
min2 = vali2[:, 1] - icmin2
max2 = icmax2 - vali2[:, 1]
#Pacote de 1024
c3 = '1024'
data_simulations3, icmin3, icmax3 = de.data_formulation(
n, flag, cam, a, b, c3)
# x representa o dataset de treino e possui 23 colunas sem o atributo alvo
data_x3 = data_simulations3.iloc[:, 0:3].values
# y representa o atributo alvo de x
data_y3 = data_simulations3.iloc[:, 3:4].values
random.seed(1)
x_train3, x_test3, y_train3, y_test3 = train_test_split(data_x3,
data_y3,
test_size=0.2,
random_state=0)
# Escalonamento de dados
scaler_train_x3 = StandardScaler()
scaler_train_y3 = StandardScaler()
scaler_test_x3 = StandardScaler()
scaler_test_y3 = StandardScaler()
u3 = scaler_test_x3.fit_transform(x_test3)
x3 = scaler_train_x3.fit_transform(x_train3)
y3 = scaler_train_y3.fit_transform(y_train3)
v3 = scaler_test_y3.fit_transform(y_test3)
#Uso de PCA no conjunto de teste para exibicao dos resultados de forma grafica
pca3 = PCA(n_components=1)
set_test3 = pca3.fit_transform(u3)
#Treinamento da SVR
svr3 = ml.optimize_parameters(SVR(), x3, y3,
ml.definitions_algorithms('SVR'))
svr3 = SVR(kernel=svr3['kernel'], gamma=svr3['gamma'], C=svr3['C'])
score3, error3, svr3 = ml.experiment_folds2('svr', svr3, x3, y3)
print("Resultados após treinamento dos algoritmos")
print("Média do score -> ", score3)
print("Média do erro -> ", error3)
print("Modelo ->", svr3)
scaler_train_x3 = StandardScaler()
scaler_train_y3 = StandardScaler()
x4 = scaler_train_x3.fit_transform(data_x3)
y4 = scaler_train_y3.fit_transform(data_y3)
#Uso de PCA no conjunto de teste para exibicao dos resultados de forma grafica
pca3 = PCA(n_components=1)
set_test3 = pca3.fit_transform(x4)
#Carregamento do modelo
print("Valores da simulação - conjunto de validação -> \n",
scaler_train_y3.inverse_transform(y4))
simu3 = sorted(scaler_train_y3.inverse_transform(y4))
print("Valores da predição - SVR -> \n",
sorted(scaler_train_y3.inverse_transform(svr3.predict(x4))))
pred3 = sorted(scaler_train_y3.inverse_transform(svr3.predict(x4)))
#Comparação entre valores da simulação e valores preditos - Taxa de entrega
vali3 = np.array(
sorted([(x4[0], y4[0]) for x4, y4 in zip(set_test3, simu3)]))
predi3 = np.array(sorted([(x4[0], y4)
for x4, y4 in zip(set_test3, pred3)]))
icmin3 = np.array(icmin3)
icmax3 = np.array(icmax3)
min3 = vali3[:, 1] - icmin3
max3 = icmax3 - vali3[:, 1]
rg.create_graphic_interval_confidence('Taxa de entrega', 'svr', min, max,
vali, predi1, pred1, set_test, min2,
max2, vali2, predi2, pred2,
set_test2, min3, max3, vali3, predi3,
pred3, set_test3)
def mlp():
#Resultados para a taxa de entrega
n = 30
flag = 1
cam = "C:/Users/Joyce Quintino/joyce/dados-tcc/cenario1 - v4/"
cam2 = "C:/Users/joyce/Documents/joyce/programsimulations/extraction_data/"
a = '0.01'
b = [
'50', '51', '52', '53', '54', '55', '56', '57', '58', '59', '60', '61',
'62', '63', '64', '65', '66', '67', '68', '69', '70', '71', '72', '73',
'74', '75', '76', '77', '78', '79', '80', '81', '82', '83', '84', '85',
'86', '87', '88', '89', '90', '91', '92', '93', '94', '95', '96', '97',
'98', '99', '100', '101', '102', '103', '104', '105', '106', '107',
'108', '109'
]
c = '256'
data_simulations, icmin, icmax = de.data_formulation(n, flag, cam, a, b, c)
# x representa o dataset de treino e possui 23 colunas sem o atributo alvo
data_x = data_simulations.iloc[:, 0:3].values
# y representa o atributo alvo de x
data_y = data_simulations.iloc[:, 3:4].values
random.seed(1)
x_train, x_test, y_train, y_test = train_test_split(data_x,
data_y,
test_size=0.2,
random_state=0)
# Escalonamento de dados
scaler_train_x = StandardScaler()
scaler_train_y = StandardScaler()
scaler_test_x = StandardScaler()
scaler_test_y = StandardScaler()
u = scaler_test_x.fit_transform(x_test)
x = scaler_train_x.fit_transform(x_train)
y = scaler_train_y.fit_transform(y_train)
v = scaler_test_y.fit_transform(y_test)
#Uso de PCA no conjunto de teste para exibicao dos resultados de forma grafica
pca = PCA(n_components=1)
set_test = pca.fit_transform(u)
#Treinamento da MLP
mlp = ml.optimize_parameters(MLPRegressor(), x, y,
ml.definitions_algorithms('MLP'))
mlp = MLPRegressor(alpha=mlp['alpha'],
activation=mlp['activation'],
learning_rate_init=mlp['learning_rate_init'],
solver=mlp['solver'],
hidden_layer_sizes=mlp['hidden_layer_sizes'])
score, error, mlp = ml.experiment_folds('mlp', mlp, x, y)
print("Resultados após treinamento dos algoritmos")
print("Média do score -> ", score)
print("Média do erro -> ", error)
print("Modelo ->", mlp)
#Pacote - 256
scaler_train_x = StandardScaler()
scaler_train_y = StandardScaler()
x1 = scaler_train_x.fit_transform(data_x)
y1 = scaler_train_y.fit_transform(data_y)
#Uso de PCA no conjunto de teste para exibicao dos resultados de forma grafica
pca = PCA(n_components=1)
set_test = pca.fit_transform(x1)
#Carregamento do modelo
print("Valores da simulação - conjunto de validação -> \n",
scaler_train_y.inverse_transform(y1))
simu1 = sorted(scaler_train_y.inverse_transform(y1))
print("Valores da predição - MLP -> \n",
sorted(scaler_train_y.inverse_transform(mlp.predict(x1))))
pred1 = sorted(scaler_train_y.inverse_transform(mlp.predict(x1)))
#Comparação entre valores da simulação e valores preditos - Taxa de entrega
vali = np.array(sorted([(x1[0], y1[0])
for x1, y1 in zip(set_test, simu1)]))
predi1 = np.array(sorted([(x1[0], y1) for x1, y1 in zip(set_test, pred1)]))
icmin = np.array(icmin)
icmax = np.array(icmax)
min = vali[:, 1] - icmin
max = icmax - vali[:, 1]
rg.create_graphic_interval_confidence2('Taxa de entrega %', 'mlp', a, c,
min, max, vali, predi1, pred1,
set_test)
#Pacote de 512
c2 = '512'
data_simulations2, icmin2, icmax2 = de.data_formulation(
n, flag, cam, a, b, c2)
# x representa o dataset de treino e possui 23 colunas sem o atributo alvo
data_x2 = data_simulations2.iloc[:, 0:3].values
# y representa o atributo alvo de x
data_y2 = data_simulations2.iloc[:, 3:4].values
random.seed(1)
x_train2, x_test2, y_train2, y_test2 = train_test_split(data_x2,
data_y2,
test_size=0.2,
random_state=0)
# Escalonamento de dados
scaler_train_x2 = StandardScaler()
scaler_train_y2 = StandardScaler()
scaler_test_x2 = StandardScaler()
scaler_test_y2 = StandardScaler()
u2 = scaler_test_x2.fit_transform(x_test2)
x2 = scaler_train_x2.fit_transform(x_train2)
y2 = scaler_train_y2.fit_transform(y_train2)
v2 = scaler_test_y2.fit_transform(y_test2)
#Uso de PCA no conjunto de teste para exibicao dos resultados de forma grafica
pca2 = PCA(n_components=1)
set_test2 = pca2.fit_transform(u2)
#Treinamento da MLP
mlp2 = ml.optimize_parameters(MLPRegressor(), x2, y2,
ml.definitions_algorithms('MLP'))
mlp2 = MLPRegressor(alpha=mlp2['alpha'],
activation=mlp2['activation'],
learning_rate_init=mlp2['learning_rate_init'],
solver=mlp2['solver'],
hidden_layer_sizes=mlp2['hidden_layer_sizes'])
score2, error2, mlp2 = ml.experiment_folds('mlp', mlp2, x2, y2)
print("Resultados após treinamento dos algoritmos")
print("Média do score -> ", score2)
print("Média do erro -> ", error2)
print("Modelo ->", mlp2)
scaler_train_x2 = StandardScaler()
scaler_train_y2 = StandardScaler()
x3 = scaler_train_x2.fit_transform(data_x2)
y3 = scaler_train_y2.fit_transform(data_y2)
#Uso de PCA no conjunto de teste para exibicao dos resultados de forma grafica
pca2 = PCA(n_components=1)
set_test2 = pca2.fit_transform(x3)
#Carregamento do modelo
print("Valores da simulação - conjunto de validação -> \n",
scaler_train_y2.inverse_transform(y3))
simu2 = sorted(scaler_train_y2.inverse_transform(y3))
print("Valores da predição - MLP -> \n",
sorted(scaler_train_y2.inverse_transform(mlp2.predict(x3))))
pred2 = sorted(scaler_train_y2.inverse_transform(mlp2.predict(x3)))
#Comparação entre valores da simulação e valores preditos - Taxa de entrega
vali2 = np.array(
sorted([(x3[0], y3[0]) for x3, y3 in zip(set_test2, simu2)]))
predi2 = np.array(sorted([(x3[0], y3)
for x3, y3 in zip(set_test2, pred2)]))
icmin2 = np.array(icmin2)
icmax2 = np.array(icmax2)
min2 = vali2[:, 1] - icmin2
max2 = icmax2 - vali2[:, 1]
rg.create_graphic_interval_confidence2('Taxa de entrega %', 'mlp', a, c2,
min2, max2, vali2, predi2, pred2,
set_test2)
#Pacote de 1024
c3 = '1024'
data_simulations3, icmin3, icmax3 = de.data_formulation(
n, flag, cam, a, b, c3)
# x representa o dataset de treino e possui 23 colunas sem o atributo alvo
data_x3 = data_simulations3.iloc[:, 0:3].values
# y representa o atributo alvo de x
data_y3 = data_simulations3.iloc[:, 3:4].values
random.seed(1)
x_train3, x_test3, y_train3, y_test3 = train_test_split(data_x3,
data_y3,
test_size=0.2,
random_state=0)
# Escalonamento de dados
scaler_train_x3 = StandardScaler()
scaler_train_y3 = StandardScaler()
scaler_test_x3 = StandardScaler()
scaler_test_y3 = StandardScaler()
u3 = scaler_test_x3.fit_transform(x_test3)
x3 = scaler_train_x3.fit_transform(x_train3)
y3 = scaler_train_y3.fit_transform(y_train3)
v3 = scaler_test_y3.fit_transform(y_test3)
#Uso de PCA no conjunto de teste para exibicao dos resultados de forma grafica
pca3 = PCA(n_components=1)
set_test3 = pca3.fit_transform(u3)
#Treinamento da MLP
mlp3 = ml.optimize_parameters(MLPRegressor(), x3, y3,
ml.definitions_algorithms('MLP'))
mlp3 = MLPRegressor(alpha=mlp3['alpha'],
activation=mlp3['activation'],
learning_rate_init=mlp3['learning_rate_init'],
solver=mlp3['solver'],
hidden_layer_sizes=mlp3['hidden_layer_sizes'])
score3, error3, mlp3 = ml.experiment_folds('mlp', mlp3, x3, y3)
print("Resultados após treinamento dos algoritmos")
print("Média do score -> ", score3)
print("Média do erro -> ", error3)
print("Modelo ->", mlp3)
scaler_train_x3 = StandardScaler()
scaler_train_y3 = StandardScaler()
x4 = scaler_train_x3.fit_transform(data_x3)
y4 = scaler_train_y3.fit_transform(data_y3)
#Uso de PCA no conjunto de teste para exibicao dos resultados de forma grafica
pca3 = PCA(n_components=1)
set_test3 = pca3.fit_transform(x4)
#Carregamento do modelo
print("Valores da simulação - conjunto de validação -> \n",
scaler_train_y3.inverse_transform(y4))
simu3 = sorted(scaler_train_y3.inverse_transform(y4))
print("Valores da predição - MLP -> \n",
sorted(scaler_train_y3.inverse_transform(mlp3.predict(x4))))
pred3 = sorted(scaler_train_y3.inverse_transform(mlp3.predict(x4)))
#Comparação entre valores da simulação e valores preditos - Taxa de entrega
vali3 = np.array(
sorted([(x4[0], y4[0]) for x4, y4 in zip(set_test3, simu3)]))
predi3 = np.array(sorted([(x4[0], y4)
for x4, y4 in zip(set_test3, pred3)]))
icmin3 = np.array(icmin3)
icmax3 = np.array(icmax3)
min3 = vali3[:, 1] - icmin3
max3 = icmax3 - vali3[:, 1]
rg.create_graphic_interval_confidence2('Taxa de entrega %', 'mlp', a, c3,
min3, max3, vali3, predi3, pred3,
set_test3)
rg.create_graphic_interval_confidence('Taxa de entrega %', 'mlp', a, min,
max, vali, predi1, pred1, set_test,
min2, max2, vali2, predi2, pred2,
set_test2, min3, max3, vali3, predi3,
pred3, set_test3)