【人工智能】实验二: 洗衣机模糊推理系统实验与基础知识

实验二: 洗衣机模糊推理系统实验

实验目的

理解模糊逻辑推理的原理及特点,熟练应用模糊推理。

实验内容

设计洗衣机洗涤时间的模糊控制。

实验要求

已知人的操作经验为:

  • “污泥越多,油脂越多,洗涤时间越长”;
  • “污泥适中,油脂适中,洗涤时间适中”;
  • “污泥越少,油脂越少,洗涤时间越短”。

模糊控制规则如表1所示:

xyz
SDNGVS
SDMGM
SDLGL
MDNGS
MDMGM
MDLGL
LDNGM
LDMGL
LDLGVL

其中:

  • SD(污泥少)、MD(污泥中)、LD(污泥多)、NG(油脂少)、MG(油脂中)、LG(油脂多)、VS(洗涤时间很短)、S(洗涤时间短)、M(洗涤时间中等)、L(洗涤时间长)、VL(洗涤时间很长)。

1. 污泥隶属函数

# 污泥隶属函数
sludge['SD'] = fuzz.trimf(sludge.universe, [0, 0, 50])
sludge['MD'] = fuzz.trimf(sludge.universe, [0, 50, 100])
sludge['LD'] = fuzz.trimf(sludge.universe, [50, 100, 100])

在这里插入图片描述
在这里插入图片描述

2. 油脂隶属函数

# 油脂隶属函数
grease['NG'] = fuzz.trimf(grease.universe, [0, 0, 50])
grease['MG'] = fuzz.trimf(grease.universe, [0, 50, 100])
grease['LG'] = fuzz.trimf(grease.universe, [50, 100, 100])

在这里插入图片描述
在这里插入图片描述

3. 洗涤时间隶属度函数

# 洗涤时间隶属度函数
washing_time['VS'] = fuzz.trimf(washing_time.universe, [0, 0, 30])
washing_time['S'] = fuzz.trimf(washing_time.universe, [0, 30, 60])
washing_time['M'] = fuzz.trimf(washing_time.universe, [30, 60, 90])
washing_time['L'] = fuzz.trimf(washing_time.universe, [60, 90, 120])
washing_time['VL'] = fuzz.trimf(washing_time.universe, [90, 120, 120])

在这里插入图片描述
在这里插入图片描述

import numpy as np
import skfuzzy as fuzz
from skfuzzy import control as ctrl
import matplotlib.pyplot as plt# 创建输入变量和输出变量
sludge = ctrl.Antecedent(np.arange(0, 101, 1), 'sludge')
grease = ctrl.Antecedent(np.arange(0, 101, 1), 'grease')
washing_time = ctrl.Consequent(np.arange(0, 121, 1), 'washing_time')# 定义隶属函数
sludge['SD'] = fuzz.trimf(sludge.universe, [0, 0, 50])
sludge['MD'] = fuzz.trimf(sludge.universe, [0, 50, 100])
sludge['LD'] = fuzz.trimf(sludge.universe, [50, 100, 100])grease['NG'] = fuzz.trimf(grease.universe, [0, 0, 50])
grease['MG'] = fuzz.trimf(grease.universe, [0, 50, 100])
grease['LG'] = fuzz.trimf(grease.universe, [50, 100, 100])washing_time['VS'] = fuzz.trimf(washing_time.universe, [0, 0, 30])
washing_time['S'] = fuzz.trimf(washing_time.universe, [0, 30, 60])
washing_time['M'] = fuzz.trimf(washing_time.universe, [30, 60, 90])
washing_time['L'] = fuzz.trimf(washing_time.universe, [60, 90, 120])
washing_time['VL'] = fuzz.trimf(washing_time.universe, [90, 120, 120])# 定义模糊控制规则
rule1 = ctrl.Rule(sludge['SD'] & grease['NG'], washing_time['VS'])
rule2 = ctrl.Rule(sludge['SD'] & grease['MG'], washing_time['M'])
rule3 = ctrl.Rule(sludge['SD'] & grease['LG'], washing_time['L'])
rule4 = ctrl.Rule(sludge['MD'] & grease['NG'], washing_time['S'])
rule5 = ctrl.Rule(sludge['MD'] & grease['MG'], washing_time['M'])
rule6 = ctrl.Rule(sludge['MD'] & grease['LG'], washing_time['L'])
rule7 = ctrl.Rule(sludge['LD'] & grease['MG'], washing_time['M'])
rule8 = ctrl.Rule(sludge['LD'] & grease['LG'], washing_time['L'])
rule9 = ctrl.Rule(sludge['LD'] & grease['LG'], washing_time['VL'])# 创建控制系统
washing_ctrl = ctrl.ControlSystem([rule1, rule2, rule3, rule4, rule5, rule6, rule7, rule8, rule9])washing = ctrl.ControlSystemSimulation(washing_ctrl)# 输入污泥和油脂值
washing.input['sludge'] = 70
washing.input['grease'] = 60# 进行模糊推理
washing.compute()# 获取洗涤时间的输出
washing_time.view(sim=washing)# 打印输出洗涤时间
print("洗涤时间:", washing.output['washing_time'])# 绘制隶属度函数
sludge.view()
grease.view()
washing_time.view()
plt.show()

4. 模糊控制规则表

在这里插入图片描述

注:SD(污泥少)、MD(污泥中)、LD(污泥多)、NG(油脂少)、MG(油脂中)、LG(油脂多)、VS(洗涤时间很短)、S(洗涤时间短)、M(洗涤时间中等)、L(洗涤时间长)、VL(洗涤时间很长)。

推论结果立体图
在这里插入图片描述

import numpy as np
import skfuzzy as fuzz
import matplotlib
matplotlib.use('TkAgg')
import matplotlib.pyplot as plt
from skfuzzy import control as ctrl#定义输入输出的取值范围
#  污泥和油脂范围为[0,100]
#  洗涤时间范围为[0,120]
x_stain = np.arange(0, 101, 1)
x_oil = np.arange(0, 101, 1)
x_time = np.arange(0, 121, 1)
# 定义模糊控制变量
stain = ctrl.Antecedent(x_stain, 'stain')
oil = ctrl.Antecedent(x_oil, 'oil')
time = ctrl.Consequent(x_time, 'time')
# 生成模糊隶属函数
#函数中的三元变量,第一个代表折线的起点,第二是最大值,第三是终点
stain['SD'] = fuzz.trimf(x_stain, [0, 0, 50])  #定义污渍的三角隶属度函数横坐标
stain['MD'] = fuzz.trimf(x_stain, [0, 50, 100])
stain['LD'] = fuzz.trimf(x_stain, [50, 100, 100])
oil['NG'] = fuzz.trimf(x_oil, [0, 0, 50]) #定义油污的三角隶属度函数横坐标
oil['MG'] = fuzz.trimf(x_oil, [0, 50, 100])
oil['LG'] = fuzz.trimf(x_oil, [50, 100, 100])
time['VS'] = fuzz.trimf(x_time, [0, 0, 20]) #定义洗涤时间的三角隶属度函数横坐标
time['S'] = fuzz.trimf(x_time, [0, 20, 50])
time['M'] = fuzz.trimf(x_time, [20, 50, 80])
time['L'] = fuzz.trimf(x_time, [50, 80, 120])
time['VL'] = fuzz.trimf(x_time, [80, 120, 120])#采用解模糊方法——质心解模糊方式
time.defuzzify_method='centroid'#规则
rule1=ctrl.Rule(antecedent=((stain['SD'] & oil['NG'])),consequent=time['VS'],label='time=VS')
rule2=ctrl.Rule(antecedent=((stain['SD'] & oil['MG'])|(stain['MD'] & oil['MG'])|(stain['LD'] & oil['NG'])),consequent=time['M'],label='time=M')
rule3=ctrl.Rule(antecedent=((stain['SD'] & oil['LG'])|(stain['MD'] & oil['LG'])|(stain['LD'] & oil['MG'])),consequent=time['L'],label='time=L')
rule4=ctrl.Rule(antecedent=((stain['MD'] & oil['NG'])),consequent=time['S'],label='time=S')
rule5=ctrl.Rule(antecedent=((stain['LD'] & oil['LG'])),consequent=time['VL'],label='time=VL')# 系统和运行环境初始化
rule=[rule1, rule2, rule3,rule4,rule5]
time_ctrl = ctrl.ControlSystem(rule)
wash_time = ctrl.ControlSystemSimulation(time_ctrl)
#规则中带一些奇怪的规则,处理后输出
for i in range(len(rule)):print("rule",i,end=":")for item in str(rule[i]):if(item!='\n'):print(item,end="")else:breakprint('\t')
#画图
stain.view()
oil.view()
time.view()
#time.view()
plt.show()
#绘制3D图
upsampled=np.linspace(0,101,21)#步距参数
x,y=np.meshgrid(upsampled,upsampled)
z=np.zeros_like(x)
pp=[]
for i in range(0,21):for j in range(0,21):wash_time.input['stain']=x[i,j]wash_time.input['oil']=y[i,j]wash_time.compute()z[i,j]=wash_time.output['time']pp.append(z[i,j])
print('max:',max(pp))
print('min:',min(pp))
from mpl_toolkits.mplot3d import Axes3D
fig=plt.figure(figsize=(8,8))#画布大小
ax=fig.add_subplot(111,projection='3d')
surf=ax.plot_surface(x,y,z,rstride=1,cstride=1,cmap='viridis',linewidth=0.1,antialiased=True)
ax.view_init(30,250)#观察角度
plt.title('3D results')
ax.set_xlabel('stain')
ax.set_ylabel('oil')
ax.set_zlabel('time')
plt.show()

(2)假定当前传感器测得的信息为x0(污泥)=60,y0(油脂)=70,采用模糊决策,给出模糊推理结果,并观察模糊推理的动态仿真环境,给出其动态仿真环境图。

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation# 导入NumPy库用于数学运算
import numpy as np# 在Sludge函数和Grease函数中添加输入值检查
def Sludge(a):sludge = [0, 0, 0]  # 默认隶属度为0,依次对应SD, MD, LDif a < 0:a = 0elif a > 100:a = 100if 0 <= a <= 50:sludge[0] = (50 - a) / 50sludge[1] = a / 50elif 50 < a <= 100:sludge[1] = (100 - a) / 50sludge[2] = (a - 50) / 50return sludgedef Grease(a):grease = [0, 0, 0]  # 默认隶属度为0,依次对应NG, MG, LGif a < 0:a = 0elif a > 100:a = 100if 0 <= a <= 50:grease[0] = (50 - a) / 50grease[1] = a / 50elif 50 < a <= 100:grease[1] = (100 - a) / 50grease[2] = (a - 50) / 50return grease# 3. 规则前提推理,并运算取最小值
def Rules(a, b):  # a为污泥隶属度,b为油脂隶属度rules_value = [0, 0, 0, 0, 0, 0, 0, 0, 0]  # 依次对应9条规则结果VS, M, L, S, M, L, M, L, VLif a[0] != 0 and b[0] != 0:rules_value[0] = min(a[0], b[0])if a[0] != 0 and b[1] != 0:rules_value[1] = min(a[0], b[1])if a[0] != 0 and b[2] != 0:rules_value[2] = min(a[0], b[2])if a[1] != 0 and b[0] != 0:rules_value[3] = min(a[1], b[0])if a[1] != 0 and b[1] != 0:rules_value[4] = min(a[1], b[1])if a[1] != 0 and b[2] != 0:rules_value[5] = min(a[1], b[2])if a[2] != 0 and b[0] != 0:rules_value[6] = min(a[2], b[0])if a[2] != 0 and b[1] != 0:rules_value[7] = min(a[2], b[1])if a[2] != 0 and b[2] != 0:rules_value[8] = min(a[2], b[2])return rules_value# 创建一个时间步骤列表
time_steps = np.arange(0, 100, 1)# 存储模糊输出值的列表
output_values = []# 创建一个初始传感器输入
x0 = 60  # 初始污泥值
y0 = 70  # 初始油脂值# 模拟模糊推理过程
for t in time_steps:# 模拟传感器测得的信息,可以根据需要在此处引入噪声x = x0y = y0# 计算污泥和油脂的隶属度sludge_membership = Sludge(x)grease_membership = Grease(y)# 规则前提推理rule_results = Rules(sludge_membership, grease_membership)# 模糊系统总的输出,取各条规则推理结果的最小值final_output = max(rule_results)# 存储输出值output_values.append(final_output)# 更新传感器输入(这里示例中的输入简单地增加)x0 += 1y0 += 1# 创建图形窗口
fig, ax = plt.subplots()# 设置初始图形
line, = ax.plot([], [])
ax.set_xlim(0, len(time_steps))
ax.set_ylim(0, 1)
ax.set_xlabel("Time Step")
ax.set_ylabel("Fuzzy Output")
ax.set_title("Fuzzy Logic Control Simulation")# 更新函数
def update(frame):line.set_data(time_steps[:frame + 1], output_values[:frame + 1])return line,# 创建动画
ani = FuncAnimation(fig, update, frames=len(time_steps), blit=True, repeat=False)
plt.show()

在这里插入图片描述

5.模糊匹配

(1) 模糊匹配
将x=60,y=70带入的隶属度函数中:

(2)规则触发。被触发的规则有4条:

Rule1:IF x is MD AND y is MG THEN z is M;
Rule2:IF x is MD AND y is LG THEN z is L;
Rule3:IF x is LD AND y is MG THEN z is L;
Rule4:IF x is LD AND y is LG THEN z is VL。

(3)规则前提推理。在同一条规则内,前提之间通过交运算得到规则结论。

(4)模糊系统总的输出(聚合),取各条规则推理结果的并。

(5)去模糊化。采用加权平均判决发的方法。根据洗涤时间隶属函数的反函数用相应的隶属度求出时间论域中对应的值。

# 1. 污泥隶属度计算
def Sludge(a):sludge = [0, 0, 0]  # 默认隶属度为0,依次对应SD,MD,LDif a < 0 or a > 100:return (print("输入值有误"))elif 0 <= a <= 50:sludge[0] = (50 - a) / 50sludge[1] = a / 50elif 50 < a <= 100:sludge[1] = (100 - a) / 50    #  40/50sludge[2] = (a - 50) / 50      # 10/50return sludge# 2. 油脂隶属度计算
def Grease(a):grease = [0, 0, 0]  # 默认隶属度为0,依次对应NG,MG,LGif a < 0 or a > 100:return (print("输入值有误"))elif 0 <= a <= 50:grease[0] = (50 - a) / 50grease[1] = a / 50elif 50 < a <= 100:grease[1] = (100 - a) / 50   #  30/50grease[2] = (a - 50) / 50   #  10/50return grease# 3. 规则前提推理,并运算取最小值
def Rules(a, b):  # a为污泥隶属度,b为油脂隶属度rules_value = [0, 0, 0, 0, 0, 0, 0, 0, 0]  # 依次对应9条规则结果VS,M,L,S,M,L,M,L,VLif a[0] != 0 and b[0] != 0:rules_value[0] = min(a[0], b[0])  # 返回规则下最小值if a[0] != 0 and b[1] != 0:rules_value[1] = min(a[0], b[1])if a[0] != 0 and b[2] != 0:rules_value[2] = min(a[0], b[2])if a[1] != 0 and b[0] != 0:rules_value[3] = min(a[1], b[0])if a[1] != 0 and b[1] != 0:rules_value[4] = min(a[1], b[1])if a[1] != 0 and b[2] != 0:rules_value[5] = min(a[1], b[2])if a[2] != 0 and b[0] != 0:rules_value[6] = min(a[2], b[0])if a[2] != 0 and b[1] != 0:rules_value[7] = min(a[2], b[1])if a[2] != 0 and b[2] != 0:rules_value[8] = min(a[2], b[2])return rules_value# 4. 每条规则推理输出
def Inference(a):  # a为9条规则下的结果隶属度time_level = [0, 0, 0, 0, 0]  # 默认时间隶属值为0,依次对应VS,S,M,L,VLtime_level[0] = a[0]    # 0time_level[1] = a[3]    # 0if (a[1] != 0 or a[4] != 0 or a[6] != 0):  # 去零值然后取剩下的最小值list_1 = [a[1], a[4], a[6]]for i in range(len(list_1) - 1, -1, -1):if list_1[i] == 0:list_1.remove(0)time_level[2] = min(list_1)if (a[2] != 0 or a[5] != 0 or a[7] != 0):list_2 = [a[2], a[5], a[7]]for i in range(len(list_2) - 1, -1, -1):if list_2[i] == 0:list_2.remove(0)time_level[3] = min(list_2)time_level[4] = a[8]return time_level# 5. 由加权平均判决法可得,根据洗涤时间隶属函数的反函数用相应的隶属度求出时间论域中对应的值
def Max_membership(a):  # a为时间隶属度time = [0, 0, 0, 0, 0, 0, 0, 0]  # 时间隶属函数八个区间分别对应的时间值time[0] = 30 - 30 * a[0]time[1] = 30 * a[1]time[2] = 60 - 30 * a[1]time[3] = 30 * a[2] + 30time[4] = 90 - 30 * a[2]time[5] = 30 * a[3] + 60time[6] = 120 - 30 * a[3]time[7] = 30 * a[4] + 90sum_1 = time[0] * a[0] + time[1] * a[1] + time[2] * a[1] + time[3] * a[2] + time[4] * a[2] + time[5] * a[3] + time[6] * a[3] + time[7] * a[4]sum_2 = a[0] + 2 * a[1] + 2 * a[2] + 2 * a[3] + a[4]result = sum_1 / sum_2return result# 洗涤时间隶属度函数
def WashTime(a):  # a为时间值if 0 <= a <= 30:u1 = (30 - a) / 30u2 = a / 30if (u1 > u2):time_level = 'VS'else:time_level = 'S'if 30 < a <= 60:u3 = (60 - a) / 30u4 = (a - 30) / 30if (u3 > u4):time_level = 'S'else:time_level = 'M'if 60 < a <= 90:u5 = (90 - a) / 30u6 = (a - 60) / 30if (u5 > u6):time_level = 'M'else:time_level = 'L'if 90 < a <= 120:u7 = (120 - a) / 30u8 = (a - 90) / 30if (u7 > u8):time_level = 'L'else:time_level = 'VL'return time_levelif __name__ == '__main__':sludge = int(input("输入污泥指数:"))grease = int(input("输入油脂指数:"))rules_value = Rules(Sludge(sludge), Grease(grease))time_level = Inference(rules_value)  # 时间隶属度time_pre = Max_membership(time_level)  # 加权平均判决发求预测时间time_sign = WashTime(time_pre)  # 根据预测时间来计算洗涤时间符号flag = {'VS': '很短', 'S': '短', 'M': '中等', 'L': '长', 'VL': '很长'}print("模糊推理系统预测洗涤时间:{}{},预计洗涤时间:{}".format(time_sign,flag[time_sign], time_pre))

在这里插入图片描述

实验内容及总结

  1. 按照实验要求,给出相应结果。
  2. 分析隶属度、模糊关系和模糊规则的相互关系。

实验思考及实践

理解模糊逻辑原理:模糊逻辑是一种处理模糊信息和不确定性的有效方法。在这个实验中,你需要理解模糊逻辑的原理,包括模糊隶属度、模糊规则以及模糊推理的基本概念。

模糊隶属度函数的设计:在实验中,你需要设计污泥、油脂和洗涤时间的隶属度函数。这需要一定的创造力和理解,以确保隶属度函数可以正确地映射输入值到模糊集合。

模糊规则的构建:根据已知的人类操作经验,你需要构建模糊规则。这包括定义哪些条件下应该触发哪些规则,以及规则的前提和结论是如何关联的。

模糊推理系统的设计:你需要设计一个模糊推理系统,以根据输入的污泥和油脂指数来推断洗衣机的洗涤时间。这包括模糊匹配、规则触发、规则前提推理、模糊系统输出和去模糊化等步骤。

模糊推理结果的解释:在实验中,你将获得模糊推理的结果,包括洗涤时间的隶属度和具体时间值。了解如何解释和应用这些结果对于模糊控制非常重要。

动态仿真环境的观察:根据传感器测得的污泥和油脂指数,你需要观察模糊推理的动态仿真环境。这有助于理解模糊推理系统在不同输入条件下的表现。

模糊推理系统基础知识

1. 简介

模糊推理系统是一种基于模糊逻辑的计算机程序,用于处理模糊信息和进行模糊推理。与传统的布尔逻辑系统相比,模糊推理系统能够处理模糊的、不确定的或部分真实的信息。

模糊推理系统基于模糊逻辑,它引入了模糊集合和模糊关系的概念,以便更好地处理不确定性和模糊性。在模糊推理系统中,命题的真假不再是严格的二元取值,而是一个连续的范围,通常用一个介于0和1之间的实数表示。

2. 模糊逻辑与布尔逻辑的对比

传统的布尔逻辑只有两个取值,即真和假,而模糊逻辑可以处理更为复杂的情况。模糊逻辑允许命题的真假是一个连续的范围,这更符合真实世界中的不确定性和模糊性。

模糊逻辑与布尔逻辑的不同之处在于,模糊逻辑使用模糊集合来表示模糊概念和模糊关系,而布尔逻辑使用精确的集合和关系。

3. 模糊推理系统的基本组成

模糊推理系统由以下几个主要组成部分构成:

模糊规则库

模糊规则库是模糊推理系统的核心组件。它包含一系列模糊规则,每个规则描述了输入变量和输出变量之间的关系。模糊规则通常采用"IF-THEN"的形式,其中IF部分是输入变量的条件,THEN部分是输出变量的结论。

模糊推理引擎

模糊推理引擎是模糊推理系统的计算核心。它根据模糊规则库和输入数据进行推理,并生成模糊结果。推理引擎通常包括模糊化、规则匹配、推理和去模糊化等步骤。

模糊化和去模糊化

在模糊推理系统中,模糊化将现实世界的模糊输入转换为模糊集合。模糊化过程使用隶属函数来描述变量的隶属度,表示变量对某个模糊集合的归属程度。

去模糊化是将模糊结果转换为精确的输出。去模糊化通过使用去模糊函数来确定最终结果的精确值。

4. 模糊推理系统的应用领域

模糊推理系统在许多领域中有广泛的应用,特别是在以下领域:

模糊控制系统

模糊控制系统使用模糊推理系统来处理模糊输入和模糊输出,实现对模糊系统的控制。它在工程领域中广泛应用于控制系统设计,特别是在模糊控制器中。

模糊决策系统

模糊决策系统使用模糊推理系统来处理模糊输入和模糊输出,帮助进行管理和决策支持。它可以不确定性和模糊性为基础,帮助决策者进行决策分析和决策制定。

模糊识别系统

模糊识别系统使用模糊推理系统来处理模糊输入和模糊输出,用于模式识别和数据挖掘。它可以应用于图像识别、语音识别、模式分类等领域。

5. 模糊推理系统的优缺点

模糊推理系统具有以下优点:

  • 能够处理模糊和不确定信息,更贴近真实世界的情况。
  • 具备适应性和鲁棒性,能够应对输入数据的变化和噪声干扰。
  • 可以通过模糊规则库的扩展和调整进行灵活性的调整。

然而,模糊推理系统也存在一些局限性和挑战:

  • 计算复杂性较高,特别是在规则库规模较大时。
  • 不同领域的模糊概念和关系的建模存在主观性和模糊性。
  • 模糊结果的解释和理解可能存在困难。

6. 模糊推理系统的发展趋势

模糊推理系统的研究和应用正不断发展和演进。未来的发展趋势包括但不限于:

  • 结合模糊推理系统与其他人工智能技术,如神经网络和遗传算法,以提高系统性能和效果。
  • 开发更高效的推理算法和优化方法,以应对计算复杂性的挑战。
  • 模糊推理系统在自动化和智能化领域的深入应用,如自动驾驶、智能机器人等。

模糊推理系统作为一种处理模糊信息的有效工具,在各个领域中发挥着重要作用,持续不断地推动着科学研究和技术进步。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/227886.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

DDD挤水分和强行加异性为好友-UMLChina建模知识竞赛第4赛季第25轮

DDD领域驱动设计批评文集 做强化自测题获得“软件方法建模师”称号 《软件方法》各章合集 参考潘加宇在《软件方法》和UMLChina公众号文章中发表的内容作答。在本文下留言回答。 只要最先答对前3题&#xff0c;即可获得本轮优胜。第4题为附加题&#xff0c;对错不影响优胜者…

开源免费图床Lychee本地部署搭建个人云图床并公网访问【内网穿透】

文章目录 1.前言2. Lychee网站搭建2.1. Lychee下载和安装2.2 Lychee网页测试2.3 cpolar的安装和注册 3.本地网页发布3.1 Cpolar云端设置3.2 Cpolar本地设置 4.公网访问测试5.结语 1.前言 图床作为图片集中存放的服务网站&#xff0c;可以看做是云存储的一部分&#xff0c;既可…

作者推荐 |【深入了解系统性能优化】「实战技术专题」全方面带你透彻探索服务优化技术方案(方案分析篇)

全方面带你透彻探索服务优化技术方案 前提背景影响一个系统性能的方方面面代码优化数据库优化网络优化硬件优化 常用的性能评价/测试指标响应时间并发数吞吐量响应时间、并发数和吞吐量之间的关系运作流程关系 性能优化方案的建议避免过早优化进行系统性能测试寻找系统瓶颈&…

R 语言相关资源分享

简介 分享一个 Github 仓库&#xff0c;包含了大量 R 语言教程和资源&#xff0c;旨在帮助各种技能水平和背景的用户深化对 R 的理解。 下面给出一些截图&#xff0c;感兴趣的读者可以自行探索&#xff5e;

JVM-2-对象

对象创建 当Java虚拟机遇到一条字节码new指令时&#xff0c;首先将去检查这个指令的参数是否能在常量池中定位到一个类的符号引用&#xff0c;并且检查这个符号引用代表的类是否已被加载、解析和初始化过。如果没有&#xff0c;那必须先执行相应的类加载过程。 为对象分配空间…

003 Windows用户与组管理

Windows用户管理 一、用户账户 1、什么是用户账户 不同用户身份拥有不同的权限每个用户包含了一个名称和一个密码每个用户账户具有唯一的安全标识符查看系统中的用户 net user 安全标识符&#xff08;SID&#xff09; whoami /user 使用注册表查看 打开注册表命令regedi…

阿里云RDS提示过期释放实例了怎么找到库表

做朋友&#xff0c;不需要资格&#xff01;——《全职猎人》 直截了当 一步到位 ~

【数据结构和算法】--队列的特殊结构-循环队列

目录 循环队列的结构循环队列的实现循环队列的创建循环队列为空判断循环队列为满判断入队出队返回循环队列首元素返回循环队列尾元素释放循环队列 循环队列的结构 循环队列是队列的一种特殊结构&#xff0c;它的长度是固定的k&#xff0c;同样是先进先出&#xff0c;理论结构是…

飞翔的鸟。

一.准备工作 首先创建一个新的Java项目命名为“飞翔的鸟”&#xff0c;并在src中创建一个包命名为“com.qiku.bird"&#xff0c;在这个包内分别创建4个类命名为“Bird”、“BirdGame”、“Column”、“Ground”&#xff0c;并向需要的图片素材导入到包内。 二.代码呈现 pa…

大数据分析的流程有哪些

数据的采集和收集。大数据预处理。大数据建模和大数据方法。大数据分析和结果展示。

ChatGPT4 Excel 高级组合函数用法index+match完成实际需求

在Excel 函数用法中有一对组合函数使用是非常多的,那就是Index+match组合函数。 接下来我们用一个实际的需求让ChatGPT来帮我们实现一下。 我们给ChatGPT4发送一个prompt:有一个表格A2至A14为业务员B列至H列为1月至7月的销售额,请根据J2单元格的业务员与K2单元格的月份查找出…

LVS负载均衡群集,熟悉LVS的工作模式,了解LVS的调度策略以及ipvsadm工具的命令格式

目录 一、什么是群集 群集的作用&#xff1a; 群集的目的是什么 根据群集所针对的目标差异&#xff0c;可分为三种类型 负载均衡群集&#xff08;LBC&#xff09;load balance cluster 高可用群集&#xff08;HAC&#xff09;high availability cluster 高性能运算群集&a…

ChatGLM-6B模型结构组件源码阅读

一、前言 本文将介绍ChatGLM-6B的模型结构组件源码。 代练链接&#xff1a;https://huggingface.co/THUDM/chatglm-6b/blob/main/modeling_chatglm.py 二、激活函数 torch.jit.script def gelu_impl(x):"""OpenAIs gelu implementation."""r…

2020 ICPC·小米邀请赛 决赛 J. Rikka with Book(状压dp)

题目 登录—专业IT笔试面试备考平台_牛客网 n(n<20)本书&#xff0c;放在桌子上&#xff0c; 第i本书的可以看成是li(li<1e3)*1*1的物体&#xff0c;其中长为li&#xff0c;宽为1&#xff0c;高为1&#xff0c; 质量均匀分布&#xff0c;且为wi(wi<1e3) 求n本书摞…

基于linux系统的Tomcat+Mysql+Jdk环境搭建(二)jdk1.8 linux 上传到MobaXterm 工具的已有session里

【JDK安装】 1.首先下载一个JDK版本 官网地址&#xff1a;http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html 下载1.8版本&#xff0c;用红框标注出来了&#xff1a; 也许有的同学看到没有1.8版本&#xff0c;你可以随便下载一个linux的…

平均数 C语言xdoj66

问题描述 计算n个整数&#xff08;x1,x2,x3...&#xff09;的平均数&#xff0c;结果保留两位小数。 输入说明 第一行为整数n&#xff08;1 < n <100&#xff09;&#xff0c;接下来是n个整数(0 < x1,x2,x3....< 2^31 - 1)。 输出说明 输出这n个整数的…

电商平台的易聊集成:无代码开发,API连接,CRM支持

连接电商与客服&#xff1a;易聊的创新解决方案 在迅速变化的电子商务市场中&#xff0c;企业要想保持竞争力&#xff0c;就必须拥有高效灵活的客服体系。易聊&#xff0c;一家领先的AISaaS服务商&#xff0c;正是基于这一需求&#xff0c;推出了一系列创新产品。它们通过智能…

C/C++ STL提供的关联式容器之map

map 由红黑树实现&#xff0c;其元素都是 “键值/实值” 所形成的一个对组&#xff08;key/value pairs)。 map 主要用于资料一对一映射的情况&#xff0c;map 内部自建一颗红黑树&#xff0c;这颗树具有对数据自动排序的功能&#xff0c;所以在 map 内部所有的数据都是有序的…

Vue2-动态组件案例

1.component介绍 说明&#xff1a; Type: string | ComponentDefinition | ComponentConstructor Explanation: String: 如果你传递一个字符串给 is&#xff0c;它会被视为组件的名称&#xff0c;用于动态地渲染不同类型的组件。这是一个在运行时动态切换组件类型的常见用例。…

【C++】 C++11 新特性探索:decltype 和 auto

▒ 目录 ▒ &#x1f6eb; 问题描述环境 1️⃣ decltype推导变量类型推导函数返回类型 2️⃣ auto自动推导变量类型迭代器和范围循环 3️⃣ decltype 和 auto 同时使用&#x1f6ec; 结论&#x1f4d6; 参考资料 &#x1f6eb; 问题 描述 C11 引入了一些强大的新特性&#xff…