萤火虫算法

2025年3月17日 | 阅读 12 分钟

在优化算法的世界里，当性能与优雅相遇，一道耀眼的光芒闪耀着：萤火虫算法（FA）。受到夜空中萤火虫迷人景象的启发，这种元启发式方法自2008年由Xin-She Yang提出以来，就吸引了研究人员和实践者们的目光。让我们踏上一次冒险之旅，揭开萤火虫算法的光明本质，探索它的起源、原理、应用和潜在的未来前景。

萤火虫算法的诞生可以追溯到萤火虫在黑暗中用它们断断续续的闪光来照亮夜空的迷人行为。就像那些作为交流和吸引配偶信号的天然发光体一样，萤火虫算法通过优化问题的复杂景观，编排出一场寻找最佳路径的解决方案的舞蹈。

原则

核心在于，萤火虫算法利用了群体智能的原理，从萤火虫的集体行为中汲取灵感。该算法在一个萤火虫种群上运行，每个萤火虫代表问题空间中的一个候选解决方案。萤火虫的亮度象征着其解决方案的质量，亮度越高的萤火虫表示结果越好。

优化的编舞始于一群随机分布在搜索空间中的萤火虫。随着算法的展开，萤火虫们在吸引和运动的优雅芭蕾中互动，受更明亮的同类的吸引。通过迭代互动，萤火虫会向更明亮化的区域聚集，这对应于引导一群人走向有希望的领土的集体智能。

对于萤火虫算法的有效性至关重要的是探索与开发之间的微妙平衡。虽然萤火虫会被更明亮的同伴所吸引，但它们的运动也表现出一定程度的随机性，这允许探索未知的领域。这种进化的舞蹈使得算法能够摆脱局部最优解，并收敛到全局最优解。

现在我们将尝试使用萤火虫算法来优化初始的质心位置，然后再使用K-means聚类。萤火虫算法在计算萤火虫的吸引力（beta）、改变它们的位置以及设定优化过程的终止条件方面有所不同。这些变化会影响收敛行为、优化速度，以及最终K-means聚类得到的质心的质量。

代码

导入库

import math
import random
import numpy as np
import pandas as pd
from math import exp
from copy import deepcopy
from matplotlib import pyplot as plt
plt.style.use('ggplot')

读取数据集

# Exclude dataset
data_frame = pd.read_csv('../input/testverim/xclara.csv',index_col=False)
cols = [1,2]
data = data_frame[data_frame.columns[cols]]

# We will Print about the Dataset
len_data_points = data.shape[0]
print("Number of data points : {}".format(len_data_points))

max_list = []
min_list = []

v1_max = data['V1'].max()
v1_min = data['V1'].min()
v2_max = data['V2'].max()
v2_min = data['V2'].min()

max_list.append(v1_max)
max_list.append(v2_max)
min_list.append(v1_min)
min_list.append(v2_min)

print("v1 max : {}, v1 min : {}, v2 max : {}, v2 min : {}".format(v1_max,v1_min,v2_max,v2_min))

输出

点可视化

v1_values = data['V1'].values
v2_values = data['V2'].values
X = np.array(list(zip(v1_values, v2_values)))


plt.scatter(v1_values, v2_values, c = 'black', s = 7)
plt.show()

输出

萤火虫算法

现在我们将萤火虫算法与K-means的聚类效率相结合，为给定的数据集寻找最佳的聚类质心。在此方法中，我们将具有

它使用固定数量的迭代次数（max_generation）来确定何时结束优化过程。它执行算法一段时间后停止。
此方法通过测量每只萤火虫内部数据点与质心之间的欧几里得距离来计算目标函数。它计算萤火虫矩阵中每个数据点与质心之间的距离。
它将根据alpha、beta和gamma等特定特征计算萤火虫的移动，并相应地更新它们的位置。

max_generation = 10 #Iteration, generation count
k = 3 # Number of clusters

# Creating firefly swarm matrix
firefly_swarm_size= 5
firefly_swarm_matrice = np.zeros((firefly_swarm_size,k,2), dtype=np.float64)

for i in range(firefly_swarm_size):
    centroid_x_location_list = np.random.randint(0, 200, size=k)
    centroid_y_location_list = np.random.randint(0, 200, size=k)
    Y = np.array(list(zip(centroid_x_location_list, centroid_y_location_list)), dtype=np.float32)
    firefly_swarm_matrice[i] = Y

print("Ba?lang?? Ate?b?ce?i Matrisi : " + "\n",firefly_swarm_matrice)

# Objective function calculation
J = np.zeros((firefly_swarm_size), dtype=np.float64)

def cal_objective(num):
    arr = np.ones((len_data_points, k), dtype=np.float64)
    for j in range(len_data_points):
        for i in range(k):
            try:
              dis = math.sqrt(((float(X[j][0] )- firefly_swarm_matrice[num][i][0]) ** 2) + ((float(X[j][1]) - firefly_swarm_matrice[num][i][1]) ** 2))
              arr[j][i] = dis
            except ValueError:
                continue
    # Nearest distances cluster
    min_dist_cluster_0 = np.ones((len_data_points), dtype=np.float64)

    for j in range(len_data_points):
        min = 0
        val=0
        for i in range(k):
            if arr[j][i] < arr[j][min]:
                    val = arr[j][i]
                    min = i

        min_dist_cluster_0[j] = val
    sum=0
    for i in range(len_data_points):
        sum=sum+min_dist_cluster_0[i]

    J[num]=math.sqrt(sum)
    return J[num]

for i in range(firefly_swarm_size):
    J[i]=cal_objective(i)

print(J)
# Firefly parameters
alpha = 0.5
beta = 0
beta_0 = 1
gamma = 1

# Find the best Firefly optimization
obj=[]
for gen in range(max_generation):
    for i in range(5):
        scale = abs((max_list[0] - min_list[0])+(max_list[1]-max_list[1]))
        for j in range(5):
            if(J[i]>J[j]):
                r=0
                for l in range(k):
                    r=r+(firefly_swarm_matrice[i][l][0] - firefly_swarm_matrice[j][l][0]) + (firefly_swarm_matrice[i][l][1] - firefly_swarm_matrice[j][l][1])
                r = abs(r)
                r = math.sqrt(r)
                betamin=0.2
                gamma=1.0
                beta0 = 1.0
                beta = (beta0 - betamin) * \
                       math.exp(-gamma * math.pow(r, 2.0)) + betamin
                beta = beta_0 * (exp(-gamma) * (r** 2))
                for l in range(k):
                    r = random.uniform(0, 1)
                    tmpf = alpha * (r - 0.5) * scale
                    firefly_swarm_matrice[i][l][0] = firefly_swarm_matrice[i][l][0] * (1.0 - beta) +firefly_swarm_matrice[j][l][0] * beta + tmpf
                    firefly_swarm_matrice[i][l][1] = firefly_swarm_matrice[i][l][1] * (1.0 - beta) + firefly_swarm_matrice[j][l][1] * beta + tmpf

            temp = np.zeros((k, 2), dtype=np.float64)
            temp = firefly_swarm_matrice[i]
            for l in range(k):
                for s in range(2):
                    if temp[l][s] < min_list[s]:
                        temp[l][s] = random.uniform(min_list[s],max_list[s])

                    if temp[l][s] > max_list[s]:
                        temp[l][s] = random.uniform(min_list[s],max_list[s])


            firefly_swarm_matrice[i] = temp
            arr = np.zeros((len_data_points, k), dtype=np.float64)
            for n in range(len_data_points):
                for m in range(k):
                    try:

                        dis = math.sqrt(((float(X[n][0]) - firefly_swarm_matrice[i][m][0]) ** 2) + ((float(X[n][1]) - firefly_swarm_matrice[i][m][1]) ** 2))
                        arr[n][m] = dis
                    except ValueError:
                        continue
            min_dist_clus = np.zeros((len_data_points), dtype=np.float64)
            for n in range(len_data_points):
                min = 0
                val=0
                for m in range(k):
                    if arr[n][m] < arr[n][min]:
                            val = arr[n][m]
                            min= m

                min_dist_clus[n] = val

            sum = 0
            for n in range(len_data_points):
                sum = sum + min_dist_clus[n]
            J[i]= math.sqrt(sum)

    obj.append(np.amin(J))
    for i in range(1,5):
        if(J[i-1]<J[i]):
            best=i

print("En iyi ate? b?ce?i matrisi : " + "\n",firefly_swarm_matrice[best])

# Calculating Euclidean distance
def dist(v1_max, v1_min, ax=1):
    return np.linalg.norm(v1_max - v1_min, axis=ax)

# k-means part

# Definition of centroid values
centroid_values = firefly_swarm_matrice[best]
print("Ba?lang?? Centroid De?erleri : " + "\n",centroid_values)
centroid_x_location_list = []
centroid_y_location_list = []

for i in range(k):
    centroid_x_location_list.append(centroid_values[i][0])
    centroid_y_location_list.append(centroid_values[i][1])

# To store updated values
C_old = np.zeros(centroid_values.shape)
# Clusters
clusters = np.zeros(len(X))

# Error function for old centroids and new centroids
error = dist(centroid_values, C_old, None)

# The loop will continue until the error becomes zero
k_obj=[]
x_axis=[]
x_val=[]
val=200
count=0
while error != 0:
    x_axis.append(count)
    x_val.append(val)
    count += 1
    val+=1

    arr = np.ones((len_data_points, k), dtype=np.float64)
    for j in range(len_data_points):
        for i in range(k):
            try:
                dis = math.sqrt(((float(X[j][0]) - centroid_values[i][0]) ** 2) + ((float(X[j][1]) - centroid_values[i][1]) ** 2))
                arr[j][i] = dis
            except ValueError:
                continue

    min_dist_cluster_0 = np.ones((len_data_points), dtype=np.float64)  # en yak?n k?me mesafesini hesaplar.
    for j in range(len_data_points):
        min = 0
        val = 0
        for i in range(k):
            if arr[j][i] < arr[j][min]:
                val = arr[j][i]
                min = i

        min_dist_cluster_0[j] = val

    sum = 0
    for i in range(len_data_points):
        sum = sum + min_dist_cluster_0[i]

    J= math.sqrt(sum)
    obj.append(J)
    # Assign values to the nearest cluster
    for i in range(len(X)):
        distances = dist(X[i], centroid_values)
        cluster = np.argmin(distances)
        clusters[i] = cluster

    # Store old centroid data.
    C_old = deepcopy(centroid_values)

    # Find new centroids by calculating average values.
    for i in range(k):
        points = [X[j] for j in range(len(X)) if clusters[j] == i]
        centroid_values[i] = np.mean(points, axis=0)
    error = dist(centroid_values, C_old, None)
print (centroid_values)

# In k-means clustering, finding the centroids using the firefly centroid data
colors = ['r', 'g', 'b', 'y', 'c', 'm']
fig, ax = plt.subplots()
for i in range(k):
        points = np.array([X[j] for j in range(len(X)) if clusters[j] == i])
        ax.scatter(points[:, 0], points[:, 1], s=7, c=colors[i])
ax.scatter(centroid_values[:, 0], centroid_values[:, 1], marker='*', s=200, c='#050505')
plt.show()

输出

现在我们将以不同的方法实现萤火虫算法。

读取数据集

cols = [1,2]
data = data_frame[data_frame.columns[cols]]


len_data_points=data.shape[0]               #total no. of data poins
print("Number of data points : {}".format(len_data_points))


###...............max_list min_list................
max_list = []
min_list = []

v1_max = data['V1'].max()
v1_min = data['V1'].min()
v2_max = data['V2'].max()
v2_min = data['V2'].min()

max_list.append(v1_max)
max_list.append(v2_max)

min_list.append(v1_min)
min_list.append(v2_min)

print("v1 max : {}, v1 min : {}, v2 max : {}, v2 min : {}".format(v1_max,v1_min,v2_max,v2_min))

输出

点可视化

#####............data plotting..........###
v1_values = data['V1'].values
v2_values = data['V2'].values
X = np.array(list(zip(v1_values, v2_values)))

plt.scatter(v1_values, v2_values, c = 'black', s = 7)
plt.show()

输出

萤火虫算法

现在我们将以一种不同于我们之前使用的方法的方式来实现萤火虫算法。这种方法将具有

目标函数通过对每个聚类中数据点与其质心之间的平方距离进行求和来计算。它计算每个数据点与每个质心之间的距离，将每个数据点分配给最近的质心，并加上平方距离。
此方法根据萤火虫之间的距离刷新它们的位置，并在特定限制内用随机值修改它们。
这种方法采用基于质心位置变化的收敛标准来确定何时结束K-Means方法。它会一直迭代，直到质心的位置在迭代之间不再有显著差异。

##.......max gen..........##
maxgen = 10

##.......no of cluster...... ###
k = 3

###.......firefly creation...........##
firefly_swarm_size= 5
firefly_swarm_matrice = np.zeros((firefly_swarm_size,k,2), dtype=np.float64)


for i in range(firefly_swarm_size):
    centroid_x_location_list = np.random.randint(0, 200, size=k)
    centroid_y_location_list = np.random.randint(0, 200, size=k)
    Y = np.array(list(zip(centroid_x_location_list, centroid_y_location_list)), dtype=np.float32)
    firefly_swarm_matrice[i] = Y

print("Initial firefly")
print(firefly_swarm_matrice)

####.......plotting firefly..........#####
for i in range(firefly_swarm_size):
    plt.scatter(firefly_swarm_matrice[i][:,0],firefly_swarm_matrice[i][:,1], label='True Position',s=150)
    plt.show()

#####......objective function calculation...........####

J=np.zeros((firefly_swarm_size), dtype=np.float64)

def cal_objective(num):
    arr = np.ones((len_data_points, k), dtype=np.float64)
    for j in range(len_data_points):
        for i in range(k):
            try:
              dis = math.sqrt(((float(X[j][0] )- firefly_swarm_matrice[num][i][0]) ** 2) + ((float(X[j][1]) - firefly_swarm_matrice[num][i][1]) ** 2))
              arr[j][i] = dis
            except ValueError:
                continue


    min_dist_clus0 = np.ones((len_data_points), dtype=np.float64)  # stores the nearest cluster distance

    for j in range(len_data_points):
        min = 0
        val=0
        for i in range(k):
            if arr[j][i] < arr[j][min]:
                    val = arr[j][i]
                    min = i

        min_dist_clus0[j] = val



    sum=0
    for i in range(len_data_points):
        sum=sum+min_dist_clus0[i]

    J[num]=math.sqrt(sum)
    return J[num]

for i in range(firefly_swarm_size):
    J[i]=cal_objective(i)

print(J)

####.........parameter for firefly algorithm............#####

alpha = 0.5
beta = 0
beta_0 = 1
gamma = 1

####...........Best Firefly Calculation...........#######

obj=[]
for gen in range(maxgen):
    for i in range(5):
        scale = abs((max_list[0] - min_list[0])+(max_list[1]-max_list[1]))
        for j in range(5):
            if(J[i]>J[j]):
                r=0
                for l in range(k):
                    r=r+(firefly_swarm_matrice[i][l][0] - firefly_swarm_matrice[j][l][0]) + (firefly_swarm_matrice[i][l][1] - firefly_swarm_matrice[j][l][1])
                r = abs(r)
                r = math.sqrt(r)
                betamin=0.2
                gamma=1.0
                beta0 = 1.0
                beta = (beta0 - betamin) * \
                       math.exp(-gamma * math.pow(r, 2.0)) + betamin
                beta = beta_0 * (exp(-gamma) * (r** 2))
               # print(beta)
                for l in range(k):
                    r = random.uniform(0, 1)
                    tmpf = alpha * (r - 0.5) * scale
                    firefly_swarm_matrice[i][l][0] = firefly_swarm_matrice[i][l][0] * (1.0 - beta) +firefly_swarm_matrice[j][l][0] * beta + tmpf
                    firefly_swarm_matrice[i][l][1] = firefly_swarm_matrice[i][l][1] * (1.0 - beta) + firefly_swarm_matrice[j][l][1] * beta + tmpf

            temp = np.zeros((k, 2), dtype=np.float64)
            temp = firefly_swarm_matrice[i]
            for l in range(k):
                for s in range(2):
                    if temp[l][s] < min_list[s]:
                        temp[l][s] = random.uniform(min_list[s],max_list[s])

                    if temp[l][s] > max_list[s]:
                        temp[l][s] = random.uniform(min_list[s],max_list[s])


            firefly_swarm_matrice[i] = temp
            arr = np.zeros((len_data_points, k), dtype=np.float64)
            for n in range(len_data_points):
                for m in range(k):
                    try:

                        dis = math.sqrt(((float(X[n][0]) - firefly_swarm_matrice[i][m][0]) ** 2) + ((float(X[n][1]) - firefly_swarm_matrice[i][m][1]) ** 2))
                        arr[n][m] = dis
                    except ValueError:
                        continue
            min_dist_clus = np.zeros((len_data_points), dtype=np.float64)
            for n in range(len_data_points):
                min = 0
                val=0
                for m in range(k):
                    if arr[n][m] < arr[n][min]:
                            val = arr[n][m]
                            min= m

                min_dist_clus[n] = val

            sum = 0
            for n in range(len_data_points):
                sum = sum + min_dist_clus[n]
            J[i]= math.sqrt(sum)

    obj.append(np.amin(J))
    for i in range(1,5):
        if(J[i-1]<J[i]):
            best=i

print("best firefly ")
print(firefly_swarm_matrice[best])



######...........ploting best fF(firefly)........#######

plt.scatter(firefly_swarm_matrice[best][:,0],firefly_swarm_matrice[best][:,1])
plt.show()


#####......... Euclidean Distance Calculator..............#####
def dist(v1_max, v1_min, ax=1):
    return np.linalg.norm(v1_max - v1_min, axis=ax)


############################################################
######..............K Means.......................########
###########################################################


#####..............Centroid initialization...........#######

centroid_values = firefly_swarm_matrice[best]
print("intitial centroid")
print(centroid_values)
centroid_x_location_list=[]
centroid_y_location_list=[]

for i in range(k):
    centroid_x_location_list.append(centroid_values[i][0])
    centroid_y_location_list.append(centroid_values[i][1])



# #########..............Plotting along with the Centroids..................################
plt.scatter(v1_values, v2_values, c='#050505', s=7)
plt.scatter(centroid_x_location_list, centroid_y_location_list, marker='*', s=200, c='g')
plt.show()


#####....... To store the value of centroids when it updates...........########
C_old = np.zeros(centroid_values.shape)
# Cluster Lables(0, 1)
clusters = np.zeros(len(X))



#######......... Error func. - Distance between new centroids and old centroids.........#######
error = dist(centroid_values, C_old, None)

# Loop will run until the error becomes zero
k_obj=[]
x_axis=[]
x_val=[]
val=200
count=0
while error != 0:
    x_axis.append(count)
    x_val.append(val)
    count += 1
    val+=1

    arr = np.ones((len_data_points, k), dtype=np.float64)
    for j in range(len_data_points):
        for i in range(k):
            try:
                dis = math.sqrt(((float(X[j][0]) - centroid_values[i][0]) ** 2) + ((float(X[j][1]) - centroid_values[i][1]) ** 2))
                arr[j][i] = dis
            except ValueError:
                continue

    min_dist_clus0 = np.ones((len_data_points), dtype=np.float64)  # stores the nearest cluster distance

    for j in range(len_data_points):
        min = 0
        val = 0
        for i in range(k):
            if arr[j][i] < arr[j][min]:
                val = arr[j][i]
                min = i

        min_dist_clus0[j] = val

    sum = 0
    for i in range(len_data_points):
        sum = sum + min_dist_clus0[i]

    J= math.sqrt(sum)
    obj.append(J)
    # Assigning each value to its closest cluster
    for i in range(len(X)):
        distances = dist(X[i], centroid_values)
        cluster = np.argmin(distances)
        clusters[i] = cluster

    # Storing the old centroid values
    C_old = deepcopy(centroid_values)
    #print(C_old)
    # Finding the new centroids by taking the average value
    for i in range(k):
        points = [X[j] for j in range(len(X)) if clusters[j] == i]
        centroid_values[i] = np.mean(points, axis=0)
    error = dist(centroid_values, C_old, None)
print (centroid_values)

############............k-means plot.............##############
colors = ['r', 'g', 'b', 'y', 'c', 'm']
fig, ax = plt.subplots()
for i in range(k):
        points = np.array([X[j] for j in range(len(X)) if clusters[j] == i])
        ax.scatter(points[:, 0], points[:, 1], s=7, c=colors[i])
ax.scatter(centroid_values[:, 0], centroid_values[:, 1], marker='*', s=200, c='#050505')
plt.show()

#############.............ploting objective function............########
for i in range(len(obj)):
        if(i< maxgen):
            plt.plot(i,obj[i])
        else:
            plt.plot(i,obj[i])
plt.show()

fig1, ax1 = plt.subplots(1,dpi = 120)
fig1.suptitle('Costs per Iterations')
plt.xlabel("Iteration")
plt.ylabel("Cost")
plt.grid(b = True, which = 'major', ls = '-.', lw = 0.45)
ax1.plot(obj)
plt.show()

输出

萤火虫（质心）的初始位置是在数据集范围内随机生成的，该数据集是

初始质心

[[-22.15139455 -18.12579377]

[ 36.07550427 -18.77385426]

[ -6.25626392 27.89296228]]

然后，我们得到了最好的萤火虫，它是

最好的萤火虫

[[-22.15139455 -18.12579377]

[ 36.07550427 -18.77385426]

[ -6.25626392 27.89296228]]

之后，我们将其与K-Means聚类合并，形成一种聚类方法，我们得到最终位置，例如

[[ 9.4780459 10.686052 ]

[ 69.92418447 -10.11964119]

[ 40.68362784 59.71589274]]

最初，迭代成本急剧增加，之后随着找到合适的萤火虫而降低。因此，萤火虫技术被有效地应用于聚类问题，并且它与K-means的集成通过结合两种算法的优势来提高聚类性能。

萤火虫算法的应用

萤火虫算法已在众多领域找到了沃土，为各种问题景观中最有利的解决方案指明了道路。以下是萤火虫算法在实践中应用的一些例子：

它已被用于工程设计任务，包括结构优化、控制系统参数调整、天线设计以及可再生能源（如风力涡轮机和太阳能电池板）的最佳选址。优化复杂的设计参数有助于提高性能，降低成本，并提高效率。
它已被用于生物信息学任务，例如蛋白质形状预测、序列比对、基因表达分析和生物标志物发现。优化计算模型和算法有助于更好地理解生物过程，识别疾病生物标志物，并设计新颖的治疗干预措施。
它已被用于电力系统优化任务，包括经济调度、单元承诺和分布式发电单元的最佳选址。优化发电单元的调度和运行有助于降低运行成本，减少排放，并提高电力系统的稳定性和可靠性。
在无线传感器网络（WSNs）中，萤火虫算法已被应用于优化各种参数，包括网络覆盖、功耗、路由协议和节点部署。通过根据网络条件动态调整这些参数，它有助于提高WSN的效率、可靠性和寿命，使其适用于环境监测、监视和智能城市等应用。

萤火虫算法的未来展望

随着优化领域的不断发展，萤火虫算法正处于创新的前沿。新兴的研究方向正在寻求提高其性能、可扩展性和适应性，以应对日益复杂的优化任务。从与其他元启发式策略的混合，到与机器学习框架的集成，未来为扩展萤火虫算法的光辉遗产提供了无限的机会。

结论

萤火虫算法闪耀着灵感和创新的光辉。通过其对大自然发光奇观的优雅模仿，它为各种领域中最优解决方案开辟了道路。当我们凝视其概念和应用的闪耀之光时，我们会想起当自然与计算和谐地融合时所产生的深刻之美。确实，萤火虫算法体现了优化的艺术，为人类创造力的无限潜力带来了光明。

下一个主题Keras: Attention and Seq2Seq

萤火虫算法

原则

导入库

读取数据集

点可视化

萤火虫算法

读取数据集

点可视化

萤火虫算法

萤火虫算法的未来展望

结论

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

机器学习

监督式学习

分类

杂项

相关教程

面试题

萤火虫算法

原则

导入库

读取数据集

点可视化

萤火虫算法

读取数据集

点可视化

萤火虫算法

萤火虫算法的未来展望

结论

相关帖子

机器学习中的偏差与方差

什么是知识图谱

GPU 如何成为机器学习领域的游戏规则改变者？

分布式系统中的设计问题与挑战

LDA 在机器学习中的应用

机器学习中的外推

DC-GAN

2025 年机器学习最新研究课题

机器学习中的漂移

Keras：注意力与 Seq2Seq

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器