def Loadlinear(MySQL,
Data,
SelectX,
ARR=[
True, True, True, False, False, True, False, False, False,
False, True, False, False, False, False, True
]):
print(Data)
# 数据IP地址
ip = MySQL[0]
# 数据库数据用户名称
name = MySQL[1]
# 数据库密码
password = MySQL[2]
# 数据库名称
database_name = MySQL[3]
# 数据库表单
table = MySQL[4] + '_tx'
# 数据库获取表
select_table = "select %s,%s,%s,%s,%s from %s" % (
Data[0], Data[1], Data[2], Data[3], Data[4], table)
inputdata = getdata(ip, name, password, database_name, select_table)
inputdata = np.array(inputdata)
inputdata = datatransform(inputdata, ARR)
list = MyFunction.BoolStr2list(SelectX, False)
inputdata = np.delete(inputdata, list, axis=1) # 删除复选框没有选中的变量数据
inputdata = inputdata[:, 0:-1]
# 加载训练好的模型
RF = joblib.load('model/linear.model') # 训练模型
RF1 = joblib.load('model/linear_y.model') # Y归一化模型
RF2 = joblib.load('model/linear_x.model') # X归一化模型
# 或者用RF1.inverse_transform反归一化
data_result_min = RF1.data_min_
data_result_max = RF1.data_max_
# 训练数据归一化
inputdata = RF2.transform(inputdata)
# 模型计算
y_console = RF.predict(inputdata)
# 计算结果重构（反归一化）
# 或者用RF1.inverse_transform反归一化
y_console = y_console * (data_result_max -
data_result_min) + data_result_min
# 打印结果
result = y_console[0, 0]
print(result)
y_name = Data[-1]
print(y_name)
excute_table = " UPDATE %s SET %s = %s" % (table, y_name, result)
print(excute_table)
db = pymysql.connect(ip, name, password, database_name)
cursor = db.cursor()
cursor.execute(excute_table)
db.commit()
cursor.close()
db.close()
return result
def DXSMain(MySQL, Data, SelectX=[True, True, True, True], degree=2):
#数据IP地址
ip = MySQL[0]
#数据库数据用户名称
name = MySQL[1]
#数据库密码
password = MySQL[2]
#数据库名称
database_name = MySQL[3]
#数据库获取表
select_table = "select %s,%s,%s,%s,%s from %s" % (
Data[0], Data[1], Data[2], Data[3], Data[4], MySQL[4])
#输入数据方次信号
# ARR=[True,True,True,True]
inputdata = getdata(ip, name, password, database_name, select_table)
inputdata = np.array(inputdata)
inputdata = datatransform(inputdata, SelectX)
list = MyFunction.BoolStr2list(SelectX, False)
inputdata = np.delete(inputdata, list, axis=1) # 删除复选框没有选中的变量数据
inputdata = np.matrix(inputdata)
#测试训练数据分割点
break_point = int(inputdata.shape[0] * 2 / 3)
x_train, y_train, x_test, y_test = trainingdata(break_point, inputdata)
#建立训练模型
poly_reg = PolynomialFeatures(
degree, interaction_only=False,
include_bias=False) #控制多项式的度，决定特征自己结合的项，决定有没有1那一项
x_train = poly_reg.fit_transform(x_train)
x_test = poly_reg.fit_transform(x_test)
lineargression = LinearRegression()
rf = lineargression.fit(x_train, y_train)
joblib.dump(rf, 'model/morelinear.model')
#原特征经过多项式特征增加后各特征的组合方式（列名）
X_ploly_df = pd.DataFrame(x_test, columns=poly_reg.get_feature_names())
lie = X_ploly_df.columns.values.tolist()
#测试集测试
outdata = lineargression.predict(x_test)
c1 = 0
for i in range(len(outdata)):
a1 = y_test[i] * 0.05
b1 = np.abs(y_test[i] - outdata[i])
if b1 <= a1:
c1 += 1
#计算置信度
score = c1 / len(outdata)
coef = rf.coef_
intercept = rf.intercept_
Msg = lie
return score, coef, intercept, Msg
def RidgeMain(MySQL, Data, SelectX, ARR):
#数据IP地址
ip = MySQL[0]
#数据库数据用户名称
name = MySQL[1]
#数据库密码
password = MySQL[2]
#数据库名称
database_name = MySQL[3]
#数据库获取表
select_table = "select %s,%s,%s,%s,%s from %s" % (
Data[0], Data[1], Data[2], Data[3], Data[4], MySQL[4])
#输入数据方次信号
#ARR=[False,True,False,False,False,True,False,False,False,True,False,False,False,True,False,False]
inputdata = getdata(ip, name, password, database_name, select_table)
inputdata = np.array(inputdata)
inputdata = datatransform(inputdata, ARR)
list = MyFunction.BoolStr2list(SelectX, False)
inputdata = np.delete(inputdata, list, axis=1) # 删除复选框没有选中的变量数据
inputdata = np.matrix(inputdata)
#测试训练数据分割点
break_point = int(inputdata.shape[0] * 2 / 3)
x_train, y_train, x_test, y_test = trainingdata(break_point, inputdata)
#建立训练模型
lineargression = LinearRegression()
rf = lineargression.fit(x_train, y_train)
joblib.dump(rf, 'model/ridge.model')
#测试集测试
outdata = lineargression.predict(x_test)
c1 = 0
for i in range(len(outdata)):
a1 = y_test[i] * 0.05
b1 = np.abs(y_test[i] - outdata[i])
if b1 <= a1:
c1 += 1
#计算置信度
score = c1 / len(outdata)
coef = rf.coef_
intercept = rf.intercept_
return score, coef, intercept
def Loadridge(MySQL,Data,SelectX,ARR=[True,True,True,False,False,True,False,False,False,False,True,False,False,False,False,True]):
# 数据IP地址
ip = MySQL[0]
# 数据库数据用户名称
name = MySQL[1]
# 数据库密码
password = MySQL[2]
# 数据库名称
database_name = MySQL[3]
# 数据库表单
table=MySQL[4]+'_tx'
# 数据库获取表
select_table = "select %s,%s,%s,%s,%s from %s" % (Data[0], Data[1], Data[2], Data[3], Data[4], table)
inputdata = getdata(ip, name, password, database_name, select_table)
inputdata = np.array(inputdata)
inputdata = datatransform(inputdata, ARR)
list = MyFunction.BoolStr2list(SelectX, False)
inputdata = np.delete(inputdata, list, axis=1) # 删除复选框没有选中的变量数据
inputdata = inputdata[:,0:-1]
# 加载训练好的模型
RF = joblib.load('model/ridge.model') # 训练模型
# 模型计算
y_console = RF.predict(inputdata)
# 打印结果
result=y_console[0,0]
print(result)
y_name=Data[-1]
print(y_name)
excute_table=" UPDATE %s SET %s = %s" % (table,y_name,result )
print(excute_table)
db = pymysql.connect(ip,name,password,database_name)
cursor = db.cursor()
cursor.execute(excute_table)
db.commit()
cursor.close()
db.close()
return result
dAngle = 360.0 / NumberOfCorners
clarity = 0.02 # Параметр четкости фигур
file = open(FileFolder + "/test.txt", "w")
file.write("Number of figures=" + str(NumberOfFigures) + " n=" + str(n) +
" m=" + str(m) + " Number of Corners=" + str(NumberOfCorners) +
"\n" + "Pixels(n*m)=" + str(n * m) + " Сlarity=" + str(clarity) +
" Clarity*n*m>" + str(clarity * n * m) + " np.sqrt(Clarity*n*m)>" +
str(np.sqrt(clarity * n * m)) + "\n")
for k in range(1, NumberOfFigures + 1):
measureOfArea, minLong, convex = 0.0, 0.0, True # Качество фигуры определяем по длине сторон и площади треугольников
while convex or (measureOfArea < clarity * n * m
or minLong < np.sqrt(clarity * n * m)):
pointX = []
pointY = []
for l in range(NumberOfCorners):
x, y = MyF.PolarRandom1(m, n, l * dAngle, (l + 1) * dAngle, l0,
l2 - 1)
pointX = pointX + [x]
pointY = pointY + [y]
measureOfArea = n * m
minLong = (n + m) / 2.0
convex = False
for l in range(NumberOfCorners): # Площадь треугольника
measureOfAreaC = (pointX[np.mod(l, NumberOfCorners)] - pointX[np.mod(2 + l, NumberOfCorners)]) * \
(pointY[np.mod(1 + l, NumberOfCorners)] - pointY[np.mod(2 + l, NumberOfCorners)]) - \
(pointY[np.mod(l, NumberOfCorners)] - pointY[np.mod(2 + l, NumberOfCorners)]) * \
(pointX[np.mod(1 + l, NumberOfCorners)] - pointX[np.mod(2 + l, NumberOfCorners)])
if l == 0:
znak = measureOfAreaC # Ореинтация первого треугольника
if measureOfAreaC * znak < 0.0:
convex = True
break
# import # [POINT 1] import MyFunction print(MyFunction.__name__) MyFunction.getID() MyFunction.getName()
parser.add_argument(action = 'store',dest = 'image_path')
parser.add_argument(action = 'store',dest = 'checkpoint')
parser.add_argument(action = 'store',dest = 'model_select')
parser.add_argument('--top_k', action = 'store',dest = 'K', type = int)
parser.add_argument('--category_names', action = 'store',dest = 'category_name')
parser.add_argument('--gpu', action = 'store_true',dest = 'device', default = False)
result = parser.parse_args()
with open(result.category_name, 'r') as f:
cat_to_name = json.load(f)
device = torch.device("cuda" if result.device else "cpu")
model = MyFunction.load_checkpoint(result.checkpoint, result.model_select)
im = Image.open(result.image_path)
np_image = MyFunction.process_image(im)
inputs_02 = torch.from_numpy(np_image)
probs,classes = MyFunction.predict(result.image_path, model, result.K, device)
print(probs)
print(classes)
flower_name = [cat_to_name.get(key) for key in classes]
print(flower_name)
ps = probs.squeeze()
fig, (ax1, ax2) = plt.subplots(figsize=(6,9), ncols=2)
ax1.imshow(im)
# import as # [POINT 2] import MyFunction as mf print(mf.__name__) mf.getID() mf.getName()
def LinearMain(MySQL,Data,SelectX,ARR=[True,True,True,False,False,True,False,False,False,False,True,False,False,False,False,True]):
# 数据IP地址
ip = MySQL[0]
# 数据库数据用户名称
name = MySQL[1]
# 数据库密码
password = MySQL[2]
# 数据库名称
database_name = MySQL[3]
# 数据库获取表
select_table = "select %s,%s,%s,%s,%s from %s" % (Data[0], Data[1], Data[2], Data[3], Data[4], MySQL[4])
inputdata = getdata(ip, name, password, database_name, select_table)
print(inputdata)
inputdata = np.array(inputdata)
print(inputdata)
inputdata = datatransform(inputdata, ARR)
print(inputdata)
list = MyFunction.BoolStr2list(SelectX, False)
inputdata = np.delete(inputdata, list, axis=1) # 删除复选框没有选中的变量数据
inputdata = np.matrix(inputdata)
print(inputdata)
# 测试训练数据分割点
break_point = int(inputdata.shape[0] * 2 / 3)
x_train, y_train, x_test, y_test = trainingdata(break_point, inputdata)
# 数据归一化
scaler = MinMaxScaler()
scaler1 = MinMaxScaler()
rf1 = scaler1.fit(y_train)
rf2 = scaler.fit(x_train)
xx_train = scaler.transform(x_train)
xx_test = scaler.transform(x_test)
yy_train = scaler1.transform(y_train)
# 获取训练结果数据的最大值及最小值
data_min = scaler1.data_min_
data_max = scaler1.data_max_
# 建立训练模型
lineargression = LinearRegression()
rf = lineargression.fit(xx_train, yy_train)
# 固化训练模型
joblib.dump(rf, 'model/linear.model')
# 固化数据归一化模型
joblib.dump(rf1, 'model/linear_y.model')
joblib.dump(rf2, 'model/linear_x.model')
# 测试集测试
outdata = lineargression.predict(xx_test)
outdata = outdata * (data_max - data_min) + data_min
count = 0
for x, y in zip(outdata, y_test):
if np.abs(x - y) / y <= 0.05:
count += 1
# 计算模型得分
score = count / y_test.shape[0]
coef = rf.coef_
intercept = rf.intercept_
x_Max = rf2.data_max_
print(type(x_Max))
x_Min = rf2.data_min_
print(type(x_Min))
y_Max = rf1.data_max_
y_Min = rf1.data_min_
return score, coef, intercept, x_Max, x_Min, y_Max, y_Min
parser.add_argument(action='store', dest='data_dir')
parser.add_argument('--arch', action='store', dest='model_selected')
parser.add_argument('--learning_rate', action='store', dest='lr', type=float)
parser.add_argument('--hidden_units',
action='store',
dest='hidden_units',
type=int)
parser.add_argument('--epochs', action='store', dest='epochs', type=int)
parser.add_argument('--save_dir', action='store', dest='save_directory')
# add commend line for users to specify using GPU
parser.add_argument('--gpu', action='store_true', dest='device', default=False)
result = parser.parse_args()
trainloaders, validloaders, testloaders = MyFunction.load_data(result.data_dir)
# use the GPU only when it is available and the user has specified to use it
device = torch.device(
"cuda" if torch.cuda.is_available() and result.device else "cpu")
model, optimizer = MyFunction.train_model(result.model_selected,
result.hidden_units, result.lr,
result.epochs, trainloaders,
validloaders, device)
# MyFunction.test_model(model, testloaders, device)
MyFunction.save_model(result.save_directory, model, optimizer)