高级搜索之遗传算法（Genetic Algorithm,GA）

已于 2024-07-01 09:55:43 修改
阅读量870 收藏 30
点赞数 18
文章标签： 人工智能 算法 python
于 2024-07-01 09:48:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74766888/article/details/137153916
版权

一、核心思想

  • 个体（individual）：候选解
  • 种群（population）：候选解的集合，表示问题的解空间
  • 染色体（chromosome）：候选解的编码方式，表示个体的特征，是一种象征着基因的数据结构
  • 精英（elite）：适应度最好的个体
  • 适应度（fitness）：目标函数值
  • 环境容纳量（capacity）：种群的最大个体数量
  • 优化准则（optimization）：指导算法何时停止搜索（迭代次数）
  • 自然选择（selection）：根据个体的适应度选择优秀个体作为父代，用于产生子代形成新的个体
  • 交叉重组（crossover）：提取两个父体的染色体片段进行交换组合，从而生成新的染色体来形成子代个体
  • 基因变异（mutation）：对个体染色体中的某些基因进行随机改变或替换来实现

二、基本操作

1. 选择策略

  • 轮盘赌选择（Roulette Wheel）：轮盘的每个扇区代表不同的个体，每个扇区的张角与个体的适应度成比例，然后产生一个随机数，落入哪个扇区就选择相应的个体
  • 锦标赛选择（Tournament）：根据设定的参赛人员数量随机选取种群中若干个个体，选择其中适应度最大的个体
  • 最佳个体选择（elitist）：把群体中适应度最高的个体不进行交叉而直接复制到下一代

2. 交叉重组策略

  • 单点交叉（Single-Point Crossover）：随机设定一个交叉点，该点前/后的部分基因结构进行互换，以此生成两个新的个体
  • 均匀交叉（Uniform Crossover）：按照50%的概率对父代每一个基因位点进行交换，从而产生新的子代个体
  • 部分匹配交叉（Partial-mapped Crossover,PMX）：具体操作可见七的代码


遗传算法：交叉操作 partially mapped crossover operator(PMX)_pmx交叉-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/qq_32182397/article/details/106031512

3. 变异策略（随机，随机，还是随机）

  • 位点变异（Bit-flip）：随机选择一个或多个基因位点，并以一定的变异概率改变这些基因位点上的基因值
  • 逆转变异（Inversion）：随机选择两个基因位点，然后将这两个基因位点之间的基因逆序排列
  • 插入变异（Insertion）：随机选择一个基因位点插入到另一个随机选择的位置中
  • 互换变异（Swap）：随机选取两个基因位点进行互换
  • 移动变异（Shift）：随机选取一个基因位点向左或向右移动一个随机位数

三、算法流程

  1. 初始化：
    1. 初始种群
    2. 最大迭代次数
  2. 迭代：是否到达最大迭代次数，当前种群中是否有个体是最优解
    1. 根据选择策略，选出两个具有优秀基因的个体
    2. 将上一步选择的两个个体交叉重组，获得两个新个体加入种群
    3. 如果达到环境容纳量，则淘汰原种群中两个具有劣质基因的个体
    4. 按照变异概率随机对种群中每个个体基因突变
  3. 输出最优解

四、影响性能的因素

1. 最大迭代次数

        其他因素不变的情况下，最大迭代次数越多，结果的适应度越好，平均GA时间越长。

2. 最大种群数量

        其他因素不变的情况下，最大种群数量越多，结果的适应度先上升后下降。这是因为我们此时在锦标赛选择策略种设置的“参赛人员数量”相对于最大种群数量偏小，所以最后选择出来的优秀亲本的实际上可能不优秀，因此每次遗传得到的子代也不够好

        因此我们我们应该根据最大种群数量来确定竞标赛选择的参赛人员数量，可以设置参赛人员数量是最大种群数量的80%

3. 初始变异概率

        其他因素不变的情况下，初始变异概率从小到大，结果的适应度先是很低，然后上升，最后下降。这是因为如果变异概率太大，可能会导致种群里的精英也发生了变异，而精英是最接近最优解的，不应该发生变异；如果变异概率太低，会导致缺乏多样性、解空间覆盖不足、演化速度变慢等问题

五、评测

1.  特点

  • 没有太多的数学要求：直接对数据结构对象（数串）操作
  • 利用大量随机技术进行搜索：提升找到全局最优解的概率
  • 并行化：对种群中每一个个体的操作是相同的，可以同时进行
  • 评估简单： 仅用适应度函数值来评估个体

2.  性质

  • 良好的鲁棒性：遗传算法对问题的参数设置和初始种群的选择相对不敏感
  • 良好的收敛性：随着算法的迭代，种群的平均适应度也逐渐增加，直至达到一定的稳定状态
  • 完备性：理论上遗传算法是完备的，然而在实践中，由于搜索空间的复杂性和计算资源的限制，不一定能够找到全局最优解，但遗传算法通常能够找到接近全局最优解的局部最优解

六、八皇后问题

问题描述：在一个 8x8 的国际象棋棋盘上，摆放八个皇后，使得任意两个皇后都不能在同一行、同一列或同一斜线上共存

import random

# 获取两个随机点
def random2point(size):
    point1 = random.randint(1, size - 1)
    point2 = random.randint(1, size - 1)
    while point1 == point2:
        point2 = random.randint(1, size - 1)
    return min(point1, point2), max(point1, point2)     # 小的在前，大的在后

# 初始种群生成函数
def initial(amount,size):
    population = []
    while len(population) != amount:        # 一共生成amount个体
        individual = random.sample(range(size),size)
        individual = ''.join([str(item) for item in individual])
        if individual not in population:    # 确保个体不同
            population.append(individual)
    return population

# 适应度函数：计算冲突数
def fitness(individual):
    conflicts = 0
    size = len(individual)
    for i in range(0,size-1):
        for j in range(i+1,size):
            diag1 = (int(individual[i]) - i) == (int(individual[j]) - j)
            diag2 = (int(individual[i]) + i) == (int(individual[j]) + j)
            if individual[i] == individual[j] or diag1 or diag2:
                conflicts += 1
    return conflicts   

# 选择策略：锦标赛，随机选10个个体“竞赛”，选出冲突数最小的个体
def tournament_select(population):
    tournament1 = random.sample(population,10)  
    parent1 = min(tournament1, key=fitness)
    tournament2 = random.sample(population,10)
    if parent1 in tournament2:
        tournament2.remove(parent1)
    parent2 = min(tournament2, key=fitness)
    return parent1,parent2

# 交叉重组策略：PMX
def crossover(parent1,parent2):
    size = len(parent1)
    child1,child2= [None] * size,[None] * size
    mapping1,mapping2= {},{}
    # 选择交叉点
    point1, point2 = random2point(size)
    # 复制交叉段
    child1[point1:point2 + 1] = parent2[point1:point2 + 1]
    child2[point1:point2 + 1] = parent1[point1:point2 + 1]
    # 创建映射字典
    mapping1 = {parent2[i]: parent1[i] for i in range(point1, point2 + 1)}
    mapping2 = {parent1[i]: parent2[i] for i in range(point1, point2 + 1)}
    # 填充子代
    for i in range(size):
        if i < point1 or i > point2:
            element1 = parent1[i]
            while element1 in mapping1:
                element1 = mapping1[element1]
            child1[i] = element1

            element2 = parent2[i]
            while element2 in mapping2:
                element2 = mapping2[element2]
            child2[i] = element2
    return ''.join(child1), ''.join(child2)

# 基因突变策略：逆转变异
def mutation(individual):
    size = len(individual)
    point1, point2 = random2point(size)
    mutate_individual = individual[:point1] + individual[point1:point2+1][::-1] + individual[point2+1:]
    return mutate_individual

#遗传算法
def genetic(population):
    size = len(population)
    max_iteration = 1000
    iteration = 0
    mutation_rate = 0.05    # 变异概率

    while iteration != max_iteration:
        # 按照适应度排序种群
        population = sorted(population,key=fitness)
        # 算法终止：找到最优解
        for item in population:
            if fitness(item) == 0:
                return item
        # 挑选出两个具有优秀基因的个体去交配
        parent1,parent2 = tournament_select(population)
        # 得到两个孩子
        child1,child2 = crossover(parent1,parent2)
        # 替换原有种群具有劣势基因的个体
        population[size-1],population[size-2] = child1,child2
        # 种群每个个体都有可能基因突变
        for i in range(len(population)):
            if random.random() < mutation_rate:
                population[i] = mutation(population[i])
        # 迭代次数+1
        iteration += 1
    return None

population = initial(20,8)
result = genetic(population)
if result != None:
    print('succss:',result)
else:
    print('fail')

七、TSP旅行商问题

（详细可以跳到我的另一篇文章看，这里只展示代码）

问题描述：假设有一个旅行商需要访问n个城市，并且每对城市之间都有距离或者成本，旅行商需要找到一条最短路径，使得他只访问每个城市一次，并且最终回到出发城市，使得总的访问成本最小。

import os
import random
import math
import time
import matplotlib.pyplot as plt
class GeneticAlgTSP():
    # 初始化种群函数：amount是种群中个体个数，length是个体的染色体长度，且保留精英
    def initial_population(self,amount,length,elite):
        population = []
        # 要求对精英进行一次变异，防止精英占据绝对优势陷入局部最优解
        if elite != []:
            elite = self.mutate(elite)                         
            population.append(elite)
        while len(population) != amount:       
            individual = random.sample(range(length),length)
            # 每个个体的染色体要求不同
            if individual not in population:                   
                population.append(individual)
        return population
    
    # 初始化城市坐标函数：filename是读取的tsp格式文件名称
    def initial_cities(self,filename):
        cities = []
        # 得到文件路径
        diskpath = os.path.dirname(__file__)
        filepath = diskpath + '//TSP数据库//'+ filename
        # 读取文件
        with open(filepath, 'r') as file:
            lines = file.readlines()                        # 读取全部行
            for line in lines:
                if line.startswith("EOF"):                  # 如果是END OF FILE则退出循环
                    break
                data = line.split()                         # 每行按照空格分开数据
                if len(data) == 3 and data[0].isdigit():    # 需要的只是坐标数据，其他忽略
                    x = float(data[1])
                    y = float(data[2])
                    cities.append((x,y))                    # 将坐标(x,y)加入城市坐标列表
        return cities
    
    # 初始化类函数：种群列表和城市坐标列表
    def __init__(self,filename,elite):
        self.cities = self.initial_cities(filename)
        self.population = self.initial_population(10,len(self.cities),elite)

    # 随机生成两点函数：限定在size范围内
    def random2point(self,size):
        point1 = random.randint(1, size - 1)
        point2 = random.randint(1, size - 1)
        while point1 == point2:
            point2 = random.randint(1, size - 1)
        return min(point1, point2), max(point1, point2)     # 小的在前大的在后
    
    # 欧几里得距离函数：根据坐标计算两个城市之间的欧几里得距离
    def euclidean_distance(self,city1,city2):
        x1, y1 = city1
        x2, y2 = city2
        distance = math.sqrt((x2 - x1)**2 + (y2 - y1)**2)
        return distance
    
    # 适应度函数：计算闭合旅行路径的总长度
    def fitness(self,individual):
        amount = len(individual)
        distance = 0
        for i in range(amount):
            city1 = self.cities[individual[i]]
            city2 = self.cities[individual[(i + 1) % amount]]       # 取模可以确保得到闭合环路
            distance += self.euclidean_distance(city1,city2)
        return int(distance)                                        # 取整

    # 选择策略：锦标赛->随机选8个个体竞赛，选出适应度最好的个体
    def tournament_select(self,population):
        group1 = random.sample(population,8)  
        parent1 = min(group1, key=self.fitness)
        group2 = random.sample(population,8)
        if parent1 in group2:
            group2.remove(parent1)                 # 确保选择的两个个体不重复
        parent2 = min(group2, key=self.fitness)
        return parent1,parent2

    # 交叉重组策略：部分映射交叉PMX
    def crossover(self,parent1,parent2):
        size = len(parent1)
        child1,child2= [None] * size,[None] * size                        
        # 选择交叉点
        point1, point2 = self.random2point(size)
        # 复制交叉段
        child1[point1:point2 + 1] = parent2[point1:point2 + 1]
        child2[point1:point2 + 1] = parent1[point1:point2 + 1]
        # 创建映射字典
        mapping1 = {parent2[i]: parent1[i] for i in range(point1, point2 + 1)}
        mapping2 = {parent1[i]: parent2[i] for i in range(point1, point2 + 1)}
        # 填充非交叉段
        for i in range(size):
            if i < point1 or i > point2:
                element1 = parent1[i]
                while element1 in mapping1:
                    element1 = mapping1[element1]
                child1[i] = element1

                element2 = parent2[i]
                while element2 in mapping2:
                    element2 = mapping2[element2]
                child2[i] = element2
        return child1,child2

    # 基因突变策略：逆转变异
    def mutate(self,individual):
        size = len(individual)
        point1, point2 = self.random2point(size)
        mutate_individual = individual[:point1] + individual[point1:point2+1][::-1] + individual[point2+1:]
        return mutate_individual
    
    # 遗传算法
    def GA(self,max_iterations,max_populations,mutate_rate):
        iteration = 0
        while iteration != max_iterations:
            size = len(self.population)
            # 挑选出两个具有优秀基因的个体去交配
            parent1,parent2 = self.tournament_select(self.population)
            # 得到两个孩子
            child1,child2 = self.crossover(parent1,parent2)
            # 如果数量已经到达环境容纳量，则替换原有种群具有劣势基因的个体，否则直接加入种群
            self.population = sorted(self.population,key=self.fitness)  
            if size == max_populations:
                self.population[size-1],self.population[size-2] = child1,child2
            elif size <= 18:
                self.population.append(child1)
                self.population.append(child2)
            # 种群每个个体都有可能基因突变
            self.population = sorted(self.population,key=self.fitness)  
            rate = mutate_rate      # 初始变异概率相同                                         
            for i in range(len(self.population)):
                if random.random() < mutate_rate:
                    self.population[i] = self.mutate(self.population[i])
                rate += 0.01        # 适应度值越高，基因越劣质，变异概率越高
            iteration += 1
        self.population = sorted(self.population,key=self.fitness)
        return self.fitness(self.population[0]),self.population[0]

# 可视化路径函数
def plot_path(points,path):
    # 擦除掉原先的图
    plt.cla()
    # 提取点的坐标
    x_values = [point[0] for point in points]
    y_values = [point[1] for point in points]
    # 绘制点
    plt.scatter(x_values, y_values, color='blue', s=15)
    # 绘制路径
    for i in range(len(path) - 1):
        point1 = points[path[i]]
        point2 = points[path[i + 1]]
        plt.plot([point1[0], point2[0]], [point1[1], point2[1]], color='red', linewidth=0.1)
    # 连接最后一个点和第一个点，形成闭合路径
    point1 = points[path[-1]]
    point2 = points[path[0]]
    plt.plot([point1[0], point2[0]], [point1[1], point2[1]], color='red', linewidth=0.1)
    # 设置标题和标签
    plt.title('Visualization of Path')
    plt.xlabel('X')
    plt.ylabel('Y')
    plt.legend(['points', 'path'], loc='upper right')
    # 重新画图
    plt.draw()
    # 控制更新频率
    plt.pause(0.2)
    

# 进化算法
def EA(filename):
    max_iterations = 10000          # 最大迭代次数
    max_generations = 100           # 最大进化次数
    max_populations = 20            # 最大种群数量
    max_blocktime = 15              # 最大阻塞次数
    mutate_rate = 0.08              # 初始变异概率

    generation = 0
    best_distance = float('inf')
    best_path = []

    blocktime = 0
    while generation != max_generations:
        solve = GeneticAlgTSP(filename,best_path)
        distance,path = solve.GA(max_iterations,max_populations,mutate_rate)
        # 进化的本质:找到比上一代精英还要好的个体
        if distance < best_distance or blocktime == max_blocktime:
            if distance < best_distance:
                best_distance = distance
                best_path = path
            print("第",generation+1,"次路径长度:",best_distance)
            plot_path(solve.cities,best_path)
            blocktime = 0
            generation += 1
            continue
        blocktime += 1
    return best_distance,best_path

#filename = 'wi29'
#filename = 'dj38'
#filename = 'qa194'
filename = 'rw1621'
#filename = 'ja9847'
filename = '//' + filename + '.tsp'
best_distance,best_path = EA(filename)
print("最佳路线:",best_path)
print("最短距离",best_distance)

达斯_0227
关注
  • 18
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
遗传算法详解（GA）（个人觉得很形象，很适合初学者）
boat_lee的博客
04-18 56万+
本文是去年课题组周报中的一个专题讲解，详细讲了GA，由于是周报，所以十分详细。文章综合参考了一些互联网资料。发博客以备忘！
GA_geneticalgorithm_遗传算法GA_
10-04
遗传算法（Genetic Algorithm, GA）是一种模拟生物进化过程的优化方法，由John Henry Holland在20世纪60年代提出。这种算法广泛应用于解决复杂的、多目标的优化问题，如机器学习模型的参数搜索、组合优化问题等。...
遗传算法（Genetic Algorithm）详解与实现
热门推荐
盼小辉丶的博客
12-25 13万+
遗传算法（Genetic Algorithm, GA）是受自然进化原理启发的一系列搜索算法。通过模仿自然选择和繁殖的过程，遗传算法可以为涉及搜索、优化和学习的各种问题提供高质量的解决方案。同时，它们类似于自然进化，因此遗传算法可以克服传统搜索和优化算法遇到的一些障碍，尤其是对于具有大量参数和复杂数学表示形式的问题。
什么是遗传算法（Genetic Algorithm，简称 GA）？
Web3 & Basketball
08-24 5638
遗传算法（Genetic Algorithm，简称 GA）是一种基于自然选择和遗传学原理的优化搜索方法。它起源于 20 世纪 60 年代，由美国计算机科学家 John H. Holland 提出。遗传算法是通过模拟自然界生物进化过程中的达尔文自然选择和遗传遗传规律，对问题的解进行迭代更新，从而搜索最优解或近似最优解的一种算法。将问题映射成一个数学问题，即建立数学模型。初始化一个种群，包含多个个体，每个个体表示一个解。
遗传算法（Genetic Algorithm，GA）
weixin_46838605的博客
03-04 1万+
这是一篇关于遗传算法的总结博客，包括算法思想，算法步骤，一个简单应用例子（python实现），求解复杂二元函数的最值（Python实现），算法进阶（持续更新ing）。
GA.rar_GA_genetic algorithm_遗传算法
09-23
遗传算法（Genetic Algorithm，简称GA）是一种模拟自然选择和遗传机制的全局优化方法，源于进化计算理论，是人工智能领域的重要研究方向之一。GA通过模拟生物进化过程中的适者生存、遗传和突变等规则来寻找问题的最...
智能算法之遗传算法_geneticalgorithm_GA优化_遗传算法_相对论_智能算法_
09-30
遗传算法（Genetic Algorithm，简称GA）是一种模拟自然界生物进化过程的优化算法，由美国科学家John Holland在20世纪70年代提出。这种算法借鉴了生物界的自然选择、遗传和突变等机制，用于解决复杂问题的全局优化，...
GA算法_geneticalgorithm_遗传算法_
10-01
遗传算法（Genetic Algorithm，简称GA）是一种模拟自然选择和遗传机制的优化方法，由John Henry Holland在20世纪60年代提出。这种算法广泛应用于解决复杂问题的全局优化，如函数优化、组合优化、机器学习等领域。在...
遗传算法.zip_genetic algorithm_遗传算法
07-15
遗传算法（Genetic Algorithm，简称GA）是一种借鉴生物进化理论，特别是自然界中物种优胜劣汰、遗传变异机制的优化算法。它在寻找问题的全局最优解时展现出强大的能力，尤其适用于解决复杂、多模态的优化问题。下面...
2024Datawhale AI夏令营---基于术语词典干预的机器翻译挑战赛--学习笔记
weixin_61573157的博客
07-15 1056
机器翻译（Machine Translation，简称MT）是自然语言处理领域的一个重要分支，其目标是将一种语言的文本自动转换为另一种语言的文本。机器翻译的发展可以追溯到20世纪50年代，经历了从基于规则的方法、统计方法到深度学习方法的演变过程。当前，机器翻译正朝着更加智能化和个性化方向发展。一方面，结合上下文理解、情感分析等技术，提高翻译的准确性和自然度；另一方面，通过用户反馈和个性化学习，提供更加符合用户需求的翻译服务。同时，跨语言信息检索、多模态翻译等新兴领域也正在成为研究热点。
基于语音识别的会议记录系统
最新发布
qq_51688022的博客
07-18 723
本文简要介绍了本科毕设“基于语音识别的会议记录系统”的开发思路与成果
标题：生成式AI的未来：对话系统还是自主代理？
chezabo6116的博客
07-18 304
生成式AI技术通过学习大量数据，能够生成新的文本、图像、音乐等内容。在对话系统（Chat）领域，生成式AI主要应用于聊天机器人、智能客服和虚拟助手等，通过自然语言处理（NLP）技术与用户进行交互。而在自主代理（Agent）领域，生成式AI则更多地应用于自动化任务执行、决策支持和个性化推荐等，强调自主性和智能化。对话系统（Chat）主要技术：自然语言理解（NLU）、自然语言生成（NLG）、对话管理等。应用场景：在线客服、智能助手、教育辅导等。自主代理（Agent）主要技术：机器学习、强化学习、知识图谱等。
昇思25天学习打卡营第14天|LLM-文本解码原理--以MindNLP为例
wwt72的博客
07-17 571
限制输出序列的最大长度为50个token。top-p=0.95，top-p采样表示在每一步生成token时，只从概率分布中累计概率达到95%的token中进行采样，有助于保持生成文本的流畅性和质量，同时允许一些低概率的token被选中，从而增加多样性。表示禁用了top-k采样，因为在top-k采样中，通常是从概率最高的k个token中随机选择一个token作为下一个输出，而这里设置为0表示不限制token的选择，实际上这将等同于使用 softmax 概率分布直接进行采样。这有助于提高生成文本的多样性。
python训练模型报错：BrokenPipeError: [Errno 32] Broken pipe
Dxy1239310216的博客
07-18 187
如果问题持续存在，并且你的项目不是必须在 Windows 上运行，考虑在 Unix/Linux 系统上运行你的代码。确保在数据加载器中使用的任何自定义函数或类都是可序列化的，因为多进程需要能够在不同进程间传递它们。进行多进程数据加载时尤其常见，尤其是在 Windows 系统上，因为 Windows 对多进程的支持与 Unix/Linux 系统有所不同。有时候，错误可能是由其他部分的代码引起的，而不是直接由数据加载器引起。如果问题依然存在，你可能需要更详细地检查你的代码或寻求更专业的帮助。
自动驾驶系列—智能巡航辅助功能中的车道变换功能介绍
u013889591的专栏
07-17 723
在现代智能驾驶技术中，智能巡航辅助的车道变换功能是提高驾驶安全性和便利性的关键特性。该功能通过摄像头、传感器和高级算法，使车辆能够在驾驶员的指令下安全地进行车道变换。本文将详细介绍车道变换功能，从背景、功能定义、原理、传感器架构、实际应用案例以及总结与展望几个方面进行阐述。智能巡航辅助功能介绍。随着自动驾驶技术的快速发展，车道变换功能已成为智能驾驶系统中的重要组成部分。
ChaosMeta for AI：混沌工程让AI稳定性更上一层楼
samson
07-18 293
混沌工程的核心思想是“通过在真实环境中引入故障，评估和提升系统的稳定性”。在实际应用中，这意味着通过故意制造各种错误和故障，观察系统的表现，从而找出和修复系统的脆弱点。随着AI系统逐渐成为现代技术的支柱，混沌工程的应用范围也在不断扩展。输出内容：模拟历史已发生的故障，如输出乱码，通过注入代码篡改故障，检验系统的容错能力，确保终端用户看到的是稳定可用的内容。任意代码篡改：模拟意外代码修改对输出的影响。输入内容：通过对抗性样本测试，确保模型的合规合法，符合伦理道德标准。
Gradio从入门到精通（1）---快速入门
疯狂飙车的蜗牛的博客
07-15 1364
Gradio 是一个开源 Python 包，允许您为机器学习模型、API 或任何任意 Python 函数快速构建演示或 Web 应用程序。然后，您可以使用 Gradio 的内置共享功能在几秒钟内共享指向演示或 Web 应用程序的链接。无需 JavaScript、CSS 或 Web 托管经验！Gradio最大的特点就是简单，便捷，短短几行代码就可以快速构建大模型web应用程序；当前很多人工智能模型的演示都是使用Gradio打造的；您会注意到，为了制作第一个演示，您创建了该类的实例。
AI作画入门指南：从基础到高级的全面教程
2401_85639015的博客
07-15 575
定义：AI作画是利用人工智能技术生成艺术作品的过程。常用的工具包括Midjourney、DALL-E和Stable Diffusion等。原理：通过深度学习模型，AI能够解析输入的文字描述，并生成相应的图像。通过这份指南，您可以从基础入门逐步掌握AI作画的技巧，最终创作出独具个性的艺术作品。AI作画不仅是技术的应用，更是艺术的创作。希望这份全面教程能为您的创作之旅提供有益的帮助，激发您的艺术潜能。
python中如何导入遗传算法增强函数ga_algorithm
06-09
在你安装了ga_algorithm模块之后，可以通过以下方式导入其中的遗传算法增强函数： ```python from ga_algorithm import GeneticAlgorithm ``` 这样就可以使用该模块中的`GeneticAlgorithm`类了。如果你在使用过程中遇到了其他问题，可以查看该模块的文档或者示例代码，或者在相关社区寻求帮助。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值