给我用python写一下nearest neighbor算法

好的，以下是用 Python 实现 nearest neighbor 算法的代码：

import numpy as np

def nearest_neighbor(train_data, test_data):
    """
    计算测试数据与训练数据集中最近邻的距离，并返回最近邻的标签值
    :param train_data: 训练数据集，二维数组，每一行代表一个样本，每一列代表一个特征
    :param test_data: 测试数据，一维数组，代表一个样本的特征
    :return: 最近邻的标签值
    """
    # 计算训练数据集中每个样本与测试数据之间的距离
    dists = np.sum((train_data - test_data) ** 2, axis=1)
    # 取距离最近的样本的索引
    min_index = np.argmin(dists)
    # 返回最近邻的标签值
    return train_data[min_index][-1]

其中，`train_data` 为训练数据集，是一个二维数组，每一行代表一个样本，每一列代表一个特征；`test_data` 为测试数据，是一个一维数组，代表一个样本的特征。函数会计算测试数据与训练数据集中每个样本之间的距离，然后返回距离最近的样本的标签值。

相关问题

使用python写一段smote算法

Sure! 下面是一个基本的SMOTE算法的Python代码：

import numpy as np
from sklearn.neighbors import NearestNeighbors

def smote(X, y, k=5, ratio=1):
    """
    Generate synthetic samples using SMOTE algorithm.
    :param X: 2D numpy array of shape (n_samples, n_features)
    :param y: 1D numpy array of shape (n_samples,), the corresponding class labels
    :param k: int, the number of nearest neighbors to use when selecting similar samples
    :param ratio: float, the amount of SMOTE to apply (e.g. 0.5 means increase the minority class by 50%)
    :return: 2D numpy array of shape (n_samples', n_features), the synthetic samples
    """
    # Get the unique class labels and the number of samples in each class
    classes, counts = np.unique(y, return_counts=True)
    # Find the minority class
    minority_class = classes[np.argmin(counts)]
    # Find the indices of the minority class samples
    minority_indices = np.where(y == minority_class)[0]
    # Calculate the number of synthetic samples to generate
    n_to_generate = int(ratio * counts[np.argmin(counts)])
    # Initialize an empty array to hold the synthetic samples
    synthetic_samples = np.zeros((n_to_generate, X.shape[1]))
    # Fit a k-NN model to the original data
    knn = NearestNeighbors(n_neighbors=k).fit(X)
    # Generate the synthetic samples
    for i in range(n_to_generate):
        # Choose a random minority class sample
        idx = np.random.choice(minority_indices)
        # Find its k nearest neighbors in the original data
        nn = knn.kneighbors(X[idx].reshape(1, -1), return_distance=False)[0]
        # Choose one of the neighbors randomly
        nn_idx = np.random.choice(nn)
        # Calculate the difference between the minority sample and the neighbor
        diff = X[nn_idx] - X[idx]
        # Multiply this difference by a random value between 0 and 1
        gap = np.random.rand() * diff
        # Add this gap to the minority sample to create the synthetic sample
        synthetic_samples[i, :] = X[idx] + gap
    # Combine the original data with the synthetic data
    new_X = np.vstack((X, synthetic_samples))
    new_y = np.hstack((y, np.array([minority_class] * n_to_generate)))
    # Shuffle the data and return it
    idx = np.random.permutation(new_X.shape[0])
    return new_X[idx], new_y[idx]

使用方法：

# 载入数据
X, y = load_data()
# 使用 SMOTE 生成新的样本
X_smote, y_smote = smote(X, y, k=5, ratio=0.5)

根据tsplib数据集，用N e a r e s t Neighbor算法求解的python实例

以下是使用Nearest Neighbor算法求解tsplib数据集的Python代码示例：

import numpy as np
import math
import matplotlib.pyplot as plt

# 读入数据
def read_input(input_file):
    with open(input_file) as f:
        lines = f.readlines()[6:-1]  # 忽略头部信息和尾部信息
        nodes = []
        for line in lines:
            node_id, x, y = line.strip().split()
            nodes.append((int(node_id), float(x), float(y)))
        return nodes

# 计算两个节点之间的距离
def distance(node1, node2):
    x1, y1 = node1[1], node1[2]
    x2, y2 = node2[1], node2[2]
    return math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)

# Nearest Neighbor算法
def nearest_neighbor(nodes, start_node):
    remaining_nodes = set(nodes)
    remaining_nodes.remove(start_node)
    current_node = start_node
    tour = [start_node]
    while remaining_nodes:
        nearest_node = min(remaining_nodes, key=lambda x: distance(current_node, x))
        remaining_nodes.remove(nearest_node)
        tour.append(nearest_node)
        current_node = nearest_node
    return tour

# 主函数
def main():
    input_file = 'dataset.tsp'
    nodes = read_input(input_file)
    start_node = nodes[0]
    tour = nearest_neighbor(nodes, start_node)
    tour.append(start_node)  # 将起点添加到路径的末尾，形成闭合回路
    print('Tour cost:', sum(distance(tour[i], tour[i+1]) for i in range(len(tour)-1)))
    # 绘制图形
    x = [node[1] for node in tour]
    y = [node[2] for node in tour]
    plt.plot(x, y, 'o-')
    plt.show()

if __name__ == '__main__':
    main()

其中，`read_input`函数用于读入tsplib数据集，`distance`函数用于计算两个节点之间的距离，`nearest_neighbor`函数是Nearest Neighbor算法的实现，`main`函数调用以上函数并绘制路径图形。请将`dataset.tsp`替换为你要解决的数据集。