一、前言

        旅行商问题（Traveling Salesman Problem, TSP）是一个经典的组合优化问题，其目标是找到一条访问给定城市集合的最短路径，使得每个城市恰好被访问一次，并最终回到起点。TSP在物流、交通运输、电路设计等领域具有广泛的应用。由于TSP是一个NP-hard问题，传统的精确算法在求解大规模问题时面临计算复杂度过高的挑战。因此，研究高效的近似算法具有重要的理论意义和实际价值。

        本文旨在探讨利用连续Hopfield神经网络（Continuous Hopfield Neural Network, CHNN）解决TSP问题的优化算法。CHNN是一种具有并行计算能力的神经网络模型，能够有效地搜索问题的可行解空间。本文将详细介绍CHNN的原理、算法步骤，并结合MATLAB代码进行深入分析，旨在为读者提供一个全面理解和应用CHNN解决TSP问题的实践指南。

二、技术与原理简介

        1. 旅行商问题与Hopfield神经网络

        1.1 旅行商问题（TSP）

        TSP可以形式化地描述为：给定一个包含N个城市的集合，以及城市之间的距离矩阵D，其中D(i,j)表示城市i和城市j之间的距离。目标是找到一条访问所有城市且总距离最短的闭合路径。

        TSP的数学模型可以表示为：

        最小化：

        约束条件： 

        其中，𝑥𝑖𝑗 表示城市i和城市j是否在路径中相邻，如果相邻则为1，否则为0。第一个约束条件保证每个城市只能被访问一次，第二个约束条件保证每个城市只能被离开一次。

        1.2 Hopfield神经网络

        Hopfield神经网络是一种循环神经网络，由一组相互连接的神经元组成。每个神经元的状态可以是激活（1）或抑制（0）。神经元之间的连接权重决定了它们之间的相互作用强度。Hopfield神经网络通过能量函数来描述网络的状态，网络的目标是找到使能量函数最小的状态。

        Hopfield神经网络的能量函数可以表示为：

其中，𝑉𝑖 ​表示神经元i的状态，𝑇𝑖𝑗 ​表示神经元i和神经元j 之间的连接权重，𝐼𝑖 表示神经元i 的外部输入。

        1.3 连续Hopfield神经网络（CHNN）

        连续Hopfield神经网络是Hopfield神经网络的一种变体，其神经元状态可以取连续值，而不是离散的0或1。CHNN通常使用sigmoid函数作为激活函数，将神经元的输入映射到0到1之间的连续值。

        CHNN的动态方程可以表示为：

其中，𝑈𝑖 表示神经元i的输入，𝑉𝑖 ​表示神经元i的输出，𝑇𝑖𝑗 表示神经元i和神经元j 之间的连接权重，𝐼𝑖 表示神经元i 的外部输入，𝜏 表示时间常数，𝑔(𝑈𝑖) 表示激活函数。常用的激活函数是sigmoid函数：

其中，𝑈0 是一个参数，控制sigmoid函数的陡峭程度。

        2. 基于CHNN的TSP优化算法

        2.1 CHNN解决TSP问题的思路

        利用CHNN解决TSP问题的核心思想是将TSP的约束条件和目标函数转化为CHNN的能量函数。通过设计合适的连接权重和外部输入，使得CHNN的能量函数在对应于TSP最优解的状态下达到最小值。

        具体来说，可以将CHNN的神经元组织成一个N×N的矩阵，其中N是城市的数量。神经元V(i,j)表示城市i 在路径中的第j 个位置。如果V(i,j) 的值接近1，则表示城市i 在路径中的第j 个位置；如果V(i,j) 的值接近0，则表示城市i不在路径中的第j 个位置。

        2.2 能量函数设计

        为了保证CHNN能够找到TSP的可行解，需要设计合适的能量函数，使其能够反映TSP的约束条件。常用的能量函数包括以下几项：

        (1) 行约束项： 保证每个城市只能在路径中出现一次。

其中，A是一个常数，用于控制行约束项的权重。

        (2) 列约束项： 保证路径中的每个位置只能有一个城市。

其中，A是一个常数，用于控制列约束项的权重。

        (3) 距离约束项： 最小化路径的总距离。

其中，D是一个常数，用于控制距离约束项的权重，𝐷𝑖𝑘 表示城市i和城市k 之间的距离，𝑉𝑖,𝑁+1=𝑉𝑖,1。

        总的能量函数为：

        2.3 连接权重和外部输入设计

        根据能量函数，可以推导出CHNN的连接权重和外部输入。

        连接权重：

其中，𝛿𝑖𝑗 ​表示克罗内克函数，当i=j 时为1，否则为0。

        外部输入：

        2.4 算法步骤

基于CHNN的TSP优化算法的步骤如下：

  1. 初始化： 初始化CHNN的神经元状态U(i,j)和V(i,j)。通常将U(i,j)初始化为接近0的值，并加入小的随机扰动，以避免网络陷入局部最小值。
  2. 迭代： 根据CHNN的动态方程，迭代更新神经元状态U(i,j)和V(i,j)。
  3. 收敛判断： 判断网络是否收敛。常用的收敛判断条件是能量函数的变化小于一个阈值，或者达到最大迭代次数。
  4. 解码： 将CHNN的输出V(i,j)解码为TSP的路径。通常选择V(i,j)值最大的城市作为路径中的第j个位置。
  5. 路径有效性判断： 检查解码后的路径是否满足TSP的约束条件。如果路径无效，则重新初始化网络并重复迭代过程。

三、代码详解

        本文的 MATLAB 代码主要分为以下几个部分：

        1. 初始化

clear all
clc
global A D

load city_location

distance = dist(citys,citys');

N = size(citys,1);
A = 200;
D = 100;
U0 = 0.1;
step = 0.0001;
delta = 2 * rand(N,N) - 1;
U = U0 * log(N-1) + delta;
V = (1 + tansig(U/U0))/2;
iter_num = 10000;
E = zeros(1,iter_num);

说明：

  • 这段代码首先清空环境变量和命令行窗口，然后定义全局变量A和D，用于控制能量函数中行约束项和距离约束项的权重。接着，导入城市位置数据，并计算城市之间的距离矩阵。然后，初始化CHNN的参数，包括城市数量N，权重A和D，sigmoid函数的参数U0，迭代步长step，神经元状态U和V，最大迭代次数iter_num，以及能量函数E。

  • clear all：清除工作区的所有变量。

  • clc：清除命令行窗口的内容。

  • global A D：声明A和D为全局变量，可以在不同的函数中使用。

  • load city_location：加载包含城市坐标的数据，假设数据保存在名为city_location.mat的文件中，文件中包含一个名为citys的变量，citys是一个N×2的矩阵，每一行代表一个城市的坐标。

  • distance = dist(citys,citys')：计算城市之间的距离矩阵。dist是MATLAB的距离计算函数，citys'是citys的转置。

  • N = size(citys,1)：获取城市的数量。

  • A = 200; D = 100;：设置能量函数中约束项和距离项的权重。这些参数需要根据具体问题进行调整。

  • U0 = 0.1;：设置sigmoid函数的参数，控制sigmoid函数的陡峭程度。

  • step = 0.0001;：设置迭代步长，控制神经元状态更新的速度。

  • delta = 2 * rand(N,N) - 1;：生成一个N×N的随机矩阵，用于初始化神经元状态U，加入小的随机扰动，以避免网络陷入局部最小值。

  • U = U0 * log(N-1) + delta;：初始化神经元状态U。U0 * log(N-1)是一个经验值，用于设置U的初始值。

  • V = (1 + tansig(U/U0))/2;：计算神经元状态V，其中tansig是双曲正切函数，将U映射到-1到1之间，然后通过(1 + tansig(U/U0))/2将其映射到0到1之间。

  • iter_num = 10000;：设置最大迭代次数。

  • E = zeros(1,iter_num);：初始化能量函数E，用于记录每次迭代的能量函数值。

        2. 寻优迭代

for k = 1:iter_num  
    % 动态方程计算
    dU = diff_u(V,distance);
    % 输入神经元状态更新
    U = U + dU*step;
    % 输出神经元状态更新
    V = (1 + tansig(U/U0))/2;
    % 能量函数计算
    e = energy(V,distance);
    E(k) = e;  
end

说明：

  • 这段代码是CHNN的核心部分，它根据CHNN的动态方程，迭代更新神经元状态U和V，并计算能量函数。

  • for k = 1:iter_num：循环迭代，直到达到最大迭代次数。

  • dU = diff_u(V,distance);：计算神经元状态U的变化量，调用自定义函数diff_u。

  • U = U + dU*step;：更新神经元状态U，其中step是迭代步长。

  • V = (1 + tansig(U/U0))/2;：更新神经元状态V。

  • e = energy(V,distance);：计算能量函数，调用自定义函数energy。

  • E(k) = e;：记录每次迭代的能量函数值。

        3. 路径有效性判断

[rows,cols] = size(V);
V1 = zeros(rows,cols);
[V_max,V_ind] = max(V);
for j = 1:cols
    V1(V_ind(j),j) = 1;
end
C = sum(V1,1);
R = sum(V1,2);
flag = isequal(C,ones(1,N)) & isequal(R',ones(1,N));

说明：

  • 这段代码判断解码后的路径是否满足TSP的约束条件。

  • [rows,cols] = size(V);：获取神经元状态V的行数和列数。

  • V1 = zeros(rows,cols);：初始化二值矩阵V1。

  • [V_max,V_ind] = max(V);：找到每一列中V值最大的神经元的索引。

  • for j = 1:cols：循环遍历每一列。

  • V1(V_ind(j),j) = 1;：将每一列中V值最大的神经元对应的V1值设置为1，其余设置为0。

  • C = sum(V1,1);：计算V1的列和，表示每个位置上是否有且只有一个城市。

  • R = sum(V1,2);：计算V1的行和，表示每个城市是否只出现一次。

  • flag = isequal(C,ones(1,N)) & isequal(R',ones(1,N));：判断解码后的路径是否满足TSP的约束条件，即每个城市只能被访问一次，且路径中的每个位置只能有一个城市。

        4. 结果显示

if flag == 1
   % 计算初始路径长度
   sort_rand = randperm(N);
   citys_rand = citys(sort_rand,:);
   Length_init = dist(citys_rand(1,:),citys_rand(end,:)');
   for i = 2:size(citys_rand,1)
       Length_init = Length_init+dist(citys_rand(i-1,:),citys_rand(i,:)');
   end
   % 绘制初始路径
   figure(1)
   plot([citys_rand(:,1);citys_rand(1,1)],[citys_rand(:,2);citys_rand(1,2)],'o-')
   for i = 1:length(citys)
       text(citys(i,1),citys(i,2),['   ' num2str(i)])
   end
   text(citys_rand(1,1),citys_rand(1,2),['       起点' ])
   text(citys_rand(end,1),citys_rand(end,2),['       终点' ])
   title(['优化前路径(长度：' num2str(Length_init) ')'])
   axis([0 1 0 1])
   grid on
   xlabel('城市位置横坐标')
   ylabel('城市位置纵坐标')
   % 计算最优路径长度
   [V1_max,V1_ind] = max(V1);
   citys_end = citys(V1_ind,:);
   Length_end = dist(citys_end(1,:),citys_end(end,:)');
   for i = 2:size(citys_end,1)
       Length_end = Length_end+dist(citys_end(i-1,:),citys_end(i,:)');
   end
   disp('最优路径矩阵');V1
   % 绘制最优路径
   figure(2)
   plot([citys_end(:,1);citys_end(1,1)],...
       [citys_end(:,2);citys_end(1,2)],'o-')
   for i = 1:length(citys)
       text(citys(i,1),citys(i,2),['  ' num2str(i)])
   end
   text(citys_end(1,1),citys_end(1,2),['       起点' ])
   text(citys_end(end,1),citys_end(end,2),['       终点' ])
   title(['优化后路径(长度：' num2str(Length_end) ')'])
   axis([0 1 0 1])
   grid on
   xlabel('城市位置横坐标')
   ylabel('城市位置纵坐标')
   % 绘制能量函数变化曲线
   figure(3)
   plot(1:iter_num,E);
   ylim([0 2000])
   title(['能量函数变化曲线(最优能量：' num2str(E(end)) ')']);
   xlabel('迭代次数');
   ylabel('能量函数');
else
   disp('寻优路径无效');
end

说明：

  • 这段代码首先判断路径是否有效。如果路径有效，则计算初始路径长度和最优路径长度，并绘制初始路径、最优路径和能量函数变化曲线。

  • if flag == 1：判断路径是否有效。

  • sort_rand = randperm(N);：生成一个随机排列的城市索引。

  • citys_rand = citys(sort_rand,:)：根据随机索引排列城市坐标，用于计算初始路径长度。

  • Length_init = dist(citys_rand(1,:),citys_rand(end,:)');：计算初始路径长度，从第一个城市到最后一个城市。

  • for i = 2:size(citys_rand,1)：循环遍历所有城市。

  • Length_init = Length_init+dist(citys_rand(i-1,:),citys_rand(i,:)');：计算初始路径长度，从上一个城市到当前城市。

  • figure(1)：创建一个新的图形窗口。

  • plot([citys_rand(:,1);citys_rand(1,1)],[citys_rand(:,2);citys_rand(1,2)],'o-')：绘制初始路径。

  • for i = 1:length(citys)：循环遍历所有城市。

  • text(citys(i,1),citys(i,2),[' ' num2str(i)])：在每个城市的位置上添加城市编号。

  • text(citys_rand(1,1),citys_rand(1,2),[' 起点' ])：在起点位置上添加文本。

  • text(citys_rand(end,1),citys_rand(end,2),[' 终点' ])：在终点位置上添加文本。

  • title(['优化前路径(长度：' num2str(Length_init) ')'])：设置图形标题。

  • axis([0 1 0 1])：设置坐标轴范围。

  • grid on：显示网格线。

  • xlabel('城市位置横坐标')：设置x轴标签。

  • ylabel('城市位置纵坐标')：设置y轴标签。

  • [V1_max,V1_ind] = max(V1);：找到每一列中V1值最大的神经元的索引，用于解码最优路径。

  • citys_end = citys(V1_ind,:)：根据索引获取最优路径的城市坐标。

  • Length_end = dist(citys_end(1,:),citys_end(end,:)');：计算最优路径长度。

  • for i = 2:size(citys_end,1)：循环遍历所有城市。

  • Length_end = Length_end+dist(citys_end(i-1,:),citys_end(i,:)');：计算最优路径长度。

  • disp('最优路径矩阵');V1：显示最优路径矩阵。

  • figure(2)：创建一个新的图形窗口。

  • plot([citys_end(:,1);citys_end(1,1)],[citys_end(:,2);citys_end(1,2)],'o-')：绘制最优路径。

  • for i = 1:length(citys)：循环遍历所有城市。

  • text(citys(i,1),citys(i,2),[' ' num2str(i)])：在每个城市的位置上添加城市编号。

  • text(citys_end(1,1),citys_end(1,2),[' 起点' ])：在起点位置上添加文本。

  • text(citys_end(end,1),citys_end(end,2),[' 终点' ])：在终点位置上添加文本。

  • title(['优化后路径(长度：' num2str(Length_end) ')'])：设置图形标题。

  • axis([0 1 0 1])：设置坐标轴范围。

  • grid on：显示网格线。

  • xlabel('城市位置横坐标')：设置x轴标签。

  • ylabel('城市位置纵坐标')：设置y轴标签。

  • figure(3)：创建一个新的图形窗口。

  • plot(1:iter_num,E);：绘制能量函数变化曲线。

  • ylim([0 2000])：设置y轴范围。

  • title(['能量函数变化曲线(最优能量：' num2str(E(end)) ')'])：设置图形标题。

  • xlabel('迭代次数')：设置x轴标签。

  • ylabel('能量函数')：设置y轴标签。

  • else：如果路径无效。

  • disp('寻优路径无效');：显示“寻优路径无效”。

        5. 辅助函数

% % % % % 计算能量函数
function E=energy(V,d)
global A D
n=size(V,1);
sum_x=sumsqr(sum(V,2)-1);
sum_i=sumsqr(sum(V,1)-1);
V_temp=V(:,2:n);
V_temp=[V_temp V(:,1)];
sum_d=d*V_temp;
sum_d=sum(sum(V.*sum_d));
E=0.5*(A*sum_x+A*sum_i+D*sum_d);
end

% % % % 计算du
function du=diff_u(V,d)
global A D
n=size(V,1);
sum_x=repmat(sum(V,2)-1,1,n);
sum_i=repmat(sum(V,1)-1,n,1);
V_temp=V(:,2:n);
V_temp=[V_temp V(:,1)];
sum_d=d*V_temp;
du=-A*sum_x-A*sum_i-D*sum_d;
end

说明：

  • energy(V,d)函数： 计算能量函数。

    • global A D：声明A和D为全局变量。
    • n=size(V,1);：获取城市数量。
    • sum_x=sumsqr(sum(V,2)-1);：计算行约束项。
    • sum_i=sumsqr(sum(V,1)-1);：计算列约束项。
    • V_temp=V(:,2:n);：将V矩阵的列向左移动一位，用于计算距离约束项。
    • V_temp=[V_temp V(:,1)];：将V矩阵的第一列添加到V_temp的最后一列。
    • sum_d=d*V_temp;：计算距离约束项。
    • sum_d=sum(sum(V.*sum_d));：计算距离约束项。
    • E=0.5*(A*sum_x+A*sum_i+D*sum_d);：计算能量函数。

  • diff_u(V,d)函数： 计算神经元状态U的变化量。

    • global A D：声明A和D为全局变量。
    • n=size(V,1);：获取城市数量。
    • sum_x=repmat(sum(V,2)-1,1,n);：计算行约束项。
    • sum_i=repmat(sum(V,1)-1,n,1);：计算列约束项。
    • V_temp=V(:,2:n);：将V矩阵的列向左移动一位，用于计算距离约束项。
    • V_temp=[V_temp V(:,1)];：将V矩阵的第一列添加到V_temp的最后一列。
    • sum_d=d*V_temp;：计算距离约束项。
    • du=-A*sum_x-A*sum_i-D*sum_d;：计算神经元状态U的变化量。

        6. 完整代码

%% 连续Hopfield神经网络的优化—旅行商问题优化计算

%% 清空环境变量、定义全局变量
clear all
clc
global A D

%% 导入城市位置
load city_location

%% 计算相互城市间距离
distance = dist(citys,citys');

%% 初始化网络
N = size(citys,1);
A = 200;
D = 100;
U0 = 0.1;
step = 0.0001;
delta = 2 * rand(N,N) - 1;
U = U0 * log(N-1) + delta;
V = (1 + tansig(U/U0))/2;
iter_num = 10000;
E = zeros(1,iter_num);

%% 寻优迭代
for k = 1:iter_num  
    % 动态方程计算
    dU = diff_u(V,distance);
    % 输入神经元状态更新
    U = U + dU*step;
    % 输出神经元状态更新
    V = (1 + tansig(U/U0))/2;
    % 能量函数计算
    e = energy(V,distance);
    E(k) = e;  
end

 %% 判断路径有效性
[rows,cols] = size(V);
V1 = zeros(rows,cols);
[V_max,V_ind] = max(V);
for j = 1:cols
    V1(V_ind(j),j) = 1;
end
C = sum(V1,1);
R = sum(V1,2);
flag = isequal(C,ones(1,N)) & isequal(R',ones(1,N));

%% 结果显示
if flag == 1
   % 计算初始路径长度
   sort_rand = randperm(N);
   citys_rand = citys(sort_rand,:);
   Length_init = dist(citys_rand(1,:),citys_rand(end,:)');
   for i = 2:size(citys_rand,1)
       Length_init = Length_init+dist(citys_rand(i-1,:),citys_rand(i,:)');
   end
   % 绘制初始路径
   figure(1)
   plot([citys_rand(:,1);citys_rand(1,1)],[citys_rand(:,2);citys_rand(1,2)],'o-')
   for i = 1:length(citys)
       text(citys(i,1),citys(i,2),['   ' num2str(i)])
   end
   text(citys_rand(1,1),citys_rand(1,2),['       起点' ])
   text(citys_rand(end,1),citys_rand(end,2),['       终点' ])
   title(['优化前路径(长度：' num2str(Length_init) ')'])
   axis([0 1 0 1])
   grid on
   xlabel('城市位置横坐标')
   ylabel('城市位置纵坐标')
   % 计算最优路径长度
   [V1_max,V1_ind] = max(V1);
   citys_end = citys(V1_ind,:);
   Length_end = dist(citys_end(1,:),citys_end(end,:)');
   for i = 2:size(citys_end,1)
       Length_end = Length_end+dist(citys_end(i-1,:),citys_end(i,:)');
   end
   disp('最优路径矩阵');V1
   % 绘制最优路径
   figure(2)
   plot([citys_end(:,1);citys_end(1,1)],...
       [citys_end(:,2);citys_end(1,2)],'o-')
   for i = 1:length(citys)
       text(citys(i,1),citys(i,2),['  ' num2str(i)])
   end
   text(citys_end(1,1),citys_end(1,2),['       起点' ])
   text(citys_end(end,1),citys_end(end,2),['       终点' ])
   title(['优化后路径(长度：' num2str(Length_end) ')'])
   axis([0 1 0 1])
   grid on
   xlabel('城市位置横坐标')
   ylabel('城市位置纵坐标')
   % 绘制能量函数变化曲线
   figure(3)
   plot(1:iter_num,E);
   ylim([0 2000])
   title(['能量函数变化曲线(最优能量：' num2str(E(end)) ')']);
   xlabel('迭代次数');
   ylabel('能量函数');
else
   disp('寻优路径无效');
end

% % % % % 计算能量函数
function E=energy(V,d)
global A D
n=size(V,1);
sum_x=sumsqr(sum(V,2)-1);
sum_i=sumsqr(sum(V,1)-1);
V_temp=V(:,2:n);
V_temp=[V_temp V(:,1)];
sum_d=d*V_temp;
sum_d=sum(sum(V.*sum_d));
E=0.5*(A*sum_x+A*sum_i+D*sum_d);
end

% % % % 计算du
function du=diff_u(V,d)
global A D
n=size(V,1);
sum_x=repmat(sum(V,2)-1,1,n);
sum_i=repmat(sum(V,1)-1,n,1);
V_temp=V(:,2:n);
V_temp=[V_temp V(:,1)];
sum_d=d*V_temp;
du=-A*sum_x-A*sum_i-D*sum_d;
end

四、总结与思考

        本文详细介绍了基于连续Hopfield神经网络的旅行商问题优化算法。通过设计合适的能量函数和动态方程，CHNN能够有效地搜索TSP的可行解空间，并找到近似最优解。MATLAB代码的实现也为读者提供了一个实践指南。

        然而，CHNN在解决TSP问题时也存在一些局限性。例如，CHNN的参数需要仔细调整，才能获得较好的性能。此外，CHNN容易陷入局部最小值，导致无法找到全局最优解。      

CHNN的局限性与改进方向：

  • 参数敏感性： CHNN的性能高度依赖于参数A、D和U0的选择。不同的参数组合可能导致算法收敛到不同的局部最小值，甚至无法收敛。因此，需要进行大量的实验才能找到合适的参数。

【作者声明】

        本文内容基于作者对 MATLAB 连续Hopfield神经网络（CHNN）优化旅行商问题（TSP）实现过程的实验与总结，所有数据和代码均为原创。文章中的观点仅代表个人见解，供读者参考交流。若有任何问题或建议，欢迎在评论区留言讨论，共同促进技术进步。

 【关注我们】

        如果您对神经网络、群智能算法及人工智能技术感兴趣，请关注我们的公众号【灵犀拾荒者】，获取更多前沿技术文章、实战案例及技术分享！欢迎点赞、收藏并转发，与更多朋友一起探讨与交流！点赞+收藏+关注，后台留言关键词【免费资料】可获免费资源及相关数据集。

# 神经网络 # 算法 # 人工智能
Logo
腾讯云开发者社区

腾讯云面向开发者汇聚海量精品云计算使用和开发经验，营造开放的云计算技术生态圈。

更多推荐

终极指南：Flink SQL连接器版本管理从混乱到有序的升级之路

Apache Flink作为流处理领域的佼佼者，其SQL连接器的版本管理一直是开发者面临的核心挑战。本文将系统讲解Flink SQL连接器版本管理的最佳实践，帮助你轻松应对版本兼容性问题，实现从混乱到有序的升级之旅。## 连接器版本管理的常见痛点 😫在Flink应用开发中，连接器版本管理常常让开发者头疼不已。不同版本的连接器可能导致各种兼容性问题，例如API变更、功能差异甚至运行时错误。

avatar 腾讯云开发者社区

Elasticsearch复杂数据类型终极指南：从入门到精通

Elasticsearch作为功能强大的搜索引擎，支持多种复杂数据类型，让开发者能够灵活处理各种结构化和非结构化数据。本文将带你全面了解Elasticsearch中的复杂数据类型，从基础概念到实际应用，助你轻松掌握数据建模的核心技巧。## 内部对象：构建层级化数据结构在Elasticsearch中，对象类型（Object）是最基础的复杂数据类型之一，用于表示具有嵌套关系的数据。例如，我们可

avatar 腾讯云开发者社区

如何快速搭建Neon无服务器PostgreSQL：面向初学者的完整指南

Neon是一款革命性的无服务器PostgreSQL解决方案，它通过分离存储和计算层，实现了自动扩缩容、类代码式数据库分支以及零级扩展能力。本指南将帮助你从零开始搭建Neon开发环境，体验这款创新数据库的强大功能。## 准备工作：环境要求与依赖项在开始搭建Neon环境前，请确保你的系统满足以下要求：- Linux操作系统（推荐Ubuntu 20.04+或Debian 11+）- Git

avatar 腾讯云开发者社区