VS Code用AI写代码：Codeium插件

Codeium

Codeium是基于边缘计算的代码AI工具，提供超过70种编程语言的代码补全、对话、搜索等功能，相当霸道。

在插件栏搜索到Codeium之后，需要科学上网安装，安装完成后会提示注册。注册之后，会弹出一个Token页面，并提供一组密钥，然后回到VS Code，按下Ctrl+Shift+P，输入Codeium:Provi...，并将复制的密钥填入。当VS Code下面出现欢迎字样时，就说明可以正常使用了。

同时，点开左侧的{...}图标，也会看到CHAT和SEARCH中出现了内容，我们就可以跟他对话了。而且具体使用时，并不需要科学上网。

chat

Codeium是听得懂中文的，比如我问

有没有什么好的激光雷达检校算法？

他的回答如下，可以说十分靠谱了

有几种常用的激光雷达校准算法可以考虑使用：
点云匹配算法：这种算法使用激光雷达采集到的点云数据进行匹配，将多个扫描周期的点云数据对齐，从而校准激光雷达的姿态和内外参。
地面平面提取算法：这种算法通过分析激光雷达扫描到的点云数据，提取地面平面信息，并利用地面平面的几何特征进行激光雷达的姿态校准。
基于特征点的匹配算法：这种算法通过提取激光雷达扫描到的点云数据中的特征点（例如，角点、边缘点等），并利用这些特征点进行匹配，从而实现激光雷达的校准。
非线性优化算法：这种算法通过建立激光雷达的数学模型，并利用非线性优化方法（如Levenberg-Marquardt算法）来最小化模型与实际观测数据之间的差异，从而实现激光雷达的校准。
这些算法都有各自的优缺点，选择适合你特定需求和数据情况的算法是很重要的。同时，还可以考虑使用开源的激光雷达校准库，例如libpointmatcher和lidar-odom等，它们提供了一些常用的激光雷达校准算法的实现和工具。

代码生成

新建一个test.py文件，在注释中写下想要做的事情，然后Codeium会自动生成相关的代码，还挺像模像样的，唯一美中不足之处在于，他并不会自动导入相应的包。

# 导入科学计算包
import numpy as np

# 创建一个函数，可以根据字符串的长度返回随机字符串
def random_str(length):
    return ''.join(random.sample(string.ascii_letters + 
                                 string.digits, length))

# 写一个斐波那契数列函数
def fib(n):
    a, b = 0, 1
    for i in range(n):
        a, b = b, a+b
    return a
1
2
3
4
5
6
7
8
9
10
11
12
13
14
'
运行
运行

但接下来让他写一个递归的斐波那契数列，就稍微有些无语了，给了个内存爆炸写法

# 写一个递归斐波那契数列函数
def fib2(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fib2(n-1) + fib2(n-2)
1
2
3
4
5
6
7
8
'
运行
运行

而且复杂的代码任务可能还是比较拉跨的

# 写一个卷积神经网络
class CNN:
    def __init__(self):
        pass

# 创建粒子群算法
class ParticleSwarm:
    def __init__(self):
        pass
1
2
3
4
5
6
7
8
9
'
运行
运行

但是，如果用chat来生成，那么还是有点意思滴

最终代码如下

import random

class Particle:
    def __init__(self, position, velocity):
        self.position = position
        self.velocity = velocity
        self.best_position = position
        self.best_fitness = float('inf')

def fitness_function(position):
    # 定义适应度函数，根据具体问题进行定义
    return sum(position)  # 以求和为例

def particle_swarm_optimization(population_size, num_dimensions, max_iterations):
    # 初始化粒子群
    swarm = []
    for _ in range(population_size):
        position = [random.uniform(-5, 5) for _ in range(num_dimensions)]
        velocity = [random.uniform(-1, 1) for _ in range(num_dimensions)]
        swarm.append(Particle(position, velocity))
    
    # 寻找全局最优解
    global_best_position = None
    global_best_fitness = float('inf')
    
    for _ in range(max_iterations):
        for particle in swarm:
            # 更新粒子速度
            for i in range(num_dimensions):
                inertia = 0.5  # 惯性权重
                cognitive_weight = 1.0  # 学习因子（针对个体最优）
                social_weight = 1.0  # 学习因子（针对全局最优）

                r1 = random.random()
                r2 = random.random()

                cognitive_component = cognitive_weight * r1 * (particle.best_position[i] - particle.position[i])
                social_component = social_weight * r2 * (global_best_position[i] - particle.position[i])

                particle.velocity[i] = inertia * particle.velocity[i] + cognitive_component + social_component

            # 更新粒子位置
            for i in range(num_dimensions):
                particle.position[i] += particle.velocity[i]

            # 计算适应度
            fitness = fitness_function(particle.position)

            # 更新个体最优位置和全局最优位置
            if fitness < particle.best_fitness:
                particle.best_position = particle.position
                particle.best_fitness = fitness

            if fitness < global_best_fitness:
                global_best_position = particle.position
                global_best_fitness = fitness
    
    return global_best_position, global_best_fitness

# 示例用法
population_size = 20
num_dimensions = 2
max_iterations = 100

best_position, best_fitness = particle_swarm_optimization(population_size, num_dimensions, max_iterations)
print("Best Position:", best_position)
print("Best Fitness:", best_fitness)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

当然，在实际使用中，不幸报错了。