《面向复杂仿真元建模的序贯近邻探索实验设计方法》论文复现

news2024/12/22 19:41:39

在这里插入图片描述
代码流程

# peaks函数热力图
from matplotlib import pyplot as plot
import numpy as np
import math
from mpl_toolkits.mplot3d import Axes3D

#python绘图显示中文
plot.rcParams['font.sans-serif']=['SimHei']
plot.rcParams['axes.unicode_minus'] = False

#创建画布
fig = plot.figure(figsize=(16,4))

#axes = Axes3D(figure)

# X=差值，Y=距离，Z概率
#生成x,y
X1 = np.arange(-10,5,0.05)
Y1 = np.arange(-5,10,0.05)#前两个参数为自变量取值范围
X1,Y1 = np.meshgrid(X1,Y1)

#peaks1
#z关于x,y的函数关系式,生成z
#Z1 = (5 * ((1 - X1) ** 2)) * (np.exp((-(X1 ** 2)) - ((Y1 + 1) ** 2)))
#Z2 = (5 * ((X1 / 5) - (Y1 ** 5))) * (np.exp(-(X1 ** 2) - (Y1 ** 2)))
#Z3 = 6 * (np.exp(-((X1 + 1) ** 2) - (Y1 ** 2)))
#Z1 = Z1 - Z2 - Z3
Z1 = 5*(1-X1)**2*(np.exp(-X1**2-(Y1+1)**2))-5*(X1/5-Y1**5)*(np.exp(-X1**2-Y1**2))-6*(np.exp(-(X1+1)**2-Y1**2))



#绘制模型
#子图13d坐标系建立
axes1=fig.add_subplot(121,projection='3d')
axes1.plot_surface(X1,Y1,Z1,cmap='rainbow')
#axes1.contourf(X1,Y1,Z1,zdir='z',offset=-2,cmap='rainbow')
#axes1.set(facecolor = "white")
axes1.set_xlabel('X')
axes1.set_ylabel('Y')
axes1.set_zlabel('Z')
#axes1.view_init(5,-75)#坐标系旋转，高程（XY平面上方60度），方位角（绕Z轴逆时针旋转度数）

axes2=fig.add_subplot(122)                      
plot.pcolor(X1,Y1,Z1,cmap ="rainbow")
axes2.set_xlabel('X')
axes2.set_ylabel('Y')
plot.show()


#创建画布
fig = plot.figure(figsize=(16,4))
#peaks2
z1=10*(X1+3)**2*np.exp(-(X1+5)**2-(Y1-5)**2)
z2=8*(X1/5-5*Y1)*np.exp(-(X1**2+Y1**2)/4)
z3=8*np.exp(-(6*X1+1)**2-(3*Y1)**2)
Z2 =z1-z2+z3 
#绘制模型
#子图13d坐标系建立
axes1=fig.add_subplot(121,projection='3d')
axes1.plot_surface(X1,Y1,Z2,cmap='rainbow')
#axes1.contourf(X1,Y1,Z1,zdir='z',offset=-2,cmap='rainbow')
#axes1.set(facecolor = "white")
axes1.set_xlabel('X')
axes1.set_ylabel('Y')
axes1.set_zlabel('Z')
#axes1.view_init(-10,0)#坐标系旋转，高程（XY平面上方60度），方位角（绕Z轴逆时针旋转度数）

axes2=fig.add_subplot(122)                      
plot.pcolor(X1,Y1,Z2,cmap ="rainbow")
axes2.set_xlabel('X')
axes2.set_ylabel('Y')
plot.show()

#1.图1结果和原图不一致
from matplotlib import pyplot as plot
import numpy as np
import math
from mpl_toolkits.mplot3d import Axes3D
#python绘图显示中文
plot.rcParams['font.sans-serif']=['SimHei']
plot.rcParams['axes.unicode_minus'] = False
#创建画布
fig = plot.figure(figsize=(16,4))
#子图13d坐标系建立
axes1=fig.add_subplot(121,projection='3d')
#axes = Axes3D(figure)
# X=差值，Y=距离，Z概率
#生成x,y
X = np.arange(0,1,0.1)
Y = np.arange(0,2**0.5,0.1)#前两个参数为自变量取值范围
x=[math.pow(i,2) for i in X]
y=[math.pow(i,2) for i in Y]
X,Y = np.meshgrid(X,Y)
#生成z
#Z = (X**2+Y**2)/2*(2/math.pi*(np.arctan(X/Y)))**2 #z关于x,y的函数关系式,
Z1=(X**2+Y**2)/3
Z2=2/math.pi
Z3=Z2*(np.arctan(X/Y))
Z=Z1*(Z3**2)
#绘制模型
axes1.plot_surface(X,Y,Z,cmap='rainbow')
#axes1.contourf(X,Y,Z,zdir='z',offset=-2,cmap='rainbow')
axes1.set(facecolor = "white")
axes1.set_xlabel('X:差值')
axes1.set_ylabel('Y:距离')
axes1.set_zlabel('Z:概率')
axes1.view_init(30, -130)#坐标系旋转

#原论文图1中X>0,Y>0
# X^2=差值，Y^2=距离，Z概率
axes2=fig.add_subplot(122,projection='3d')
X1,Y1 = np.meshgrid(x,y)
Z1 = (X1+Y1)/3*(2/math.pi*np.arctan(np.sqrt(X1/Y1)))**2 #z关于x,y的函数关系式,此处为锥面
axes2.plot_surface(X1,Y1,Z1,cmap='rainbow')
#axes2.patch.set_facecolor('blue')
axes2.set_xlabel('X:差值平方')
axes2.set_ylabel('Y:距离平方')
axes2.set_zlabel('Z:概率')
axes2.view_init(30, -130)
plot.show()

import numpy as np
import time

from matplotlib import pyplot as plot
import numpy as np
import math
from mpl_toolkits.mplot3d import Axes3D
import random
import os

import matplotlib.pyplot as plt
from scipy.cluster.hierarchy import dendrogram, ward
# 现在为包含簇之间距离的linkage_array绘制树状图
from sklearn.cluster import AgglomerativeClustering

seed=13
random.seed(seed)
np.random.seed(seed)
os.environ['PYTHONHASHSEED']=str(seed)

x=np.linspace(-12,4,num=11)
y=np.linspace(-6,10,num=11)
X=[]
Y=[]
for i in range(len(x)-1):
    xi=random.uniform(x[i],x[i+1])
    X.append(xi)
for i in range(len(y)-1):
    yi=random.uniform(y[i],y[i+1])
    Y.append(yi)
#print(X)
#print(len(X))


X,Y = np.meshgrid(X,Y)

Z = 5*(1-X)**2*(np.exp(-X**2-(Y+1)**2))-5*(X/5-Y**5)*(np.exp(-X**2-Y**2))-6*(np.exp(-(X+1)**2-Y**2))


Z1 = Z.ravel()
Z1=np.array(Z1)
Z1=np.array(Z1).reshape(-1, 1)

print(len(Z1))

fig =plot.figure(figsize=(30,24))
ax1=fig.add_subplot(331)
ax1.grid()
ax1.scatter(X,Y)

ax2=fig.add_subplot(332,projection='3d')
ax2.plot_surface(X,Y,Z,cmap='rainbow')
ax2.set_xlabel('X')
ax2.set_ylabel('Y')
ax2.set_zlabel('Z')

X1 = X.ravel()
X1=np.array(X1)
X1=np.array(X1).reshape(-1, 1)
Y1 = Y.ravel()
Y1=np.array(Y1)
Y1=np.array(Y1).reshape(-1, 1)
samplesxy=np.hstack((X1,Y1))
samples=np.hstack((X1,Y1,Z1))
 
 
class Node(object):
    '''结点对象'''
    def __init__(self, item=None, label=None, dim=None, parent=None, left_child=None, right_child=None):
        self.item = item   # 结点的值(样本信息)
        self.label = label  # 结点的标签
        self.dim = dim   # 结点的切分的维度(特征)
        self.parent = parent  # 父结点
        self.left_child = left_child  # 左子树
        self.right_child = right_child # 右子树
 
 
class KDTree(object):
    '''kd树'''
 
    def __init__(self, aList, labelList):
        self.__length = 0  # 不可修改
        self.__root = self.__create(aList,labelList)  # 根结点, 私有属性, 不可修改
 
    def __create(self, aList, labelList, parentNode=None):
        '''
        创建kd树
        :param aList: 需要传入一个类数组对象(行数表示样本数，列数表示特征数)
        :labellist: 样本的标签
        :parentNode: 父结点
        :return: 根结点
        '''
        dataArray = np.array(aList)
        m,n = dataArray.shape
        labelArray = np.array(labelList).reshape(m,1)
        if m == 0:  # 样本集为空
            return None
        # 求所有特征的方差，选择最大的那个特征作为切分超平面
        var_list = [np.var(dataArray[:,col]) for col in range(n)]  # 获取每一个特征的方差
        max_index = var_list.index(max(var_list))  # 获取最大方差特征的索引
        # 样本按最大方差特征进行升序排序后，取出位于中间的样本
        max_feat_ind_list = dataArray[:,max_index].argsort()
        mid_item_index = max_feat_ind_list[m // 2]
        if m == 1:  # 样本为1时，返回自身
            self.__length += 1
            return Node(dim=max_index,label=labelArray[mid_item_index], item=dataArray[mid_item_index], parent=parentNode, left_child=None, right_child=None)
 
        # 生成结点
        node = Node(dim=max_index, label=labelArray[mid_item_index], item=dataArray[mid_item_index], parent=parentNode, )
        # 构建有序的子树
        left_tree = dataArray[max_feat_ind_list[:m // 2]] # 左子树
        left_label = labelArray[max_feat_ind_list[:m // 2]] # 左子树标签
        left_child = self.__create(left_tree,left_label,node)
        if m == 2:  # 只有左子树，无右子树
            right_child = None
        else:
            right_tree = dataArray[max_feat_ind_list[m // 2 + 1:]] # 右子树
            right_label = labelArray[max_feat_ind_list[m // 2 + 1:]] # 右子树标签
            right_child = self.__create(right_tree,right_label,node)
            # self.__length += 1
        # 左右子树递归调用自己，返回子树根结点
        node.left_child=left_child
        node.right_child=right_child
        self.__length += 1
        return node
 
    @property
    def length(self):
        return self.__length
 
    @property
    def root(self):
        return self.__root
 
    def transfer_dict(self,node):
        '''
        查看kd树结构
        :node:需要传入根结点对象
        :return: 字典嵌套格式的kd树,字典的key是self.item,其余项作为key的值，类似下面格式
        {(1,2,3):{
                'label':1,
                'dim':0,
                'left_child':{(2,3,4):{
                                     'label':1,
                                     'dim':1,
                                     'left_child':None,
                                     'right_child':None
                                    },
                'right_child':{(4,5,6):{
                                        'label':1,
                                        'dim':1,
                                        'left_child':None,
                                        'right_child':None
                                        }
                }
        '''
        if node == None:
            return None
        kd_dict = {}
        kd_dict[tuple(node.item)] = {}  # 将自身值作为key
        kd_dict[tuple(node.item)]['label'] = node.label[0]
        kd_dict[tuple(node.item)]['dim'] = node.dim
        kd_dict[tuple(node.item)]['parent'] = tuple(node.parent.item) if node.parent else None
        kd_dict[tuple(node.item)]['left_child'] = self.transfer_dict(node.left_child)
        kd_dict[tuple(node.item)]['right_child'] = self.transfer_dict(node.right_child)
        return kd_dict
 
    def transfer_list(self,node, kdList=[]):
        '''
        将kd树转化为嵌套字典的列表输出
        :param node: 需要传入根结点
        :return: 返回嵌套字典的列表，格式如下
        [{'item': (9, 3),
             'label': 1,
             'dim': 0,
             'parent': None,
             'left_child': (3, 4),
             'right_child': (11, 11)
         },
         {'item': (3, 4),
            'label': 1,
            'dim': 1,
            'parent': (9, 3),
            'left_child': (7, 0),
            'right_child': (3, 15)
         }]
        '''
        if node == None:
            return None
        element_dict = {}
        element_dict['item'] = tuple(node.item)
        element_dict['label'] = node.label[0]
        element_dict['dim'] = node.dim
        element_dict['parent'] = tuple(node.parent.item) if node.parent else None
        element_dict['left_child'] = tuple(node.left_child.item) if node.left_child else None
        element_dict['right_child'] = tuple(node.right_child.item) if node.right_child else None
        kdList.append(element_dict)
        self.transfer_list(node.left_child, kdList)
        self.transfer_list(node.right_child, kdList)
        return kdList
 
    def _find_nearest_neighbour(self, item):
        '''
        找最近邻点
        :param item:需要预测的新样本
        :return: 距离最近的样本点
        '''
        itemArray = np.array(item)
        if self.length == 0:  # 空kd树
            return None
        # 递归找离测试点最近的那个叶结点
        node = self.__root
        if self.length == 1: # 只有一个样本
            return node
        while True:
            cur_dim = node.dim
            if item[cur_dim] == node.item[cur_dim]:
                return node
            elif item[cur_dim] < node.item[cur_dim]:  # 进入左子树
                if node.left_child == None:  # 左子树为空，返回自身
                    return node
                node = node.left_child
            else:
                if node.right_child == None:  # 右子树为空，返回自身
                    return node
                node = node.right_child
 
    def knn_algo(self, item, k=1):
        '''
        找到距离测试样本最近的前k个样本
        :param item: 测试样本
        :param k: knn算法参数，定义需要参考的最近点数量，一般为1-5
        :return: 返回前k个样本的最大分类标签
        '''
        if self.length <= k:
            label_dict = {}
            # 获取所有label的数量
            for element in self.transfer_list(self.root):
                if element['label'] in label_dict:
                    label_dict[element['label']] += 1
                else:
                    label_dict[element['label']] = 1
            sorted_label = sorted(label_dict.items(), key=lambda item:item[1],reverse=True)  # 给标签排序
            return sorted_label[0][0]
 
        item = np.array(item)
        node = self._find_nearest_neighbour(item)  # 找到最近的那个结点
        if node == None:  # 空树
            return None
       # print('靠近点%s最近的叶结点为:%s'%(item, node.item))
        node_list = []
        distance = np.sqrt(sum((item-node.item)**2))  # 测试点与最近点之间的距离
        least_dis = distance
        # 返回上一个父结点，判断以测试点为圆心，distance为半径的圆是否与父结点分隔超平面相交，若相交，则说明父结点的另一个子树可能存在更近的点
        node_list.append([distance, tuple(node.item), node.label[0]])  # 需要将距离与结点一起保存起来
 
        # 若最近的结点不是叶结点，则说明，它还有左子树
        if node.left_child != None:
            left_child = node.left_child
            left_dis = np.sqrt(sum((item-left_child.item)**2))
            if k > len(node_list) or least_dis < least_dis:
                node_list.append([left_dis, tuple(left_child.item), left_child.label[0]])
                node_list.sort()  # 对结点列表按距离排序
                least_dis = node_list[-1][0] if k >= len(node_list) else node_list[k-1][0]
        # 回到父结点
        while True:
            if node == self.root:  # 已经回到kd树的根结点
                break
            parent = node.parent
            # 计算测试点与父结点的距离，与上面距离做比较
            par_dis = np.sqrt(sum((item-parent.item)**2))
            if k >len(node_list) or par_dis < least_dis:  # k大于结点数或者父结点距离小于结点列表中最大的距离
                node_list.append([par_dis, tuple(parent.item) , parent.label[0]])
                node_list.sort()  # 对结点列表按距离排序
                least_dis = node_list[-1][0] if k >= len(node_list) else node_list[k - 1][0]
 
            # 判断父结点的另一个子树与结点列表中最大的距离构成的圆是否有交集
            if k >len(node_list) or abs(item[parent.dim] - parent.item[parent.dim]) < least_dis :  # 说明父结点的另一个子树与圆有交集
                # 说明父结点的另一子树区域与圆有交集
                other_child = parent.left_child if parent.left_child != node else parent.right_child  # 找另一个子树
                # 测试点在该子结点超平面的左侧
                if other_child != None:
                    if item[parent.dim] - parent.item[parent.dim] <= 0:
                        self.left_search(item,other_child,node_list,k)
                    else:
                        self.right_search(item,other_child,node_list,k)  # 测试点在该子结点平面的右侧
 
            node = parent  # 否则继续返回上一层
        # 接下来取出前k个元素中最大的分类标签
        label_dict = {}
        node_list = node_list[:k]
        # 获取所有label的数量
        for element in node_list:
            if element[2] in label_dict:
                label_dict[element[2]] += 1
            else:
                label_dict[element[2]] = 1
        sorted_label = sorted(label_dict.items(), key=lambda item:item[1], reverse=True)  # 给标签排序
        return sorted_label[0][0],node_list
 
    def left_search(self, item, node, nodeList, k):
        '''
        按左中右顺序遍历子树结点，返回结点列表
        :param node: 子树结点
        :param item: 传入的测试样本
        :param nodeList: 结点列表
        :param k: 搜索比较的结点数量
        :return: 结点列表
        '''
        nodeList.sort()  # 对结点列表按距离排序
        least_dis = nodeList[-1][0] if k >= len(nodeList) else nodeList[k - 1][0]
        if node.left_child == None and node.right_child == None:  # 叶结点
            dis = np.sqrt(sum((item - node.item) ** 2))
            if k > len(nodeList) or dis < least_dis:
                nodeList.append([dis, tuple(node.item), node.label[0]])
                #nodeList.append([list(node.item), node.label[0]])
            return
        self.left_search(item, node.left_child, nodeList, k)
        # 每次进行比较前都更新nodelist数据
        nodeList.sort()  # 对结点列表按距离排序
        least_dis = nodeList[-1][0] if k >= len(nodeList) else nodeList[k - 1][0]
        # 比较根结点
        dis = np.sqrt(sum((item-node.item)**2))
        if k > len(nodeList) or dis < least_dis:
            nodeList.append([dis, tuple(node.item), node.label[0]])
            #nodeList.append([list(node.item), node.label[0]])
        # 右子树
        if k > len(nodeList) or abs(item[node.dim] - node.item[node.dim]) < least_dis: # 需要搜索右子树
            if node.right_child != None:
                self.left_search(item, node.right_child, nodeList, k)
 
        return nodeList
 
    def right_search(self,item, node, nodeList, k):
        '''
        按右中左顺序遍历子树结点
        :param item: 测试的样本点
        :param node: 子树结点
        :param nodeList: 结点列表
        :param k: 搜索比较的结点数量
        :return: 结点列表
        '''
        nodeList.sort()  # 对结点列表按距离排序
        least_dis = nodeList[-1][0] if k >= len(nodeList) else nodeList[k - 1][0]
        if node.left_child == None and node.right_child == None:  # 叶结点
            dis = np.sqrt(sum((item - node.item) ** 2))
            if k > len(nodeList) or dis < least_dis:
                nodeList.append([dis, tuple(node.item), node.label[0]])
                #nodeList.append([list(node.item), node.label[0]])
            return
        if node.right_child != None:
            self.right_search(item, node.right_child, nodeList, k)
 
        nodeList.sort()  # 对结点列表按距离排序
        least_dis = nodeList[-1][0] if k >= len(nodeList) else nodeList[k - 1][0]
        # 比较根结点
        dis = np.sqrt(sum((item - node.item) ** 2))
        if k > len(nodeList) or dis < least_dis:
            nodeList.append([dis, tuple(node.item), node.label[0]])
            #nodeList.append([list(node.item), node.label[0]])
        # 左子树
        if k > len(nodeList) or abs(item[node.dim] - node.item[node.dim]) < least_dis: # 需要搜索左子树
            self.right_search(item, node.left_child, nodeList, k)
 
        return nodeList

    
def node_listtoarray(nodelist):
    n=len(nodelist)
    nodelistarray=[]
    for i in range(n):
        dis=nodelist[i][0]
        x=nodelist[i][1][0]
        y=nodelist[i][1][-1]
        z=nodelist[i][-1]
        nodelistarray.append([x,y,z,dis])#sqrtdis
    nodelistarray=np.array(nodelistarray)
    return (nodelistarray)

    
def normsamples(neibors):
    x=neibors[:,0]
    y=neibors[:,1]
    z=neibors[:,2]
    normneibors=[]
    for i in range(len(x)):
        if max(x)-min(x)!=0:
            xnormi=(x[i]-min(x))/(max(x)-min(x))
        else:
            xnormi=x[i]
        if max(y)-min(y)!=0:
            ynormi=(y[i]-min(y))/(max(y)-min(y))
        else:
            ynormi=y[i]
        if max(z)-min(z)!=0:
            znormi=(z[i]-min(z))/(max(z)-min(z))
        else:
            znormi=z[i]
        normneibors.append([xnormi,ynormi,znormi])
    normneibors=np.array(normneibors)
    return (normneibors)


def newpoints(oldpoint,itneibor):
    newpointss=[]
    gp=[]
    for i in range(1,len(itneibor)):
        xmeani=(oldpoint[0]+itneibor[i][0])/2
        ymeani=(oldpoint[1]+itneibor[i][1])/2
        diffxi=abs(oldpoint[0]-itneibor[i][0])
        diffyi=abs(oldpoint[1]-itneibor[i][1])
        xi=xmeani+int(random.sample([1,-1], 1)[0])*1/6*random.uniform(0,diffxi)
        yi=ymeani+int(random.sample([1,-1], 1)[0])*1/6*random.uniform(0,diffyi)
        zi=5*(1-xi)**2*(np.exp(-xi**2-(yi+1)**2))-5*(xi/5-yi**5)*(np.exp(-xi**2-yi**2))-6*(np.exp(-(xi+1)**2-yi**2))
        thenew=[xi,yi,zi]

        itneibor=normsamples(itneibor)
        grad=itneibor[0][-1]-itneibor[i][-1]
        distancesqure=0
        for j in range(len(oldpoint)-1):#(x,y) no z
            distancesqure+=(itneibor[0][j]-itneibor[i][j])**2
        distance=distancesqure**0.5
        delta=2/math.pi*np.arctan(grad/distance)
        generateprobability=(grad**2+distancesqure)/3*(delta**2)
        if generateprobability>=1.50e-1:
            newpointss.append(thenew)
            gp.append(generateprobability)        
    newpointss=np.array(newpointss)
    gp=np.array(gp) 
    #newpoints_p= np.column_stack((newpointss,gp))
    return (newpointss)


def allnewpointsai(samples):
    dataArray=samples[:,0:-1]
    label=samples[:,-1]
    kd_tree = KDTree(dataArray,label)
    allnewnpoints=samples
    for i in range(len(samples)):
        label, node_list = kd_tree.knn_algo(dataArray[i],k=20)
        nodeneibor=node_listtoarray(node_list)
        newpoint=newpoints(dataArray[i],nodeneibor)
        if len(newpoint)!=0:
            allnewnpoints=np.vstack((allnewnpoints,newpoint))
    return (allnewnpoints[len(samples):])


ps=[]
newpoints1=allnewpointsai(samples)
ps1=len(newpoints1)/(len(newpoints1)+len(samples))
ps.append(ps1)
print("第1次迭代产生{0}个点，占比{1}".format(len(newpoints1),len(newpoints1)/(len(newpoints1)+len(samples))))
samples=np.vstack((samples,newpoints1))
for i in range(1,100):
    newpointsi=allnewpointsai(samples)
    psi=len(newpointsi)/(len(newpointsi)+len(samples))
    ps.append(psi)
    if ps[i]>0.1 and abs(ps[i-1]-ps[i])>0.005:
        print("第{0}次迭代产生{1}个点，占比{2}".format(i+1,len(newpointsi),len(newpointsi)/(len(newpointsi)+len(samples))))
        samples=np.vstack((samples,newpointsi))
    else:
        break

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

GPT系列概述

GPT系列概述

OPENAI做的东西 Openai老窝在爱荷华州&#xff0c;微软投资的数据中心 万物皆可GPT下咱们要失业了&#xff1f; 但是世界不仅仅是GPT GPT其实也只是冰山一角&#xff0c;2022年每4天就有一个大型模型问世 GPT历史时刻 GPT-1 带回到2018年的NLP 所有下游任务都需要微调&#x…
阅读更多...
sudo: /usr/bin/sudo must be owned by uid 0 and have the setuid bit set问题解决方案

sudo: /usr/bin/sudo must be owned by uid 0 and have the setuid bit set问题解决方案

sudo: /usr/bin/sudo must be owned by uid 0 and have the setuid bit set问题解决方案 当我们使用sudo su切换权限时提示错误&#xff1a; sudo: /usr/bin/sudo must be owned by uid 0 and have the setuid bit set该错误出现原因&#xff1a;是因为/usr/bin/sudo的权限被…
阅读更多...
计算机网络复习5

计算机网络复习5

传输层——端到端 文章目录 传输层——端到端功能传输层的寻址与端口UDPTCPTCP连接管理TCP可靠传输TCP流量控制TCP拥塞控制网络拥塞的处理 功能 从通信和信息处理的角度看&#xff0c;传输层向它上面的应用层提供通信服务&#xff0c;它属于面向通信部分的最高层&#xff0c;同…
阅读更多...
再升级|川石教育鸿蒙应用开发4.0教程发布

再升级|川石教育鸿蒙应用开发4.0教程发布

全新鸿蒙蓄势待发 HarmonyOS是一款面向未来的全场景分布式智慧操作系统。 对于消费者而言&#xff0c;HarmonyOS用一个统一的软件系统从根本上解决消费者面对大量智能终端体验割裂的问题&#xff0c;为消费者带来统一、便利、安全的智慧化全场景体验。 对于开发者而言&#xf…
阅读更多...
现在AI那么发达，还有必要系统地学习Excel吗？

现在AI那么发达，还有必要系统地学习Excel吗？

随着人工智能&#xff08;AI&#xff09;技术的飞速发展&#xff0c;许多传统的工作和技能正在逐渐被自动化和取代。在这个背景下&#xff0c;一些人开始质疑学习Excel等传统技能的必要性。然而&#xff0c;我认为学习Excel仍然是非常有必要的&#xff0c;原因如下。 首先&…
阅读更多...
.NET DevOps 接入指南 | 1. GitLab 安装

.NET DevOps 接入指南 | 1. GitLab 安装

引言 容器、DevOps和微服务被称为驱动云原生快速发展的三架马车。而DevOps是其中非常重要的一环&#xff0c;DevOps 是由Developers&#xff08;Dev&#xff09;和Operations&#xff08;Ops&#xff09;两个单词简称组成&#xff0c;中文直译就是“开发运维一体化”。 DevOps…
阅读更多...
python大于等于小于等于,python大于等于怎么写

python大于等于小于等于,python大于等于怎么写

大家好&#xff0c;小编为大家解答python中大于等于且小于等于的问题。很多人还不知道python大于号小于号如何运用&#xff0c;现在让我们一起来看看吧&#xff01; 大家好&#xff0c;小编来为大家解答以下问题&#xff0c;python中大于并小于一个数代码&#xff0c;python 大…
阅读更多...
STL——stack容器

STL——stack容器

1.stack基本概念 概念&#xff1a;stack是一种先进后出&#xff08;First In Last Out,FILO&#xff09;的数据结构&#xff0c;它只有一个出口。 栈中只有顶端的元素才可以被外界使用&#xff0c;因此栈不允许有遍历行为。 栈中进入数据称为——入栈&#xff08;push&#x…
阅读更多...
大模型系列：OpenAI使用技巧_自定义文本向量化embeding

大模型系列：OpenAI使用技巧_自定义文本向量化embeding

文章目录 0. Imports1. 输入2. 加载和处理输入数据3. 将数据分成训练和测试集4. 生成合成的负样本5. 计算嵌入和余弦相似度6. 绘制余弦相似度的分布图7. 使用提供的训练数据优化矩阵。8. 绘制训练期间找到的最佳矩阵的前后对比图&#xff0c;展示结果 本笔记本演示了一种将Open…
阅读更多...
计算每个月的天数

计算每个月的天数

大家好呀&#xff0c;今天的每日一题来喽。准备好了吗亲。上车上车&#xff01;&#xff01;&#xff01; 文章目录 目录 文章目录 题目重现 输⼊y和m两个整数&#xff0c;y表⽰年份&#xff0c;m表⽰⽉份&#xff0c;计算y年m⽉有多少天&#xff0c;并输出天数。 一、解法思路…
阅读更多...
k8s之陈述式资源管理

k8s之陈述式资源管理

1.kubectl命令 kubectl version 查看k8s的版本 kubectl api-resources 查看所有api的资源对象的名称 kubectl cluster-info 查看k8s的集群信息 kubectl get cs 查看master节点的状态 kubectl get pod 查看默认命名空间内的pod的信息 kubectl get ns 查看当前集群所有的命…
阅读更多...
遍历二叉树的Morris序

遍历二叉树的Morris序

参考书&#xff1a;《程序员代码面试指南》 这种方法的好处在于&#xff0c;它做到了时间复杂度为O(n)&#xff0c;额外空间复杂度为O(1)&#xff08;只申请几个变量就可以完成整个二叉树的遍历&#xff09;。 Morris遍历时cur访问节点的顺序就是morris序&#xff0c;可以在M…
阅读更多...
大模型系列：OpenAI使用技巧_在文本向量化的交易数据做多标签分类

大模型系列：OpenAI使用技巧_在文本向量化的交易数据做多标签分类

本笔记本涵盖了数据未标记但具有可用于将其聚类为有意义的类别的特征的用例。聚类的挑战在于使那些使得这些聚类突出的特征可读&#xff0c;这就是我们将使用GPT-3生成有意义的聚类描述的地方。然后&#xff0c;我们可以使用这些描述来为以前未标记的数据集应用标签。 为了向模…
阅读更多...
大数据技术16：数据湖和湖仓一体

大数据技术16：数据湖和湖仓一体

前言&#xff1a;近几年大数据概念很多&#xff0c;数据库和数据仓库还没搞清楚&#xff0c;就又出了数据湖&#xff0c;现在又开始流行湖仓一体。互联网公司拼命造高大上概念来忽略小白买单的能力还是可以的。 1、数据库 数据库是结构化信息或数据的有序集合&#xff0c;一般以…
阅读更多...
分享一款超强大的抖音数据采集工具

分享一款超强大的抖音数据采集工具

你好&#xff0c;我是坚持分享干货的 EarlGrey&#xff0c;翻译出版过《Python编程无师自通》、《Python并行计算手册》等技术书籍。 如果我的分享对你有帮助&#xff0c;请关注我&#xff0c;一起向上进击。 创作不易&#xff0c;希望大家给一点鼓励&#xff0c;把公众号设置为…
阅读更多...
轮廓检测与处理

轮廓检测与处理

轮廓检测 先将图像转换成二值 gray cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) # 灰度图 ret, thresh cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY) # 变为二值&#xff0c;大于127置为255&#xff0c;小于100置为0.使用cv2.findContours(thresh, cv2.RETR_TREE, cv2.…
阅读更多...
【Unity入门】热更新框架之xLua

【Unity入门】热更新框架之xLua

目录 一、xLua概述1.1xLua简介1.2xLua安装 二、Lua文件加载2.1执行字符串2.2加载Lua文件2.3自定义loader 三、xLua文件配置3.1打标签3.2静态列表3.3动态列表 四、Lua与C#交互4.1 C#访问Lua4.1.1 获取一个全局基本数据类型4.1.2 访问一个全局的table4.1.3 访问一个全局的functio…
阅读更多...
【Unity美术】Unity工程师对3D模型需要达到的了解【一】

【Unity美术】Unity工程师对3D模型需要达到的了解【一】

&#x1f468;‍&#x1f4bb;个人主页&#xff1a;元宇宙-秩沅 &#x1f468;‍&#x1f4bb; hallo 欢迎 点赞&#x1f44d; 收藏⭐ 留言&#x1f4dd; 加关注✅! &#x1f468;‍&#x1f4bb; 本文由 秩沅 原创 &#x1f468;‍&#x1f4bb; 收录于专栏&#xff1a;Uni…
阅读更多...
机器学习之K-means聚类

机器学习之K-means聚类

概念 K-means是一种常用的机器学习算法，用于聚类分析。聚类是一种无监督学习方法，它试图将数据集中的样本划分为具有相似特征的组（簇）。K-means算法的目标是将数据集划分为K个簇，其中每个样本属于与其最近的簇中心。 以下是K-means算法的基本步骤： 选择簇的数量（K值）…
阅读更多...
算法分析与设计基础

算法分析与设计基础

一、绪论 1.算法的概念及特征 1.1 定义&#xff1a; 算法是指求解某个问题或是某类问题的一系列无歧义的指令&#xff0c;也就是说&#xff0c;对于符合一定规范的输入&#xff0c;能够在有限时间内获得所要求的输出。 1.2 特征&#xff1a; 输入&#xff1a;算法中的各种运…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023