Kichlvichn·хуту
Kichlvichn·хуту

Python深度学习SC2(星际争霸2)AI

文章目录

  • 1.准备工作
    • 创建一个文件
        • 导入sc2包
        • 自定义一个类
        • 第一次运行游戏
        • 现阶段全部代码：
  • 2.探机（工人）和折跃水晶塔（增加人口上限）
        • 为了制造工人，需要自定义一个方法build_workers()
        • 为了增加人口上限，需要自定义一个方法build_pylons()
        • 现阶段全部代码
  • 3.收集瓦斯和扩展基地
        • 扩张基地
        • 建造瓦斯收集器
        • 现阶段所有代码
  • 4.建设军队
        • 建造军队
        • 现阶段所有代码
  • 5.指挥军队
        • 自定义一个简单的攻击方法
        • 扩展攻击方法
  • 6.击败困难人机
        • 定义每分钟迭代数
        • 改进建造GateWay的方法
        • 控制工人数量
        • 动态扩展基地
        • 空军
        • 改进攻击方法
        • 现阶段代码及总结
  • 7.添加深度学习
        • 更改进攻
        • 准备工作
  • 8.将更多的数据进行可视化
        • 绘制所有单位、建筑
        • 侦察敌方信息
        • 现阶段代码
  • 9.建立训练数据
        • 加入其他数据的可视化
        • 变更攻击方法
        • 现阶段全部代码
  • 10.建立神经网络模型
  • 11.训练神经网络模型
  • 12.使用神经网络模型

1.准备工作

战网下载sc2
python3(这里用python3.7.4)
下载游戏地图，前往Blizzard s2client的“ 地图包”部分并下载一些地图。
https://github.com/Blizzard/s2client-proto#map-packs
Python深度学习SC2(星际争霸2)AI_第1张图片
下载好后将地图放入SC2的安装目录的Maps下（没有Maps则新建）结构为：
Python深度学习SC2(星际争霸2)AI_第2张图片

为了方便以星灵种族为例：
游戏内容参考资料 https://liquipedia.net/starcraft2/Protoss_Units_(Legacy_of_the_Void)
Python深度学习SC2(星际争霸2)AI_第3张图片
Python深度学习SC2(星际争霸2)AI_第4张图片

安装sc2包 pip3 install sc2

如果sc2是自定义安装：
打开sc2内的paths.py（位于C:\Users***\AppData\Local\Programs\Python\Python37\Lib\site-packages\sc2\paths.py）

BASEDIR = {
“Windows”: “C:/Program Files (x86)/StarCraft II”, #更改匹配路径
“Darwin”: “/Applications/StarCraft II”,
“Linux”: “~/StarCraftII”,
“WineLinux”: “~/.wine/drive_c/Program Files (x86)/StarCraft II”, }

创建一个文件

创建一个py文件如test.py

导入sc2包

import sc2                                                       
from sc2 import run_game, maps, Race, Difficulty    #导入了运行游戏、地图、种族、难度
from sc2.player import Bot, Computer    #Bot是将要编写的AI，Computer是对战的电脑

也可以只写第一行，这样写只是为了方便

自定义一个类

"""
创建机器人类，继承自sc2.BotAI
"""
class SentBot(sc2.BotAI):
	#用async异步就不需要等待每一个完成再做其他事
    async def on_step(self, iteration):
        #每一步做什么
        await self.distribute_workers()         #父类中的方法

开局有12名工人，首先给他们平均分配工作，将工作人员分配到所有基地。sc2.BotAI父类有一个名为的方法distribute_workers正好可以实现这个功能（如果觉得不够精细，后面也可以自己写分发功能）

想要了解如何实现的可以看这

async def distribute_workers(self, resource_ratio: float = 2):
        """
        Distributes workers across all the bases taken.
        Keyword `resource_ratio` takes a float. If the current minerals to gas
        ratio is bigger than `resource_ratio`, this function prefer filling geysers
        first, if it is lower, it will prefer sending workers to minerals first.
        This is only for workers that need to be moved anyways, it will NOT will
        geysers on its own.

        NOTE: This function is far from optimal, if you really want to have
        refined worker control, you should write your own distribution function.
        For example long distance mining control and moving workers if a base was killed
        are not being handled.

        WARNING: This is quite slow when there are lots of workers or multiple bases.
        """
        if not self.state.mineral_field or not self.workers or not self.townhalls.ready:
            return
        actions = []
        worker_pool = [worker for worker in self.workers.idle]
        bases = self.townhalls.ready
        geysers = self.geysers.ready

        # list of places that need more workers
        deficit_mining_places = []

        for mining_place in bases | geysers:
            difference = mining_place.surplus_harvesters
            # perfect amount of workers, skip mining place
            if not difference:
                continue
            if mining_place.is_vespene_geyser:
                # get all workers that target the gas extraction site
                # or are on their way back from it
                local_workers = self.workers.filter(
                    lambda unit: unit.order_target == mining_place.tag
                    or (unit.is_carrying_vespene and unit.order_target == bases.closest_to(mining_place).tag)
                )
            else:
                # get tags of minerals around expansion
                local_minerals_tags = {
                    mineral.tag for mineral in self.state.mineral_field if mineral.distance_to(mining_place) <= 8
                }
                # get all target tags a worker can have
                # tags of the minerals he could mine at that base
                # get workers that work at that gather site
                local_workers = self.workers.filter(
                    lambda unit: unit.order_target in local_minerals_tags
                    or (unit.is_carrying_minerals and unit.order_target == mining_place.tag)
                )
            # too many workers
            if difference > 0:
                for worker in local_workers[:difference]:
                    worker_pool.append(worker)
            # too few workers
            # add mining place to deficit bases for every missing worker
            else:
                deficit_mining_places += [mining_place for _ in range(-difference)]

        # prepare all minerals near a base if we have too many workers
        # and need to send them to the closest patch
        if len(worker_pool) > len(deficit_mining_places):
            all_minerals_near_base = [
                mineral
                for mineral in self.state.mineral_field
                if any(mineral.distance_to(base) <= 8 for base in self.townhalls.ready)
            ]
        # distribute every worker in the pool
        for worker in worker_pool:
            # as long as have workers and mining places
            if deficit_mining_places:
                # choose only mineral fields first if current mineral to gas ratio is less than target ratio
                if self.vespene and self.minerals / self.vespene < resource_ratio:
                    possible_mining_places = [place for place in deficit_mining_places if not place.vespene_contents]
                # else prefer gas
                else:
                    possible_mining_places = [place for place in deficit_mining_places if place.vespene_contents]
                # if preferred type is not available any more, get all other places
                if not possible_mining_places:
                    possible_mining_places = deficit_mining_places
                # find closest mining place
                current_place = min(deficit_mining_places, key=lambda place: place.distance_to(worker))
                # remove it from the list
                deficit_mining_places.remove(current_place)
                # if current place is a gas extraction site, go there
                if current_place.vespene_contents:
                    actions.append(worker.gather(current_place))
                # if current place is a gas extraction site,
                # go to the mineral field that is near and has the most minerals left
                else:
                    local_minerals = [
                        mineral for mineral in self.state.mineral_field if mineral.distance_to(current_place) <= 8
                    ]
                    target_mineral = max(local_minerals, key=lambda mineral: mineral.mineral_contents)
                    actions.append(worker.gather(target_mineral))
            # more workers to distribute than free mining spots
            # send to closest if worker is doing nothing
            elif worker.is_idle and all_minerals_near_base:
                target_mineral = min(all_minerals_near_base, key=lambda mineral: mineral.distance_to(worker))
                actions.append(worker.gather(target_mineral))
            else:
                # there are no deficit mining places and worker is not idle
                # so dont move him
                pass

        await self.do_actions(actions)

上面的方法在sc2/sc2.BotAI文件中

第一次运行游戏

调用run_game方法设定合适的参数，这里AI选定星灵，敌方选择人类势力的简单人机

"""
运行游戏，选择地图，自定义选手(AI vs computer) or (AI vs AI), 是否实时运行
"""
run_game(maps.get("AbyssalReefLE"), [Bot(Race.Protoss, SentBot()), Computer(Race.Terran, Difficulty.Easy)], realtime = True)

运行文件可以看到如下：

现阶段全部代码：

import sc2                                                       
from sc2 import run_game, maps, Race, Difficulty            #导入了运行游戏、地图、种族、难度
from sc2.player import Bot, Computer      #Bot是将要编写的AI，Computer是对战的电脑                        

"""
创建机器人类，继承自sc2.BotAI
"""
class SentBot(sc2.BotAI):
    #用async异步就不需要等待每一个完成再做其他事
    async def on_step(self, iteration):
        #每一步做什么
        await self.distribute_workers()         #父类中的方法
        

"""
运行游戏，选择地图，自定义选手(AI vs computer) or (AI vs AI), 是否实时运行
"""
run_game(maps.get("AbyssalReefLE"), [Bot(Race.Protoss, SentBot()), Computer(Race.Terran, Difficulty.Easy)], realtime = True)

2.探机（工人）和折跃水晶塔（增加人口上限）

之前的代码只能分配工人，现在需要来写一个创造工人的方法
在星灵种族（Protoss）中主基地叫（Nexus）工人叫（Probe）
详见游戏内容参考资料 https://liquipedia.net/starcraft2/Protoss_Units_(Legacy_of_the_Void)

为了制造工人，根据关系图可知，要先访问Nexus，还要为了与工人交互，访问Probe，为了增加人口上限，访问Pylon。

from sc2.constants import UnitTypeId

为了制造工人，需要自定义一个方法build_workers()

        async def build_workers(self):
        #遍历全部的主基地（已经准备好的且没有队列的）
        for nexus in self.units(UnitTypeId.NEXUS).ready.noqueue:
            #如果能够支付的起工人
            if self.can_afford(UnitTypeId.PROBE):
                #让该目标制造一个工人
                await self.do(nexus.train(UnitTypeId.PROBE))

为了增加人口上限，需要自定义一个方法build_pylons()

    async def build_pylons(self):
        #如果人口上限 - 当前人口 < 5 并且当前没有正在建造的水晶塔
        if self.supply_left < 5 and not self.already_pending(UnitTypeId.PYLON):
            #找到已经建好的主基地
            nexuses = self.units(UnitTypeId.NEXUS).ready
            #如果主基地存在
            if nexuses.exists:
                #如果能够支付的起水晶塔
                if self.can_afford(UnitTypeId.PYLON):
                    #在主基地附近建造水晶塔
                    await self.build(UnitTypeId.PYLON, near=nexuses.first)

现阶段全部代码

import sc2                                                       
from sc2 import run_game, maps, Race, Difficulty            #导入了运行游戏、地图、种族、难度
from sc2.player import Bot, Computer      #Bot是将要编写的AI，Computer是对战的电脑
from sc2.constants import UnitTypeId

"""
创建机器人类，继承自sc2.BotAI
"""
class SentBot(sc2.BotAI):
    #用async异步就不需要等待每一个完成再做其他事
    async def on_step(self, iteration):
        #每一步做什么
        await self.distribute_workers()         #父类中的方法
        #建造工人
        await self.build_workers()
        #建造水晶塔
        await self.build_pylons()

    async def build_workers(self):
        #遍历全部的主基地（已经准备好的且没有队列的）
        for nexus in self.units(UnitTypeId.NEXUS).ready.noqueue:
            #如果能够支付的起工人
            if self.can_afford(UnitTypeId.PROBE):
                #让该目标制造一个工人
                await self.do(nexus.train(UnitTypeId.PROBE))

    async def build_pylons(self):
        #如果人口上限 - 当前人口 < 5 并且当前没有正在建造的水晶塔
        if self.supply_left < 5 and not self.already_pending(UnitTypeId.PYLON):
            #找到已经建好的主基地
            nexuses = self.units(UnitTypeId.NEXUS).ready
            #如果主基地存在
            if nexuses.exists:
                #如果能够支付的起水晶塔
                if self.can_afford(UnitTypeId.PYLON):
                    #在主基地附近建造水晶塔
                    await self.build(UnitTypeId.PYLON, near=nexuses.first)


"""
运行游戏，选择地图，自定义选手(AI vs computer) or (AI vs AI), 是否实时运行
"""
run_game(maps.get("AbyssalReefLE"), [Bot(Race.Protoss, SentBot()), Computer(Race.Terran, Difficulty.Easy)], realtime = True)

3.收集瓦斯和扩展基地

扩张基地

自定义方法expand()

    async def expand(self):
        #如果基地总数小于n且能够支付的起基地建造的费用
        if self.units(UnitTypeId.NEXUS).amount < 2 and self.can_afford(UnitTypeId.NEXUS):
            #父类扩张基地方法
            await self.expand_now()

建造瓦斯收集器

当需要进行进一步的发展时，需要从主基地附件的Vespene收集瓦斯，这种建筑物称为assimilator。
范围可做调整，15左右差不多。

    async def build_assimilator(self):
        #遍历所有已经建好的主基地
        for nexus in self.units(UnitTypeId.NEXUS).ready:
            #定义所有离该主基地25个单元格的瓦斯间歇泉
            vespenes = self.state.vespene_geyser.closer_than(25, nexus)
            for vespene in vespenes:
                #如果支付不起则退出
                if not self.can_afford(UnitTypeId.ASSIMILATOR):
                    break
                #否则就在瓦斯泉的附近选一个工人
                worker = self.select_build_worker(vespene.position)
                #如果没有工人则退出
                if not worker:
                    break
                #如果瓦斯间歇泉上面没有瓦斯收集器就建一个瓦斯收集器
                if not self.units(UnitTypeId.ASSIMILATOR).closer_than(1.0, vespene).exists:
                    await self.do(worker.build(UnitTypeId.ASSIMILATOR, vespene))

现阶段所有代码

import sc2                                                       
from sc2 import run_game, maps, Race, Difficulty            #导入了运行游戏、地图、种族、难度
from sc2.player import Bot, Computer      #Bot是将要编写的AI，Computer是对战的电脑
from sc2.constants import UnitTypeId

"""
创建机器人类，继承自sc2.BotAI
"""
class SentBot(sc2.BotAI):
    #用async异步就不需要等待每一个完成再做其他事
    async def on_step(self, iteration):
        #每一步做什么
        await self.distribute_workers()         #父类中的方法
        #建造工人
        await self.build_workers()
        #建造水晶塔
        await self.build_pylons()
        #扩张基地
        await self.expand()
        #建造瓦斯收集器
        await self.build_assimilator()


    async def build_workers(self):
        #遍历全部的主基地（已经准备好的且没有队列的）
        for nexus in self.units(UnitTypeId.NEXUS).ready.noqueue:
            #如果能够支付的起工人
            if self.can_afford(UnitTypeId.PROBE):
                #让该目标制造一个工人
                await self.do(nexus.train(UnitTypeId.PROBE))


    async def build_pylons(self):
        #如果人口上限 - 当前人口 < 5 并且当前没有正在建造的水晶塔
        if self.supply_left < 5 and not self.already_pending(UnitTypeId.PYLON):
            #找到已经建好的主基地
            nexuses = self.units(UnitTypeId.NEXUS).ready
            #如果主基地存在
            if nexuses.exists:
                #如果能够支付的起水晶塔
                if self.can_afford(UnitTypeId.PYLON):
                    #在主基地附近建造水晶塔
                    await self.build(UnitTypeId.PYLON, near=nexuses.first)


    async def expand(self):
        #如果基地总数小于n且能够支付的起基地建造的费用
        if self.units(UnitTypeId.NEXUS).amount < 2 and self.can_afford(UnitTypeId.NEXUS):
            #父类扩张基地方法
            await self.expand_now()


    async def build_assimilator(self):
        #遍历所有已经建好的主基地
        for nexus in self.units(UnitTypeId.NEXUS).ready:
            #定义所有离该主基地25个单元格的瓦斯间歇泉
            vespenes = self.state.vespene_geyser.closer_than(25, nexus)
            for vespene in vespenes:
                #如果支付不起则退出
                if not self.can_afford(UnitTypeId.ASSIMILATOR):
                    break
                #否则就在瓦斯泉的附近选一个工人
                worker = self.select_build_worker(vespene.position)
                #如果没有工人则退出
                if not worker:
                    break
                #如果瓦斯间歇泉上面没有瓦斯收集器就建一个瓦斯收集器
                if not self.units(UnitTypeId.ASSIMILATOR).closer_than(1.0, vespene).exists:
                    await self.do(worker.build(UnitTypeId.ASSIMILATOR, vespene))

"""
运行游戏，选择地图，自定义选手(AI vs computer) or (AI vs AI), 是否实时运行
"""
run_game(maps.get("AbyssalReefLE"), [Bot(Race.Protoss, SentBot()), Computer(Race.Terran, Difficulty.Easy)], realtime = True)

4.建设军队

为了简单起见，建议构建单一的兵种，这里选择能够攻击地面和空中单位的兵种。
Python深度学习SC2(星际争霸2)AI_第5张图片
Python深度学习SC2(星际争霸2)AI_第6张图片
这里选择stalker为例，因为现在更容易使用。
可以看到它的制造前提为：
Python深度学习SC2(星际争霸2)AI_第7张图片
控制核心（Cybernet Core）是关于研究的，只需要造一个，如果需要加速出兵，则可以多造（Gateway）。
由于选择的是Protoss，使用需要在水晶塔的范围内才能建造建筑物

 async def build_army_buildings(self):
        #首先需要找到水晶塔
        if self.units(UnitTypeId.PYLON).ready.exists:
            #如果有水晶塔，则选择一个随机的水晶塔
            pylon = self.units(UnitTypeId.PYLON).ready.random
            #如果已经存在GateWay
            if self.units(UnitTypeId.GATEWAY).ready.exists:
                #如果没有CyberneticsCore，而且能支付的起且没有正在建造中的，则建造CyberneticsCore
                if not self.units(UnitTypeId.CYBERNETICSCORE):
                    if self.can_afford(UnitTypeId.CYBERNETICSCORE) and \
                        not self.already_pending(UnitTypeId.CYBERNETICSCORE):
                        await self.build(UnitTypeId.CYBERNETICSCORE, near=pylon)
            #如果不存在，且能够支付得起，而且没有正在建造中的，则建造
            else:
                if self.can_afford(UnitTypeId.GATEWAY) and not self.already_pending(UnitTypeId.GATEWAY):
                    await self.build(UnitTypeId.GATEWAY, near=pylon)

详情见注释

建造军队

类似于建造工人

    async def build_army(self):
        #遍历所有已经建好的且没有队列的Gateway
        for gw in self.units(UnitTypeId.GATEWAY).ready.noqueue:
            #如果能支付得起且可用人口大于0，则训练Stalker
            if self.can_afford(UnitTypeId.STALKER) and self.supply_left > 0:
                await self.do(gw.train(UnitTypeId.STALKER))

现阶段所有代码

import sc2                                                       
from sc2 import run_game, maps, Race, Difficulty            #导入了运行游戏、地图、种族、难度
from sc2.player import Bot, Computer      #Bot是将要编写的AI，Computer是对战的电脑
from sc2.constants import UnitTypeId

"""
创建机器人类，继承自sc2.BotAI
"""
class SentBot(sc2.BotAI):
    #用async异步就不需要等待每一个完成再做其他事
    async def on_step(self, iteration):
        #每一步做什么
        await self.distribute_workers()         #父类中的方法
        #建造工人
        await self.build_workers()
        #建造水晶塔
        await self.build_pylons()
        #扩张基地
        await self.expand()
        #建造瓦斯收集器
        await self.build_assimilator()
        #建造能生产军队的建筑
        await self.build_army_buildings()
        #建造军队
        await self.build_army()


    async def build_workers(self):
        #遍历全部的主基地（已经准备好的且没有队列的）
        for nexus in self.units(UnitTypeId.NEXUS).ready.noqueue:
            #如果能够支付的起工人
            if self.can_afford(UnitTypeId.PROBE):
                #让该目标制造一个工人
                await self.do(nexus.train(UnitTypeId.PROBE))


    async def build_pylons(self):
        #如果人口上限 - 当前人口 < 5 并且当前没有正在建造的水晶塔
        if self.supply_left < 5 and not self.already_pending(UnitTypeId.PYLON):
            #找到已经建好的主基地
            nexuses = self.units(UnitTypeId.NEXUS).ready
            #如果主基地存在
            if nexuses.exists:
                #如果能够支付的起水晶塔
                if self.can_afford(UnitTypeId.PYLON):
                    #在主基地附近建造水晶塔
                    await self.build(UnitTypeId.PYLON, near=nexuses.first)


    async def expand(self):
        #如果基地总数小于n且能够支付的起基地建造的费用
        if self.units(UnitTypeId.NEXUS).amount < 2 and self.can_afford(UnitTypeId.NEXUS):
            #父类扩张基地方法
            await self.expand_now()


    async def build_assimilator(self):
        #遍历所有已经建好的主基地
        for nexus in self.units(UnitTypeId.NEXUS).ready:
            #定义所有离该主基地25个单元格的瓦斯间歇泉
            vespenes = self.state.vespene_geyser.closer_than(25, nexus)
            for vespene in vespenes:
                #如果支付不起则退出
                if not self.can_afford(UnitTypeId.ASSIMILATOR):
                    break
                #否则就在瓦斯泉的附近选一个工人
                worker = self.select_build_worker(vespene.position)
                #如果没有工人则退出
                if not worker:
                    break
                #如果瓦斯间歇泉上面没有瓦斯收集器就建一个瓦斯收集器
                if not self.units(UnitTypeId.ASSIMILATOR).closer_than(1.0, vespene).exists:
                    await self.do(worker.build(UnitTypeId.ASSIMILATOR, vespene))


    async def build_army_buildings(self):
        #首先需要找到水晶塔
        if self.units(UnitTypeId.PYLON).ready.exists:
            #如果有水晶塔，则选择一个随机的水晶塔
            pylon = self.units(UnitTypeId.PYLON).ready.random
            #如果已经存在GateWay
            if self.units(UnitTypeId.GATEWAY).ready.exists:
                #如果没有CyberneticsCore，而且能支付的起且没有正在建造中的，则建造CyberneticsCore
                if not self.units(UnitTypeId.CYBERNETICSCORE):
                    if self.can_afford(UnitTypeId.CYBERNETICSCORE) and \
                        not self.already_pending(UnitTypeId.CYBERNETICSCORE):
                        await self.build(UnitTypeId.CYBERNETICSCORE, near=pylon)
            #如果不存在，且能够支付得起，而且没有正在建造中的，则建造
            else:
                if self.can_afford(UnitTypeId.GATEWAY) and not self.already_pending(UnitTypeId.GATEWAY):
                    await self.build(UnitTypeId.GATEWAY, near=pylon)


    async def build_army(self):
        #遍历所有已经建好的且没有队列的Gateway
        for gw in self.units(UnitTypeId.GATEWAY).ready.noqueue:
            #如果能支付得起且可用人口大于0，则训练Stalker
            if self.can_afford(UnitTypeId.STALKER) and self.supply_left > 0:
                await self.do(gw.train(UnitTypeId.STALKER))

"""
运行游戏，选择地图，自定义选手(AI vs computer) or (AI vs AI), 是否实时运行
"""
run_game(maps.get("AbyssalReefLE"), [Bot(Race.Protoss, SentBot()), Computer(Race.Terran, Difficulty.Easy)], realtime = False)

5.指挥军队

有了造兵的功能，现在可以指挥军队了

自定义一个简单的攻击方法

    async def attack_enemy(self):
        if self.units(UnitTypeId.STALKER).amount > 3:
            if len(self.known_enemy_units) > 0:
                for s in self.units(UnitTypeId.STALKER).idle:
                    await self.do(s.attack(random.choice(self.known_enemy_units)))

如果小兵的数量大于3且发现了敌人，则遍历在闲置状态的小兵去攻击一个随机的敌人。

扩展攻击方法

首先需要一个用来寻找敌方目标的方法
自定义方法find_target()

    def find_target(self):
        #如果发现了敌方单位
        if len(self.known_enemy_units) > 0:
            return random.choice(self.known_enemy_units)
        # 如果发现了敌方建筑
        elif len(self.known_enemy_structures) > 0:
            return random.choice(self.known_enemy_structures)
        #什么都没发现直接去敌方出生点
        else:
            return self.enemy_start_locations[0]

改进攻击方法

    async def attack_enemy(self):
        #总兵数大于3，保守
        if self.units(UnitTypeId.STALKER).amount > 3:
            if len(self.known_enemy_units) > 0:
                for s in self.units(UnitTypeId.STALKER).idle:
                    await self.do(s.attack(random.choice(self.known_enemy_units)))
        #总兵数大于15,激进
        if self.units(UnitTypeId.STALKER).amount > 15:
            for s in self.units(UnitTypeId.STALKER).idle:
                await self.do(s.attack(self.find_target()))

6.击败困难人机

目前的问题是AI没有时间概念，而且没有合理的平衡工人和军队的人数
经过测试每分钟大约165次迭代

定义每分钟迭代数

#初始化
    def __init__(self):
        #每分钟迭代数
        self.ITERATIONS_PER_MINUTE = 165

在on_step中添加记录

    async def on_step(self, iteration):
        #记录已经迭代的次数
        self.iteration = iteration
        ......

改进建造GateWay的方法

    async def build_army_buildings(self):
        #首先需要找到水晶塔
        if self.units(UnitTypeId.PYLON).ready.exists:
            #如果有水晶塔，则选择一个随机的水晶塔
            pylon = self.units(UnitTypeId.PYLON).ready.random
            #如果已经存在GateWay且没有CyberneticsCore
            if self.units(UnitTypeId.GATEWAY).ready.exists and not self.units(UnitTypeId.CYBERNETICSCORE):
                #如果能支付的起且没有正在建造中的，则建造CyberneticsCore
                if self.can_afford(UnitTypeId.CYBERNETICSCORE) and not self.already_pending(UnitTypeId.CYBERNETICSCORE):
                    await self.build(UnitTypeId.CYBERNETICSCORE, near=pylon)
            #如果gateway的数量小于分钟数
            elif len(self.units(UnitTypeId.GATEWAY)) < (self.iteration / self.ITERATIONS_PER_MINUTE):
                #且能够支付得起，而且没有正在建造中的，则建造
                if self.can_afford(UnitTypeId.GATEWAY) and not self.already_pending(UnitTypeId.GATEWAY):
                    await self.build(UnitTypeId.GATEWAY, near=pylon)

控制工人数量

    def __init__(self):
        #每分钟迭代数
        self.ITERATIONS_PER_MINUTE = 165
        #定义最大工人数
        self.MAX_WORKERS = 50

如果要动态的控制工人的数量，则：
改进后建造工人的方法

    async def build_workers(self):
        #动态控制工人数量
        if len(self.units(UnitTypeId.PROBE)) < (len(self.units(UnitTypeId.NEXUS)) * 16) and \
            len(self.units(UnitTypeId.PROBE)) < self.MAX_WORKERS:
            #遍历全部的主基地（已经准备好的且没有队列的）
            for nexus in self.units(UnitTypeId.NEXUS).ready.noqueue:
                #如果能够支付的起工人
                if self.can_afford(UnitTypeId.PROBE):
                    #让该目标制造一个工人
                    await self.do(nexus.train(UnitTypeId.PROBE))

动态扩展基地

与其一次扩张3个基地，不如按照时间来扩张，这样更加合理

    async def expand(self):
        #如果基地总数小于n且能够支付的起基地建造的费用
        if self.units(UnitTypeId.NEXUS).amount < (self.iteration / self.ITERATIONS_PER_MINUTE ) and \
                self.can_afford(UnitTypeId.NEXUS):
            #父类扩张基地方法
            await self.expand_now()

空军

由于后期Stalker不强，不如建立一支空军（Void Ray）
要想建立（Void Ray）还需要一个建筑（Stargate）

再次改进（军队建筑）

    async def build_army_buildings(self):
        #首先需要找到水晶塔
        if self.units(UnitTypeId.PYLON).ready.exists:
            #如果有水晶塔，则选择一个随机的水晶塔
            pylon = self.units(UnitTypeId.PYLON).ready.random
            
            #如果已经存在GateWay且没有CyberneticsCore
            if self.units(UnitTypeId.GATEWAY).ready.exists and not self.units(UnitTypeId.CYBERNETICSCORE):
                #如果能支付的起且没有正在建造中的，则建造CyberneticsCore
                if self.can_afford(UnitTypeId.CYBERNETICSCORE) and not self.already_pending(UnitTypeId.CYBERNETICSCORE):
                    await self.build(UnitTypeId.CYBERNETICSCORE, near=pylon)
                    
            #如果gateway的数量小于分钟数/2
            elif len(self.units(UnitTypeId.GATEWAY)) < (self.iteration / self.ITERATIONS_PER_MINUTE / 2):
                #且能够支付得起，而且没有正在建造中的，则建造
                if self.can_afford(UnitTypeId.GATEWAY) and not self.already_pending(UnitTypeId.GATEWAY):
                    await self.build(UnitTypeId.GATEWAY, near=pylon)
            
            #如果有了控制核心，则建立Stargate
            if self.units(UnitTypeId.CYBERNETICSCORE).ready.exists:
                #数量小于分钟数/2
                if len(self.units(UnitTypeId.STARGATE)) < (self.iteration / self.ITERATIONS_PER_MINUTE / 2):
                    # 且能够支付得起，而且没有正在建造中的，则建造
                    if self.can_afford(UnitTypeId.STARGATE) and not self.already_pending(UnitTypeId.STARGATE):
                        await self.build(UnitTypeId.STARGATE, near=pylon)

造兵

    async def build_army(self):
        #遍历所有已经建好的且没有队列的Gateway
        for gw in self.units(UnitTypeId.GATEWAY).ready.noqueue:
            if self.units(UnitTypeId.STALKER).amount <= self.units(UnitTypeId.VOIDRAY).amount:
                #如果能支付得起且可用人口大于0，则训练Stalker
                if self.can_afford(UnitTypeId.STALKER) and self.supply_left > 0:
                    await self.do(gw.train(UnitTypeId.STALKER))
        #空军
        for sg in self.units(UnitTypeId.STARGATE).ready.noqueue:
            if self.can_afford(UnitTypeId.VOIDRAY) and self.supply_left > 0:
                await self.do(sg.train(UnitTypeId.VOIDRAY))

改进攻击方法

    async def attack_enemy(self):
        #[0：进攻， 1：防守]
        army_types = {UnitTypeId.STALKER : [15, 5], UnitTypeId.VOIDRAY : [8, 3]}
        for n in army_types:
            # 激进
            if self.units(n).amount > army_types[n][0]:
                for s in self.units(n).idle:
                    await self.do(s.attack(self.find_target()))
            # 保守
            if self.units(n).amount > army_types[n][1]:
                if len(self.known_enemy_units) > 0:
                    for s in self.units(UnitTypeId.STALKER).idle:
                        await self.do(s.attack(random.choice(self.known_enemy_units)))

现阶段代码及总结

import sc2                                                       
from sc2 import run_game, maps, Race, Difficulty            #导入了运行游戏、地图、种族、难度
from sc2.player import Bot, Computer      #Bot是将要编写的AI，Computer是对战的电脑
from sc2.constants import UnitTypeId
import random

"""
创建机器人类，继承自sc2.BotAI
"""
class SentBot(sc2.BotAI):
    #初始化
    def __init__(self):
        #每分钟迭代数
        self.ITERATIONS_PER_MINUTE = 165
        #定义最大工人数
        self.MAX_WORKERS = 50


    #用async异步就不需要等待每一个完成再做其他事
    async def on_step(self, iteration):
        #记录已经迭代的次数
        self.iteration = iteration
        #每一步做什么
        await self.distribute_workers()         #父类中的方法
        #建造工人
        await self.build_workers()
        #建造水晶塔
        await self.build_pylons()
        #扩张基地
        await self.expand()
        #建造瓦斯收集器
        await self.build_assimilator()
        #建造能生产军队的建筑
        await self.build_army_buildings()
        #建造军队
        await self.build_army()
        #军队作战
        await self.attack_enemy()


    async def build_workers(self):
        #动态控制工人数量
        if len(self.units(UnitTypeId.PROBE)) < (len(self.units(UnitTypeId.NEXUS)) * 16) and \
            len(self.units(UnitTypeId.PROBE)) < self.MAX_WORKERS:
            #遍历全部的主基地（已经准备好的且没有队列的）
            for nexus in self.units(UnitTypeId.NEXUS).ready.noqueue:
                #如果能够支付的起工人
                if self.can_afford(UnitTypeId.PROBE):
                    #让该目标制造一个工人
                    await self.do(nexus.train(UnitTypeId.PROBE))


    async def build_pylons(self):
        #如果人口上限 - 当前人口 < 5 并且当前没有正在建造的水晶塔
        if self.supply_left < 5 and not self.already_pending(UnitTypeId.PYLON):
            #找到已经建好的主基地
            nexuses = self.units(UnitTypeId.NEXUS).ready
            #如果主基地存在
            if nexuses.exists:
                #如果能够支付的起水晶塔
                if self.can_afford(UnitTypeId.PYLON):
                    #在主基地附近建造水晶塔
                    await self.build(UnitTypeId.PYLON, near=nexuses.first)


    async def expand(self):
        #如果基地总数小于n且能够支付的起基地建造的费用
        if self.units(UnitTypeId.NEXUS).amount < (self.iteration / self.ITERATIONS_PER_MINUTE / 2) and \
                self.can_afford(UnitTypeId.NEXUS):
            #父类扩张基地方法
            await self.expand_now()


    async def build_assimilator(self):
        #遍历所有已经建好的主基地
        for nexus in self.units(UnitTypeId.NEXUS).ready:
            #定义所有离该主基地25个单元格的瓦斯间歇泉
            vespenes = self.state.vespene_geyser.closer_than(15.0, nexus)
            for vespene in vespenes:
                #如果支付不起则退出
                if not self.can_afford(UnitTypeId.ASSIMILATOR):
                    break
                #否则就在瓦斯泉的附近选一个工人
                worker = self.select_build_worker(vespene.position)
                #如果没有工人则退出
                if not worker:
                    break
                #如果瓦斯间歇泉上面没有瓦斯收集器就建一个瓦斯收集器
                if not self.units(UnitTypeId.ASSIMILATOR).closer_than(1.0, vespene).exists:
                    await self.do(worker.build(UnitTypeId.ASSIMILATOR, vespene))


    async def build_army_buildings(self):
        #首先需要找到水晶塔
        if self.units(UnitTypeId.PYLON).ready.exists:
            #如果有水晶塔，则选择一个随机的水晶塔
            pylon = self.units(UnitTypeId.PYLON).ready.random

            #如果已经存在GateWay且没有CyberneticsCore
            if self.units(UnitTypeId.GATEWAY).ready.exists and not self.units(UnitTypeId.CYBERNETICSCORE):
                #如果能支付的起且没有正在建造中的，则建造CyberneticsCore
                if self.can_afford(UnitTypeId.CYBERNETICSCORE) and not self.already_pending(UnitTypeId.CYBERNETICSCORE):
                    await self.build(UnitTypeId.CYBERNETICSCORE, near=pylon)

            #如果gateway的数量小于分钟数/2
            elif len(self.units(UnitTypeId.GATEWAY)) < (self.iteration / self.ITERATIONS_PER_MINUTE / 2):
                #且能够支付得起，而且没有正在建造中的，则建造
                if self.can_afford(UnitTypeId.GATEWAY) and not self.already_pending(UnitTypeId.GATEWAY):
                    await self.build(UnitTypeId.GATEWAY, near=pylon)

            #如果有了控制核心，则建立Stargate
            if self.units(UnitTypeId.CYBERNETICSCORE).ready.exists:
                #数量小于分钟数/2
                if len(self.units(UnitTypeId.STARGATE)) < (self.iteration / self.ITERATIONS_PER_MINUTE / 2):
                    # 且能够支付得起，而且没有正在建造中的，则建造
                    if self.can_afford(UnitTypeId.STARGATE) and not self.already_pending(UnitTypeId.STARGATE):
                        await self.build(UnitTypeId.STARGATE, near=pylon)


    async def build_army(self):
        #遍历所有已经建好的且没有队列的Gateway
        for gw in self.units(UnitTypeId.GATEWAY).ready.noqueue:
            if self.units(UnitTypeId.STALKER).amount <= self.units(UnitTypeId.VOIDRAY).amount:
                #如果能支付得起且可用人口大于0，则训练Stalker
                if self.can_afford(UnitTypeId.STALKER) and self.supply_left > 0:
                    await self.do(gw.train(UnitTypeId.STALKER))
        #空军
        for sg in self.units(UnitTypeId.STARGATE).ready.noqueue:
            if self.can_afford(UnitTypeId.VOIDRAY) and self.supply_left > 0:
                await self.do(sg.train(UnitTypeId.VOIDRAY))


    async def attack_enemy(self):
        #[0：进攻， 1：防守]
        army_types = {UnitTypeId.STALKER : [15, 5], UnitTypeId.VOIDRAY : [8, 3]}
        for n in army_types:
            # 激进
            if self.units(n).amount > army_types[n][0]:
                for s in self.units(n).idle:
                    await self.do(s.attack(self.find_target()))
            # 保守
            if self.units(n).amount > army_types[n][1]:
                if len(self.known_enemy_units) > 0:
                    for s in self.units(UnitTypeId.STALKER).idle:
                        await self.do(s.attack(random.choice(self.known_enemy_units)))



    def find_target(self):
        #如果发现了敌方单位
        if len(self.known_enemy_units) > 0:
            return random.choice(self.known_enemy_units)
        # 如果发现了敌方建筑
        elif len(self.known_enemy_structures) > 0:
            return random.choice(self.known_enemy_structures)
        #什么都没发现直接去敌方出生点
        else:
            return self.enemy_start_locations[0]

"""
运行游戏，选择地图，自定义选手(AI vs computer) or (AI vs AI), 是否实时运行
"""
run_game(maps.get("AbyssalReefLE"), [Bot(Race.Protoss, SentBot()), Computer(Race.Terran, Difficulty.Hard)], realtime = False)


现在基本上能够战胜困难人机了
现阶段可以从GitHub上下载别人的AI来进行对战。

7.添加深度学习

尝试添加深度学习的进化算法。
使用遗传进化算法可以使获胜的成为训练数据（基因库），失败的则被遗忘（淘汰）。

更改进攻

只使用voidray
建筑

    async def build_army_buildings(self):
        #首先需要找到水晶塔
        if self.units(UnitTypeId.PYLON).ready.exists:
            #如果有水晶塔，则选择一个随机的水晶塔
            pylon = self.units(UnitTypeId.PYLON).ready.random

            #如果已经存在GateWay且没有CyberneticsCore
            if self.units(UnitTypeId.GATEWAY).ready.exists and not self.units(UnitTypeId.CYBERNETICSCORE):
                #如果能支付的起且没有正在建造中的，则建造CyberneticsCore
                if self.can_afford(UnitTypeId.CYBERNETICSCORE) and not self.already_pending(UnitTypeId.CYBERNETICSCORE):
                    await self.build(UnitTypeId.CYBERNETICSCORE, near=pylon)

            #如果gateway的数量小于1
            elif len(self.units(UnitTypeId.GATEWAY)) < 1:
                #且能够支付得起，而且没有正在建造中的，则建造
                if self.can_afford(UnitTypeId.GATEWAY) and not self.already_pending(UnitTypeId.GATEWAY):
                    await self.build(UnitTypeId.GATEWAY, near=pylon)

            #如果有了控制核心，则建立Stargate
            if self.units(UnitTypeId.CYBERNETICSCORE).ready.exists:
                #数量小于分钟数/2
                if len(self.units(UnitTypeId.STARGATE)) < (self.iteration / self.ITERATIONS_PER_MINUTE):
                    # 且能够支付得起，而且没有正在建造中的，则建造
                    if self.can_afford(UnitTypeId.STARGATE) and not self.already_pending(UnitTypeId.STARGATE):
                        await self.build(UnitTypeId.STARGATE, near=pylon)

造兵

    async def build_army(self):
        #空军
        for sg in self.units(UnitTypeId.STARGATE).ready.noqueue:
            if self.can_afford(UnitTypeId.VOIDRAY) and self.supply_left > 0:
                await self.do(sg.train(UnitTypeId.VOIDRAY))

攻击

    async def attack_enemy(self):
        #[0：进攻， 1：防守]
        army_types = {#UnitTypeId.STALKER : [15, 5],
         UnitTypeId.VOIDRAY : [8, 3]}
        for n in army_types:
            for s in self.units(n).idle:
                await self.do(s.attack(self.find_target()))

可以选择全部进攻或者不进攻。
在整个游戏中有许多的变量，我们要可视化此数据，并且传给神经网络，建议使用卷积神经网络。

准备工作

安装cv2，numpy，matplotlib

import cv2
import numpy as np

自定义一个方法，用来可视化数据

    """攻击之前执行此操作"""
    async def intel(self):
        #200 176 3  按行绘制RGB（200个矩阵）
        game_data = np.zeros((self.game_info.map_size[1], self.game_info.map_size[0], 3), np.uint8)
        for nexus in self.units(UnitTypeId.NEXUS):
            n_pos = nexus.position
            cv2.circle(game_data, (int(n_pos[0]), int(n_pos[1])), 10, (0,255,0), -1)
        #图像垂直翻转
        flipped = cv2.flip(game_data, 0)
        #调整图像大小，原图像，输出图像所需大小，比例因子
        resized = cv2.resize(flipped, dsize=None, fx=2, fy=2)

        cv2.imshow("Intel", resized)
        cv2.waitKey(1)

8.将更多的数据进行可视化

绘制所有单位、建筑

首先，我们要可视化其余单元。创建一个draw_dict

#绘制己方所有单元
        draw_dict = {
                     UnitTypeId.NEXUS: [15, (0, 255, 0)],
                     UnitTypeId.PYLON: [3, (20, 235, 0)],
                     UnitTypeId.PROBE: [1, (55, 200, 0)],
                     UnitTypeId.ASSIMILATOR: [2, (55, 200, 0)],
                     UnitTypeId.GATEWAY: [3, (200, 100, 0)],
                     UnitTypeId.CYBERNETICSCORE: [3, (150, 150, 0)],
                     UnitTypeId.STARGATE: [5, (255, 0, 0)],
                     UnitTypeId.VOIDRAY: [3, (255, 100, 0)],
                    }
        for unit in draw_dict:
            for n in self.units(unit).ready:
                n_pos = n.position
                cv2.circle(game_data, (int(n_pos[0]), int(n_pos[1])), draw_dict[unit][0], draw_dict[unit][1], -1)

        #绘制敌方的单元
        #建筑
        main_base_names = ["nexus", "commandcenter", "hatchery"]
        for enemy_building in self.known_enemy_structures:
            pos = enemy_building.position
            #非主基地
            if enemy_building.name.lower() not in main_base_names:
                cv2.circle(game_data, (int(pos[0]), int(pos[1])), 5, (200, 50, 212), -1)
        for enemy_building in self.known_enemy_structures:
            pos = enemy_building.position
            #主基地
            if enemy_building.name.lower() in main_base_names:
                cv2.circle(game_data, (int(pos[0]), int(pos[1])), 15, (0, 0, 255), -1)
        #敌方单位
        for enemy_unit in self.known_enemy_units:
            if not enemy_unit.is_structure:
                worker_names = ["probe",
                                "scv",
                                "drone"]
                pos = enemy_unit.position
                #工人
                if enemy_unit.name.lower() in worker_names:
                    cv2.circle(game_data, (int(pos[0]), int(pos[1])), 1, (55, 0, 155), -1)
                #军队
                else:
                    cv2.circle(game_data, (int(pos[0]), int(pos[1])), 3, (50, 0, 215), -1)

侦察敌方信息

组建一个侦查员（observer）还需要一个建筑（Robotics Facility）
Python深度学习SC2(星际争霸2)AI_第8张图片
Python深度学习SC2(星际争霸2)AI_第9张图片
更改方法

    async def build_army_buildings(self):
        #首先需要找到水晶塔
        if self.units(UnitTypeId.PYLON).ready.exists:
            #如果有水晶塔，则选择一个随机的水晶塔
            pylon = self.units(UnitTypeId.PYLON).ready.random

            #如果已经存在GateWay且没有CyberneticsCore
            if self.units(UnitTypeId.GATEWAY).ready.exists and not self.units(UnitTypeId.CYBERNETICSCORE):
                #如果能支付的起且没有正在建造中的，则建造CyberneticsCore
                if self.can_afford(UnitTypeId.CYBERNETICSCORE) and not self.already_pending(UnitTypeId.CYBERNETICSCORE):
                    await self.build(UnitTypeId.CYBERNETICSCORE, near=pylon)

            #如果gateway的数量小于1
            elif len(self.units(UnitTypeId.GATEWAY)) < 1:
                #且能够支付得起，而且没有正在建造中的，则建造
                if self.can_afford(UnitTypeId.GATEWAY) and not self.already_pending(UnitTypeId.GATEWAY):
                    await self.build(UnitTypeId.GATEWAY, near=pylon)

            #如果有了控制核心，则建立Stargate
            if self.units(UnitTypeId.CYBERNETICSCORE).ready.exists:
                #数量小于分钟数/2
                if len(self.units(UnitTypeId.STARGATE)) < (self.iteration / self.ITERATIONS_PER_MINUTE):
                    # 且能够支付得起，而且没有正在建造中的，则建造
                    if self.can_afford(UnitTypeId.STARGATE) and not self.already_pending(UnitTypeId.STARGATE):
                        await self.build(UnitTypeId.STARGATE, near=pylon)

            # 如果有了控制核心，则建造侦察兵基地
            if self.units(UnitTypeId.CYBERNETICSCORE).ready.exists:
                #数量小于1
                if len(self.units(UnitTypeId.ROBOTICSFACILITY)) < 1:
                    if self.can_afford(UnitTypeId.ROBOTICSFACILITY) and not self.already_pending(UnitTypeId.ROBOTICSFACILITY):
                        await self.build(UnitTypeId.ROBOTICSFACILITY, near=pylon)

添加自定义方法（侦查员）

    def random_location_variance(self, enemy_start_location):
        x = enemy_start_location[0]
        y = enemy_start_location[1]

        x += ((random.randrange(-20, 20)) / 100) * enemy_start_location[0]
        y += ((random.randrange(-20, 20)) / 100) * enemy_start_location[1]

        if x < 0:
            x = 0
        if y < 0:
            y = 0
        if x > self.game_info.map_size[0]:
            x = self.game_info.map_size[0]
        if y > self.game_info.map_size[1]:
            y = self.game_info.map_size[1]

        go_to = position.Point2(position.Pointlike((x, y)))
        return go_to

    #侦察兵
    async def scout(self):
        #有则行动
        if len(self.units(UnitTypeId.OBSERVER)) > 0:
            scout = self.units(UnitTypeId.OBSERVER)[0]
            #闲置的侦察兵
            if scout.is_idle:
                enemy_location = self.enemy_start_locations[0]
                #侦察敌人出生地附近的位置
                move_to = self.random_location_variance(enemy_location)
                await self.do(scout.move(move_to))
        #没有则建造
        else:
            for rf in self.units(UnitTypeId.ROBOTICSFACILITY).ready.noqueue:
                if self.can_afford(UnitTypeId.OBSERVER) and self.supply_left > 0:
                    await self.do(rf.train(UnitTypeId.OBSERVER))

现阶段代码

import sc2
from sc2 import run_game, maps, Race, Difficulty,position            #导入了运行游戏、地图、种族、难度、位置
from sc2.player import Bot, Computer      #Bot是将要编写的AI，Computer是对战的电脑
from sc2.constants import UnitTypeId
import random
import cv2
import numpy as np

"""
创建机器人类，继承自sc2.BotAI
"""
class SentBot(sc2.BotAI):
    #初始化
    def __init__(self):
        #每分钟迭代数
        self.ITERATIONS_PER_MINUTE = 165
        #定义最大工人数
        self.MAX_WORKERS = 50


    #用async异步就不需要等待每一个完成再做其他事
    async def on_step(self, iteration):
        #记录已经迭代的次数
        self.iteration = iteration
        #侦察兵
        await  self.scout()
        #每一步做什么
        await self.distribute_workers()         #父类中的方法
        #建造工人
        await self.build_workers()
        #建造水晶塔
        await self.build_pylons()
        #扩张基地
        await self.expand()
        #建造瓦斯收集器
        await self.build_assimilator()
        #建造能生产军队的建筑
        await self.build_army_buildings()
        #建造军队
        await self.build_army()
        #可视化
        await self.intel()
        #军队作战
        await self.attack_enemy()



    async def build_workers(self):
        #动态控制工人数量
        if len(self.units(UnitTypeId.PROBE)) < (len(self.units(UnitTypeId.NEXUS)) * 16) and \
            len(self.units(UnitTypeId.PROBE)) < self.MAX_WORKERS:
            #遍历全部的主基地（已经准备好的且没有队列的）
            for nexus in self.units(UnitTypeId.NEXUS).ready.noqueue:
                #如果能够支付的起工人
                if self.can_afford(UnitTypeId.PROBE):
                    #让该目标制造一个工人
                    await self.do(nexus.train(UnitTypeId.PROBE))


    async def build_pylons(self):
        #如果人口上限 - 当前人口 < 5 并且当前没有正在建造的水晶塔
        if self.supply_left < 5 and not self.already_pending(UnitTypeId.PYLON):
            #找到已经建好的主基地
            nexuses = self.units(UnitTypeId.NEXUS).ready
            #如果主基地存在
            if nexuses.exists:
                #如果能够支付的起水晶塔
                if self.can_afford(UnitTypeId.PYLON):
                    #在主基地附近建造水晶塔
                    await self.build(UnitTypeId.PYLON, near=nexuses.first)


    async def expand(self):
        #如果基地总数小于n且能够支付的起基地建造的费用
        if self.units(UnitTypeId.NEXUS).amount < (self.iteration / self.ITERATIONS_PER_MINUTE) and \
                self.can_afford(UnitTypeId.NEXUS):
            #父类扩张基地方法
            await self.expand_now()


    async def build_assimilator(self):
        #遍历所有已经建好的主基地
        for nexus in self.units(UnitTypeId.NEXUS).ready:
            #定义所有离该主基地25个单元格的瓦斯间歇泉
            vespenes = self.state.vespene_geyser.closer_than(15.0, nexus)
            for vespene in vespenes:
                #如果支付不起则退出
                if not self.can_afford(UnitTypeId.ASSIMILATOR):
                    break
                #否则就在瓦斯泉的附近选一个工人
                worker = self.select_build_worker(vespene.position)
                #如果没有工人则退出
                if not worker:
                    break
                #如果瓦斯间歇泉上面没有瓦斯收集器就建一个瓦斯收集器
                if not self.units(UnitTypeId.ASSIMILATOR).closer_than(1.0, vespene).exists:
                    await self.do(worker.build(UnitTypeId.ASSIMILATOR, vespene))


    async def build_army_buildings(self):
        #首先需要找到水晶塔
        if self.units(UnitTypeId.PYLON).ready.exists:
            #如果有水晶塔，则选择一个随机的水晶塔
            pylon = self.units(UnitTypeId.PYLON).ready.random

            #如果已经存在GateWay且没有CyberneticsCore
            if self.units(UnitTypeId.GATEWAY).ready.exists and not self.units(UnitTypeId.CYBERNETICSCORE):
                #如果能支付的起且没有正在建造中的，则建造CyberneticsCore
                if self.can_afford(UnitTypeId.CYBERNETICSCORE) and not self.already_pending(UnitTypeId.CYBERNETICSCORE):
                    await self.build(UnitTypeId.CYBERNETICSCORE, near=pylon)

            #如果gateway的数量小于1
            elif len(self.units(UnitTypeId.GATEWAY)) < 1:
                #且能够支付得起，而且没有正在建造中的，则建造
                if self.can_afford(UnitTypeId.GATEWAY) and not self.already_pending(UnitTypeId.GATEWAY):
                    await self.build(UnitTypeId.GATEWAY, near=pylon)

            #如果有了控制核心，则建立Stargate
            if self.units(UnitTypeId.CYBERNETICSCORE).ready.exists:
                #数量小于分钟数/2
                if len(self.units(UnitTypeId.STARGATE)) < (self.iteration / self.ITERATIONS_PER_MINUTE):
                    # 且能够支付得起，而且没有正在建造中的，则建造
                    if self.can_afford(UnitTypeId.STARGATE) and not self.already_pending(UnitTypeId.STARGATE):
                        await self.build(UnitTypeId.STARGATE, near=pylon)

            # 如果有了控制核心，则建造侦察兵基地
            if self.units(UnitTypeId.CYBERNETICSCORE).ready.exists:
                #数量小于1
                if len(self.units(UnitTypeId.ROBOTICSFACILITY)) < 1:
                    if self.can_afford(UnitTypeId.ROBOTICSFACILITY) and not self.already_pending(UnitTypeId.ROBOTICSFACILITY):
                        await self.build(UnitTypeId.ROBOTICSFACILITY, near=pylon)


    #侦察兵
    async def scout(self):
        #有则行动
        if len(self.units(UnitTypeId.OBSERVER)) > 0:
            scout = self.units(UnitTypeId.OBSERVER)[0]
            #闲置的侦察兵
            if scout.is_idle:
                enemy_location = self.enemy_start_locations[0]
                #侦察敌人出生地附近的位置
                move_to = self.random_location_variance(enemy_location)
                await self.do(scout.move(move_to))
        #没有则建造
        else:
            for rf in self.units(UnitTypeId.ROBOTICSFACILITY).ready.noqueue:
                if self.can_afford(UnitTypeId.OBSERVER) and self.supply_left > 0:
                    await self.do(rf.train(UnitTypeId.OBSERVER))


    async def build_army(self):
        #空军
        for sg in self.units(UnitTypeId.STARGATE).ready.noqueue:
            if self.can_afford(UnitTypeId.VOIDRAY) and self.supply_left > 0:
                await self.do(sg.train(UnitTypeId.VOIDRAY))


    async def attack_enemy(self):
        #[0：进攻， 1：防守]
        army_types = {UnitTypeId.VOIDRAY: [8, 3]}
        for UNIT in army_types:
            if self.units(UNIT).amount > army_types[UNIT][0]:
                for s in self.units(UNIT).idle:
                    await self.do(s.attack(self.find_target()))

            elif self.units(UNIT).amount > army_types[UNIT][1]:
                if len(self.known_enemy_units) > 0:
                    for s in self.units(UNIT).idle:
                        await self.do(s.attack(random.choice(self.known_enemy_units)))



    def find_target(self):
        #如果发现了敌方单位
        if len(self.known_enemy_units) > 0:
            return random.choice(self.known_enemy_units)
        # 如果发现了敌方建筑
        elif len(self.known_enemy_structures) > 0:
            return random.choice(self.known_enemy_structures)
        #什么都没发现直接去敌方出生点
        else:
            return self.enemy_start_locations[0]


    def random_location_variance(self, enemy_start_location):
        x = enemy_start_location[0]
        y = enemy_start_location[1]

        x += ((random.randrange(-20, 20)) / 100) * enemy_start_location[0]
        y += ((random.randrange(-20, 20)) / 100) * enemy_start_location[1]

        if x < 0:
            x = 0
        if y < 0:
            y = 0
        if x > self.game_info.map_size[0]:
            x = self.game_info.map_size[0]
        if y > self.game_info.map_size[1]:
            y = self.game_info.map_size[1]

        go_to = position.Point2(position.Pointlike((x, y)))
        return go_to


    """攻击之前执行此操作"""
    async def intel(self):
        #200 176 3  按行绘制RGB（200个矩阵）
        game_data = np.zeros((self.game_info.map_size[1], self.game_info.map_size[0], 3), np.uint8)

        #绘制己方所有单元
        draw_dict = {
                     UnitTypeId.NEXUS: [15, (0, 255, 0)],
                     UnitTypeId.PYLON: [3, (20, 235, 0)],
                     UnitTypeId.PROBE: [1, (55, 200, 0)],
                     UnitTypeId.ASSIMILATOR: [2, (55, 200, 0)],
                     UnitTypeId.GATEWAY: [3, (200, 100, 0)],
                     UnitTypeId.CYBERNETICSCORE: [3, (150, 150, 0)],
                     UnitTypeId.STARGATE: [5, (255, 0, 0)],
                     UnitTypeId.VOIDRAY: [3, (255, 100, 0)],
                     UnitTypeId.OBSERVER: [1, (255, 255, 255)],
                     UnitTypeId.ROBOTICSFACILITY: [5, (215, 155, 0)],
                    }
        for unit in draw_dict:
            for n in self.units(unit).ready:
                n_pos = n.position
                cv2.circle(game_data, (int(n_pos[0]), int(n_pos[1])), draw_dict[unit][0], draw_dict[unit][1], -1)

        #绘制敌方的单元
        #建筑
        main_base_names = ["nexus", "commandcenter", "hatchery"]
        for enemy_building in self.known_enemy_structures:
            pos = enemy_building.position
            #非主基地
            if enemy_building.name.lower() not in main_base_names:
                cv2.circle(game_data, (int(pos[0]), int(pos[1])), 5, (200, 50, 212), -1)
        for enemy_building in self.known_enemy_structures:
            pos = enemy_building.position
            #主基地
            if enemy_building.name.lower() in main_base_names:
                cv2.circle(game_data, (int(pos[0]), int(pos[1])), 15, (0, 0, 255), -1)
        #敌方单位
        for enemy_unit in self.known_enemy_units:
            if not enemy_unit.is_structure:
                worker_names = ["probe",
                                "scv",
                                "drone"]
                pos = enemy_unit.position
                #工人
                if enemy_unit.name.lower() in worker_names:
                    cv2.circle(game_data, (int(pos[0]), int(pos[1])), 1, (55, 0, 155), -1)
                #军队
                else:
                    cv2.circle(game_data, (int(pos[0]), int(pos[1])), 3, (50, 0, 215), -1)

        #图像垂直翻转
        flipped = cv2.flip(game_data, 0)
        #调整图像大小，原图像，输出图像所需大小，比例因子
        resized = cv2.resize(flipped, dsize=None, fx=2, fy=2)

        cv2.imshow("Intel", resized)
        cv2.waitKey(1)




"""
运行游戏，选择地图，自定义选手(AI vs computer) or (AI vs AI), 是否实时运行
"""
run_game(maps.get("AbyssalReefLE"), [Bot(Race.Protoss, SentBot()), Computer(Race.Terran, Difficulty.Hard)], realtime = True)

9.建立训练数据

加入其他数据的可视化

绘制数据线

#其他数据的可视化
        line_max = 50
        #矿物数量/1500
        mineral_ratio = self.minerals / 1500
        if mineral_ratio > 1.0:
            mineral_ratio = 1.0
        #瓦斯气的数量/1500
        vespene_ratio = self.vespene / 1500
        if vespene_ratio > 1.0:
            vespene_ratio = 1.0
        #可用人口比例
        population_ratio = self.supply_left / self.supply_cap
        if population_ratio > 1.0:
            population_ratio = 1.0
        #人口上限数/200
        plausible_supply = self.supply_cap / 200.0
        #voidray占全部人口的比例
        military_weight = len(self.units(UnitTypeId.VOIDRAY)) / (self.supply_cap - self.supply_left)
        if military_weight > 1.0:
            military_weight = 1.0
        #绘制数据线line（图片， 起点， 终点， RGB， 粗细）
        # voidray占全部人口的比例
        cv2.line(game_data, (0, 19), (int(line_max * military_weight), 19), (250, 250, 200), 3)
        # 人口上限数/200
        cv2.line(game_data, (0, 15), (int(line_max * plausible_supply), 15), (220, 200, 200), 3)
        # 可用人口比例
        cv2.line(game_data, (0, 11), (int(line_max * population_ratio), 11), (150, 150, 150), 3)
        # 瓦斯气的数量/1500
        cv2.line(game_data, (0, 7), (int(line_max * vespene_ratio), 7), (210, 200, 0), 3)
        # 矿物数量/1500
        cv2.line(game_data, (0, 3), (int(line_max * mineral_ratio), 3), (0, 255, 25), 3)

变更攻击方法

首先添加两个变量

class SentBot(sc2.BotAI):
    #初始化
    def __init__(self):
        #每分钟迭代数
        self.ITERATIONS_PER_MINUTE = 165
        #定义最大工人数
        self.MAX_WORKERS = 50
        #记录上一次迭代数
        self.do_something_after = 0
        #训练数据
        self.train_data = []

将攻击方法改为随机决策

   async def attack_enemy(self):
        #如果voidray有闲置的
        if len(self.units(UnitTypeId.VOIDRAY).idle) > 0:
            #随机一种决策
            choice = random.randrange(0, 4)
            #定义目标
            target = False
            #如果迭代数大于上一次的迭代数
            if self.iteration > self.do_something_after:
                #不攻击，等待20-165个迭代
                if choice == 0:
                    wait = random.randrange(20, 165)
                    self.do_something_after = self.iteration + wait
                #攻击离家最近的敌方单位
                elif choice == 1:
                    if len(self.known_enemy_units) > 0:
                        target = self.known_enemy_units.closest_to(random.choice(self.units(UnitTypeId.NEXUS)))
                #攻击敌方建筑物
                elif choice == 2:
                    if len(self.known_enemy_structures) > 0:
                        target = random.choice(self.known_enemy_structures)
                #攻击敌方出生地
                elif choice == 3:
                    target = self.enemy_start_locations[0]
                #如果目标不为空，则让所有闲置的voidray做该决策
                if target:
                    for vr in self.units(UnitTypeId.VOIDRAY).idle:
                        await self.do(vr.attack(target))
                #每次做出决策，就将其连同当前可视化信息添加到训练集中，列如[(1，0，0，0),(...)]
                y = np.zeros(4)
                y[choice] = 1
                print(y)
                self.train_data.append([y, self.flipped])

设置是否要可视化，添加

#类外添加
HEADLESS = False

...
		#图像垂直翻转
        self.flipped = cv2.flip(game_data, 0)
        #是否可视化
        if not HEADLESS:
            # 调整图像大小，原图像，输出图像所需大小，比例因子
            resized = cv2.resize(self.flipped, dsize=None, fx=2, fy=2)
            cv2.imshow("Intel", resized)
            cv2.waitKey(1)

只需要记录胜利的数据，因此添加on_end方法

    #结束
    def on_end(self, game_result: Result):
        print("!!!!!!game over!!!!!!")
        print(game_result)
        if game_result == Result.Victory:
            np.save("train_data/{}.npy".format(str(int(time.time()))), np.array(self.train_data))

现阶段全部代码

import sc2
from sc2 import run_game, maps, Race, Difficulty, position, Result            #导入了运行游戏、地图、种族、难度、位置、结果
from sc2.player import Bot, Computer      #Bot是将要编写的AI，Computer是对战的电脑
from sc2.constants import UnitTypeId
import random
import cv2
import numpy as np
import time


HEADLESS = False



"""
创建机器人类，继承自sc2.BotAI
"""
class SentBot(sc2.BotAI):
    #初始化
    def __init__(self):
        #每分钟迭代数
        self.ITERATIONS_PER_MINUTE = 165
        #定义最大工人数
        self.MAX_WORKERS = 50
        #记录上一次迭代数
        self.do_something_after = 0
        #训练数据
        self.train_data = []

    #结束
    def on_end(self, game_result: Result):
        if game_result == Result.Victory:
            np.save("train_data/{}.npy".format(str(int(time.time()))), np.array(self.train_data))
        print("!!!!!!game over!!!!!!")
        print(game_result)


    #用async异步就不需要等待每一个完成再做其他事
    async def on_step(self, iteration):
        #记录已经迭代的次数
        self.iteration = iteration
        #侦察兵
        await  self.scout()
        #每一步做什么
        await self.distribute_workers()         #父类中的方法
        #建造工人
        await self.build_workers()
        #建造水晶塔
        await self.build_pylons()
        #扩张基地
        await self.expand()
        #建造瓦斯收集器
        await self.build_assimilator()
        #建造能生产军队的建筑
        await self.build_army_buildings()
        #建造军队
        await self.build_army()
        #可视化
        await self.intel()
        #军队作战
        await self.attack_enemy()



    async def build_workers(self):
        #动态控制工人数量
        if len(self.units(UnitTypeId.PROBE)) < (len(self.units(UnitTypeId.NEXUS)) * 16) and \
            len(self.units(UnitTypeId.PROBE)) < self.MAX_WORKERS:
            #遍历全部的主基地（已经准备好的且没有队列的）
            for nexus in self.units(UnitTypeId.NEXUS).ready.noqueue:
                #如果能够支付的起工人
                if self.can_afford(UnitTypeId.PROBE):
                    #让该目标制造一个工人
                    await self.do(nexus.train(UnitTypeId.PROBE))


    async def build_pylons(self):
        #如果人口上限 - 当前人口 < 5 并且当前没有正在建造的水晶塔
        if self.supply_left < 5 and not self.already_pending(UnitTypeId.PYLON):
            #找到已经建好的主基地
            nexuses = self.units(UnitTypeId.NEXUS).ready
            #如果主基地存在
            if nexuses.exists:
                #如果能够支付的起水晶塔
                if self.can_afford(UnitTypeId.PYLON):
                    #在主基地附近建造水晶塔
                    await self.build(UnitTypeId.PYLON, near=nexuses.first)


    async def expand(self):
        #如果基地总数小于n且能够支付的起基地建造的费用
        if self.units(UnitTypeId.NEXUS).amount < (self.iteration / self.ITERATIONS_PER_MINUTE) and \
                self.can_afford(UnitTypeId.NEXUS):
            #父类扩张基地方法
            await self.expand_now()


    async def build_assimilator(self):
        #遍历所有已经建好的主基地
        for nexus in self.units(UnitTypeId.NEXUS).ready:
            #定义所有离该主基地25个单元格的瓦斯间歇泉
            vespenes = self.state.vespene_geyser.closer_than(15.0, nexus)
            for vespene in vespenes:
                #如果支付不起则退出
                if not self.can_afford(UnitTypeId.ASSIMILATOR):
                    break
                #否则就在瓦斯泉的附近选一个工人
                worker = self.select_build_worker(vespene.position)
                #如果没有工人则退出
                if not worker:
                    break
                #如果瓦斯间歇泉上面没有瓦斯收集器就建一个瓦斯收集器
                if not self.units(UnitTypeId.ASSIMILATOR).closer_than(1.0, vespene).exists:
                    await self.do(worker.build(UnitTypeId.ASSIMILATOR, vespene))


    async def build_army_buildings(self):
        #首先需要找到水晶塔
        if self.units(UnitTypeId.PYLON).ready.exists:
            #如果有水晶塔，则选择一个随机的水晶塔
            pylon = self.units(UnitTypeId.PYLON).ready.random

            #如果已经存在GateWay且没有CyberneticsCore
            if self.units(UnitTypeId.GATEWAY).ready.exists and not self.units(UnitTypeId.CYBERNETICSCORE):
                #如果能支付的起且没有正在建造中的，则建造CyberneticsCore
                if self.can_afford(UnitTypeId.CYBERNETICSCORE) and not self.already_pending(UnitTypeId.CYBERNETICSCORE):
                    await self.build(UnitTypeId.CYBERNETICSCORE, near=pylon)

            #如果gateway的数量小于1
            elif len(self.units(UnitTypeId.GATEWAY)) < 1:
                #且能够支付得起，而且没有正在建造中的，则建造
                if self.can_afford(UnitTypeId.GATEWAY) and not self.already_pending(UnitTypeId.GATEWAY):
                    await self.build(UnitTypeId.GATEWAY, near=pylon)

            #如果有了控制核心，则建立Stargate
            if self.units(UnitTypeId.CYBERNETICSCORE).ready.exists:
                #数量小于分钟数/2
                if len(self.units(UnitTypeId.STARGATE)) < (self.iteration / self.ITERATIONS_PER_MINUTE):
                    # 且能够支付得起，而且没有正在建造中的，则建造
                    if self.can_afford(UnitTypeId.STARGATE) and not self.already_pending(UnitTypeId.STARGATE):
                        await self.build(UnitTypeId.STARGATE, near=pylon)

            # 如果有了控制核心，则建造侦察兵基地
            if self.units(UnitTypeId.CYBERNETICSCORE).ready.exists:
                #数量小于1
                if len(self.units(UnitTypeId.ROBOTICSFACILITY)) < 1:
                    if self.can_afford(UnitTypeId.ROBOTICSFACILITY) and not self.already_pending(UnitTypeId.ROBOTICSFACILITY):
                        await self.build(UnitTypeId.ROBOTICSFACILITY, near=pylon)


    #侦察兵
    async def scout(self):
        #有则行动
        if len(self.units(UnitTypeId.OBSERVER)) > 0:
            scout = self.units(UnitTypeId.OBSERVER)[0]
            #闲置的侦察兵
            if scout.is_idle:
                enemy_location = self.enemy_start_locations[0]
                #侦察敌人出生地附近的位置
                move_to = self.random_location_variance(enemy_location)
                await self.do(scout.move(move_to))
        #没有则建造
        else:
            for rf in self.units(UnitTypeId.ROBOTICSFACILITY).ready.noqueue:
                if self.can_afford(UnitTypeId.OBSERVER) and self.supply_left > 0:
                    await self.do(rf.train(UnitTypeId.OBSERVER))


    async def build_army(self):
        #空军
        for sg in self.units(UnitTypeId.STARGATE).ready.noqueue:
            if self.can_afford(UnitTypeId.VOIDRAY) and self.supply_left > 0:
                await self.do(sg.train(UnitTypeId.VOIDRAY))


    async def attack_enemy(self):
        #如果voidray有闲置的
        if len(self.units(UnitTypeId.VOIDRAY).idle) > 0:
            #随机一种决策
            choice = random.randrange(0, 4)
            #定义目标
            target = False
            #如果迭代数大于上一次的迭代数
            if self.iteration > self.do_something_after:
                #不攻击，等待20-165个迭代
                if choice == 0:
                    wait = random.randrange(20, 165)
                    self.do_something_after = self.iteration + wait
                #攻击离家最近的敌方单位
                elif choice == 1:
                    if len(self.known_enemy_units) > 0:
                        target = self.known_enemy_units.closest_to(random.choice(self.units(UnitTypeId.NEXUS)))
                #攻击敌方建筑物
                elif choice == 2:
                    if len(self.known_enemy_structures) > 0:
                        target = random.choice(self.known_enemy_structures)
                #攻击敌方出生地
                elif choice == 3:
                    target = self.enemy_start_locations[0]
                #如果目标不为空，则让所有闲置的voidray做该决策
                if target:
                    for vr in self.units(UnitTypeId.VOIDRAY).idle:
                        await self.do(vr.attack(target))
                #每次做出决策，就将其连同当前可视化信息添加到训练集中，列如[(1，0，0，0),(...)]
                y = np.zeros(4)
                y[choice] = 1
                print(y)
                self.train_data.append([y, self.flipped])




    def find_target(self):
        #如果发现了敌方单位
        if len(self.known_enemy_units) > 0:
            return random.choice(self.known_enemy_units)
        # 如果发现了敌方建筑
        elif len(self.known_enemy_structures) > 0:
            return random.choice(self.known_enemy_structures)
        #什么都没发现直接去敌方出生点
        else:
            return self.enemy_start_locations[0]


    #目标附近的随机位置
    def random_location_variance(self, enemy_start_location):
        x = enemy_start_location[0]
        y = enemy_start_location[1]

        x += ((random.randrange(-20, 20)) / 100) * enemy_start_location[0]
        y += ((random.randrange(-20, 20)) / 100) * enemy_start_location[1]

        if x < 0:
            x = 0
        if y < 0:
            y = 0
        if x > self.game_info.map_size[0]:
            x = self.game_info.map_size[0]
        if y > self.game_info.map_size[1]:
            y = self.game_info.map_size[1]

        go_to = position.Point2(position.Pointlike((x, y)))
        return go_to


    """攻击之前执行此操作"""
    async def intel(self):
        #200 176 3  按行绘制RGB（200个矩阵）
        game_data = np.zeros((self.game_info.map_size[1], self.game_info.map_size[0], 3), np.uint8)

        #绘制己方所有单元
        draw_dict = {
                     UnitTypeId.NEXUS: [15, (0, 255, 0)],
                     UnitTypeId.PYLON: [3, (20, 235, 0)],
                     UnitTypeId.PROBE: [1, (55, 200, 0)],
                     UnitTypeId.ASSIMILATOR: [2, (55, 200, 0)],
                     UnitTypeId.GATEWAY: [3, (200, 100, 0)],
                     UnitTypeId.CYBERNETICSCORE: [3, (150, 150, 0)],
                     UnitTypeId.STARGATE: [5, (255, 0, 0)],
                     UnitTypeId.VOIDRAY: [3, (255, 100, 0)],
                     UnitTypeId.OBSERVER: [1, (255, 255, 255)],
                     UnitTypeId.ROBOTICSFACILITY: [5, (215, 155, 0)],
                    }
        for unit in draw_dict:
            for n in self.units(unit).ready:
                n_pos = n.position
                cv2.circle(game_data, (int(n_pos[0]), int(n_pos[1])), draw_dict[unit][0], draw_dict[unit][1], -1)

        #绘制敌方的单元
        #建筑
        main_base_names = ["nexus", "commandcenter", "hatchery"]
        for enemy_building in self.known_enemy_structures:
            pos = enemy_building.position
            #非主基地
            if enemy_building.name.lower() not in main_base_names:
                cv2.circle(game_data, (int(pos[0]), int(pos[1])), 5, (200, 50, 212), -1)
        for enemy_building in self.known_enemy_structures:
            pos = enemy_building.position
            #主基地
            if enemy_building.name.lower() in main_base_names:
                cv2.circle(game_data, (int(pos[0]), int(pos[1])), 15, (0, 0, 255), -1)
        #敌方单位
        for enemy_unit in self.known_enemy_units:
            if not enemy_unit.is_structure:
                worker_names = ["probe",
                                "scv",
                                "drone"]
                pos = enemy_unit.position
                #工人
                if enemy_unit.name.lower() in worker_names:
                    cv2.circle(game_data, (int(pos[0]), int(pos[1])), 1, (55, 0, 155), -1)
                #军队
                else:
                    cv2.circle(game_data, (int(pos[0]), int(pos[1])), 3, (50, 0, 215), -1)

        #其他数据的可视化
        line_max = 50
        #矿物数量/1500
        mineral_ratio = self.minerals / 1500
        if mineral_ratio > 1.0:
            mineral_ratio = 1.0
        #瓦斯气的数量/1500
        vespene_ratio = self.vespene / 1500
        if vespene_ratio > 1.0:
            vespene_ratio = 1.0
        #可用人口比例
        population_ratio = self.supply_left / self.supply_cap
        if population_ratio > 1.0:
            population_ratio = 1.0
        #人口上限数/200
        plausible_supply = self.supply_cap / 200.0
        #voidray占全部人口的比例
        military_weight = len(self.units(UnitTypeId.VOIDRAY)) / (self.supply_cap - self.supply_left)
        if military_weight > 1.0:
            military_weight = 1.0
        #绘制数据线line（图片， 起点， 终点， RGB， 粗细）
        # voidray占全部人口的比例
        cv2.line(game_data, (0, 19), (int(line_max * military_weight), 19), (250, 250, 200), 3)
        # 人口上限数/200
        cv2.line(game_data, (0, 15), (int(line_max * plausible_supply), 15), (220, 200, 200), 3)
        # 可用人口比例
        cv2.line(game_data, (0, 11), (int(line_max * population_ratio), 11), (150, 150, 150), 3)
        # 瓦斯气的数量/1500
        cv2.line(game_data, (0, 7), (int(line_max * vespene_ratio), 7), (210, 200, 0), 3)
        # 矿物数量/1500
        cv2.line(game_data, (0, 3), (int(line_max * mineral_ratio), 3), (0, 255, 25), 3)

        #图像垂直翻转
        self.flipped = cv2.flip(game_data, 0)
        #是否可视化
        if not HEADLESS:
            # 调整图像大小，原图像，输出图像所需大小，比例因子
            resized = cv2.resize(self.flipped, dsize=None, fx=2, fy=2)
            cv2.imshow("Intel", resized)
            cv2.waitKey(1)




"""
运行游戏，选择地图，自定义选手(AI vs computer) or (AI vs AI), 是否实时运行
"""
run_game(maps.get("AbyssalReefLE"),
         [Bot(Race.Protoss, SentBot()), Computer(Race.Terran, Difficulty.Easy)],
         realtime=False)


如果游戏胜利，则可以看到记录了一条数据
Python深度学习SC2(星际争霸2)AI_第10张图片
也可以查看其内容：
Python深度学习SC2(星际争霸2)AI_第11张图片

10.建立神经网络模型

安装tensorflow-gpu、keras

import keras
from keras.models import Sequential                         #导入顺序模型
from keras.layers import Dense, Dropout, Flatten            #导入全连接层、输入丢弃、输入展平
from keras.layers import Conv2D, MaxPooling2D               #导入2D卷积层、2D空间最大池化
from keras.callbacks import TensorBoard                     #基本可视化
import numpy as np
import os
import random

#建立模型
model = Sequential()

#隐藏卷积层
model.add(Conv2D(32, (3, 3), padding="same", input_shape=(176, 200, 3), activation="relu"))
model.add(Conv2D(32, (3, 3), activation="relu"))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.2))

model.add(Conv2D(64, (3, 3), padding="same", activation="relu"))
model.add(Conv2D(64, (3, 3), activation="relu"))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.2))

model.add(Conv2D(128, (3, 3), padding='same', activation='relu'))
model.add(Conv2D(128, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.2))

#完全连接的密集层
model.add(Flatten())
model.add(Dense(512, activation="relu"))
model.add(Dropout(0.5))

#输出层
model.add(Dense(4, activation="softmax"))

#设置神经网络编译配置
#学习率1e-4
learning_rate = 0.0001
#优化器
opt = keras.optimizers.adam(lr=learning_rate, decay=1e-6)

model.compile(loss='categorical_crossentropy',
              optimizer=opt,
              metrics=['accuracy'])
#通过TensorBoard记录
tensorboard = TensorBoard(log_dir="logs/stage1")

11.训练神经网络模型

不支持gpu版本的也可以用cpu

import keras
from keras.models import Sequential                         #导入顺序模型
from keras.layers import Dense, Dropout, Flatten            #导入全连接层、输入丢弃、输入展平
from keras.layers import Conv2D, MaxPooling2D               #导入2D卷积层、2D空间最大池化
from keras.callbacks import TensorBoard                     #基本可视化
import numpy as np
import os
import random

"""建立模型"""
model = Sequential()

#隐藏卷积层
model.add(Conv2D(32, (3, 3), padding="same", input_shape=(176, 200, 3), activation="relu"))
model.add(Conv2D(32, (3, 3), activation="relu"))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.2))

model.add(Conv2D(64, (3, 3), padding="same", activation="relu"))
model.add(Conv2D(64, (3, 3), activation="relu"))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.2))

model.add(Conv2D(128, (3, 3), padding='same', activation='relu'))
model.add(Conv2D(128, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.2))

#完全连接的密集层
model.add(Flatten())
model.add(Dense(512, activation="relu"))
model.add(Dropout(0.5))

#输出层
model.add(Dense(4, activation="softmax"))

#设置神经网络编译配置
#学习率1e-4
learning_rate = 0.0001
#优化器
opt = keras.optimizers.Adam(lr=learning_rate, decay=1e-6)

model.compile(loss='categorical_crossentropy',
              optimizer=opt,
              metrics=['accuracy'])
#通过TensorBoard记录
tensorboard = TensorBoard(log_dir="logs/stage1")





"""训练模型"""
#训练数据存放的文件夹
train_data_dir = "Train_data"

#世代数
epochs = 10




"""平衡数据的长度"""
def check_data():
    choices = {"no_attacks" : no_attacks,
               "attack_closest_to_nexus" : attack_closest_to_nexus,
               "attack_enemy_structures" : attack_enemy_structures,
               "attack_enemy_start" : attack_enemy_start}

    total_data = 0
    lengths = []
    #统计每种决策的长度
    for choice in choices:
        print("Length of {} is: {}".format(choice, len(choices[choice])))
        total_data += len(choices[choice])
        lengths.append(len(choices[choice]))
    print("Total data length now is:", total_data)
    return lengths




for i in range(epochs):
    current = 0
    increment = 200         #一次200增量,每次读200个文件
    not_maximum = True
    #加载所有文件
    all_files = os.listdir(train_data_dir)
    maximum = len(all_files)
    #将文件随机排序
    random.shuffle(all_files)

    while not_maximum:
        print("Working On {} : {}".format(current, current + increment))
        no_attacks = []
        attack_closest_to_nexus = []
        attack_enemy_structures = []
        attack_enemy_start = []

        for file in all_files[current: current + increment]:
            #完整路径
            full_path = os.path.join(train_data_dir, file)
            #data = 一局游戏的数据
            data = np.load(full_path, allow_pickle=True)
            data = list(data)
            #一次进攻
            for d in data:
                #得到最大数坐标，列如：
                """
                [0. 1. 0. 0.]
                1
                [0. 0. 1. 0.]
                2
                """
                choice = np.argmax(d[0])
                if choice == 0:
                    no_attacks.append([d[0], d[1]])
                elif choice == 1:
                    attack_closest_to_nexus.append([d[0], d[1]])
                elif choice == 2:
                    attack_enemy_structures.append([d[0], d[1]])
                elif choice == 3:
                    attack_enemy_start.append([d[0], d[1]])

        #取得四种决策数量的列表，如[29, 65, 84, 77]
        lengths = check_data()
        # 得到了四种决策中的最小数量
        lowest_data = min(lengths)

        #将列表元素重新排序
        random.shuffle(no_attacks)
        random.shuffle(attack_closest_to_nexus)
        random.shuffle(attack_enemy_structures)
        random.shuffle(attack_enemy_start)

        #使数据的数据量相同
        no_attacks = no_attacks[:lowest_data]
        attack_closest_to_nexus = attack_closest_to_nexus[:lowest_data]
        attack_enemy_structures = attack_enemy_structures[:lowest_data]
        attack_enemy_start = attack_enemy_start[:lowest_data]

        #重新统计
        check_data()

        #将所有决策加入更大的列表中
        train_data = no_attacks + attack_closest_to_nexus + attack_enemy_structures + attack_enemy_start
        #将其中所有元素重新排序
        random.shuffle(train_data)
        #print(train_data)

        #保留100个样本进行验证
        test_size = 100
        #分批训练的样本数
        batch_size = 128

        #调整输入数据，x=game_data, y=决策表
        #剔除验证样本
        x_train = np.array([i[1] for i in train_data[:-test_size]]).reshape(-1, 176, 200, 3)
        y_train = np.array([i[0] for i in train_data[:-test_size]])
        #验证样本
        x_test = np.array([i[1] for i in train_data[-test_size:]]).reshape(-1, 176, 200, 3)
        y_test = np.array([i[0] for i in train_data[-test_size:]])

        #开始拟合数据
        model.fit(x_train, y_train,
                  batch_size=batch_size,
                  validation_data=(x_test, y_test),
                  shuffle=True,
                  verbose=1, callbacks=[tensorboard])

        #保存模型并继续迭代：
        model.save("BasicCNN-{}-epochs-{}-LR-STAGE1".format(epochs, learning_rate))
        current += increment
        if current > maximum:
            not_maximum = False

12.使用神经网络模型

import sc2
from sc2 import run_game, maps, Race, Difficulty, position, Result            #导入了运行游戏、地图、种族、难度、位置、结果
from sc2.player import Bot, Computer      #Bot是将要编写的AI，Computer是对战的电脑
from sc2.constants import UnitTypeId
import random
import cv2
import numpy as np
import time
import os
import keras


HEADLESS = False



"""
创建机器人类，继承自sc2.BotAI
"""
class SentBot(sc2.BotAI):
    #初始化
    def __init__(self, use_model=False):
        #每分钟迭代数
        self.ITERATIONS_PER_MINUTE = 165
        #定义最大工人数
        self.MAX_WORKERS = 50
        #记录上一次迭代数
        self.do_something_after = 0
        #训练数据
        self.train_data = []
        #是否使用模型
        self.use_model = use_model
        #导入模型
        if self.use_model:
            print("use model")
            self.model = keras.models.load_model("BasicCNN-1-epochs-0.0001-LR-STAGE1")


    #结束
    def on_end(self, game_result: Result):
        # if game_result == Result.Victory:
        #     np.save("train_data/{}.npy".format(str(int(time.time()))), np.array(self.train_data))
        print("!!!!!!game over!!!!!!")
        print(game_result, self.use_model)

        with open("gameout-random-vs-medium.txt", "a") as f:
            if self.use_model:
                f.write("Model {}\n".format(game_result))
            else:
                f.write("Random {}\n".format(game_result))


    #用async异步就不需要等待每一个完成再做其他事
    async def on_step(self, iteration):
        #记录已经迭代的次数
        self.iteration = iteration
        #侦察兵
        await  self.scout()
        #每一步做什么
        await self.distribute_workers()         #父类中的方法
        #建造工人
        await self.build_workers()
        #建造水晶塔
        await self.build_pylons()
        #扩张基地
        await self.expand()
        #建造瓦斯收集器
        await self.build_assimilator()
        #建造能生产军队的建筑
        await self.build_army_buildings()
        #建造军队
        await self.build_army()
        #可视化
        await self.intel()
        #军队作战
        await self.attack_enemy()



    async def build_workers(self):
        #动态控制工人数量
        if len(self.units(UnitTypeId.PROBE)) < (len(self.units(UnitTypeId.NEXUS)) * 16) and \
            len(self.units(UnitTypeId.PROBE)) < self.MAX_WORKERS:
            #遍历全部的主基地（已经准备好的且没有队列的）
            for nexus in self.units(UnitTypeId.NEXUS).ready.noqueue:
                #如果能够支付的起工人
                if self.can_afford(UnitTypeId.PROBE):
                    #让该目标制造一个工人
                    await self.do(nexus.train(UnitTypeId.PROBE))


    async def build_pylons(self):
        #如果人口上限 - 当前人口 < 5 并且当前没有正在建造的水晶塔
        if self.supply_left < 5 and not self.already_pending(UnitTypeId.PYLON):
            #找到已经建好的主基地
            nexuses = self.units(UnitTypeId.NEXUS).ready
            #如果主基地存在
            if nexuses.exists:
                #如果能够支付的起水晶塔
                if self.can_afford(UnitTypeId.PYLON):
                    #在主基地附近建造水晶塔
                    await self.build(UnitTypeId.PYLON, near=nexuses.first)


    async def expand(self):
        #如果基地总数小于n且能够支付的起基地建造的费用
        if self.units(UnitTypeId.NEXUS).amount < (self.iteration / self.ITERATIONS_PER_MINUTE) and \
                self.can_afford(UnitTypeId.NEXUS):
            #父类扩张基地方法
            await self.expand_now()


    async def build_assimilator(self):
        #遍历所有已经建好的主基地
        for nexus in self.units(UnitTypeId.NEXUS).ready:
            #定义所有离该主基地25个单元格的瓦斯间歇泉
            vespenes = self.state.vespene_geyser.closer_than(15.0, nexus)
            for vespene in vespenes:
                #如果支付不起则退出
                if not self.can_afford(UnitTypeId.ASSIMILATOR):
                    break
                #否则就在瓦斯泉的附近选一个工人
                worker = self.select_build_worker(vespene.position)
                #如果没有工人则退出
                if not worker:
                    break
                #如果瓦斯间歇泉上面没有瓦斯收集器就建一个瓦斯收集器
                if not self.units(UnitTypeId.ASSIMILATOR).closer_than(1.0, vespene).exists:
                    await self.do(worker.build(UnitTypeId.ASSIMILATOR, vespene))


    async def build_army_buildings(self):
        #首先需要找到水晶塔
        if self.units(UnitTypeId.PYLON).ready.exists:
            #如果有水晶塔，则选择一个随机的水晶塔
            pylon = self.units(UnitTypeId.PYLON).ready.random

            #如果已经存在GateWay且没有CyberneticsCore
            if self.units(UnitTypeId.GATEWAY).ready.exists and not self.units(UnitTypeId.CYBERNETICSCORE):
                #如果能支付的起且没有正在建造中的，则建造CyberneticsCore
                if self.can_afford(UnitTypeId.CYBERNETICSCORE) and not self.already_pending(UnitTypeId.CYBERNETICSCORE):
                    await self.build(UnitTypeId.CYBERNETICSCORE, near=pylon)

            #如果gateway的数量小于1
            elif len(self.units(UnitTypeId.GATEWAY)) < 1:
                #且能够支付得起，而且没有正在建造中的，则建造
                if self.can_afford(UnitTypeId.GATEWAY) and not self.already_pending(UnitTypeId.GATEWAY):
                    await self.build(UnitTypeId.GATEWAY, near=pylon)

            #如果有了控制核心，则建立Stargate
            if self.units(UnitTypeId.CYBERNETICSCORE).ready.exists:
                #数量小于分钟数/2
                if len(self.units(UnitTypeId.STARGATE)) < (self.iteration / self.ITERATIONS_PER_MINUTE):
                    # 且能够支付得起，而且没有正在建造中的，则建造
                    if self.can_afford(UnitTypeId.STARGATE) and not self.already_pending(UnitTypeId.STARGATE):
                        await self.build(UnitTypeId.STARGATE, near=pylon)

            # 如果有了控制核心，则建造侦察兵基地
            if self.units(UnitTypeId.CYBERNETICSCORE).ready.exists:
                #数量小于1
                if len(self.units(UnitTypeId.ROBOTICSFACILITY)) < 1:
                    if self.can_afford(UnitTypeId.ROBOTICSFACILITY) and not self.already_pending(UnitTypeId.ROBOTICSFACILITY):
                        await self.build(UnitTypeId.ROBOTICSFACILITY, near=pylon)


    #侦察兵
    async def scout(self):
        #有则行动
        if len(self.units(UnitTypeId.OBSERVER)) > 0:
            scout = self.units(UnitTypeId.OBSERVER)[0]
            #闲置的侦察兵
            if scout.is_idle:
                enemy_location = self.enemy_start_locations[0]
                #侦察敌人出生地附近的位置
                move_to = self.random_location_variance(enemy_location)
                await self.do(scout.move(move_to))
        #没有则建造
        else:
            for rf in self.units(UnitTypeId.ROBOTICSFACILITY).ready.noqueue:
                if self.can_afford(UnitTypeId.OBSERVER) and self.supply_left > 0:
                    await self.do(rf.train(UnitTypeId.OBSERVER))


    async def build_army(self):
        #空军
        for sg in self.units(UnitTypeId.STARGATE).ready.noqueue:
            if self.can_afford(UnitTypeId.VOIDRAY) and self.supply_left > 0:
                await self.do(sg.train(UnitTypeId.VOIDRAY))


    async def attack_enemy(self):
        #如果voidray有闲置的
        if len(self.units(UnitTypeId.VOIDRAY).idle) > 0:
            #随机一种决策
            # choice = random.randrange(0, 4)
            #定义目标
            target = False

            #如果迭代数大于上一次的迭代数
            if self.iteration > self.do_something_after:

                if self.use_model:
                    prediction = self.model.predict([self.flipped.reshape([-1, 176, 200, 3])])
                    choice = np.argmax(prediction[0])
                    # print('prediction: ',choice)

                    choice_dict = {0: "No Attack!",
                                   1: "Attack close to our nexus!",
                                   2: "Attack Enemy Structure!",
                                   3: "Attack Eneemy Start!"}

                    print("Choice #{}:{}".format(choice, choice_dict[choice]))

                else:
                    choice = random.randrange(0, 4)

                #不攻击，等待20-165个迭代
                if choice == 0:
                    wait = random.randrange(20, 165)
                    self.do_something_after = self.iteration + wait
                #攻击离家最近的敌方单位
                elif choice == 1:
                    if len(self.known_enemy_units) > 0:
                        target = self.known_enemy_units.closest_to(random.choice(self.units(UnitTypeId.NEXUS)))
                #攻击敌方建筑物
                elif choice == 2:
                    if len(self.known_enemy_structures) > 0:
                        target = random.choice(self.known_enemy_structures)
                #攻击敌方出生地
                elif choice == 3:
                    target = self.enemy_start_locations[0]
                #如果目标不为空，则让所有闲置的voidray做该决策
                if target:
                    for vr in self.units(UnitTypeId.VOIDRAY).idle:
                        await self.do(vr.attack(target))
                #每次做出决策，就将其连同当前可视化信息添加到训练集中，列如[(1，0，0，0),(...)]
                y = np.zeros(4)
                y[choice] = 1
                # print(y)
                self.train_data.append([y, self.flipped])




    def find_target(self):
        #如果发现了敌方单位
        if len(self.known_enemy_units) > 0:
            return random.choice(self.known_enemy_units)
        # 如果发现了敌方建筑
        elif len(self.known_enemy_structures) > 0:
            return random.choice(self.known_enemy_structures)
        #什么都没发现直接去敌方出生点
        else:
            return self.enemy_start_locations[0]


    #目标附近的随机位置
    def random_location_variance(self, enemy_start_location):
        x = enemy_start_location[0]
        y = enemy_start_location[1]

        x += ((random.randrange(-20, 20)) / 100) * enemy_start_location[0]
        y += ((random.randrange(-20, 20)) / 100) * enemy_start_location[1]

        if x < 0:
            x = 0
        if y < 0:
            y = 0
        if x > self.game_info.map_size[0]:
            x = self.game_info.map_size[0]
        if y > self.game_info.map_size[1]:
            y = self.game_info.map_size[1]

        go_to = position.Point2(position.Pointlike((x, y)))
        return go_to


    """攻击之前执行此操作"""
    async def intel(self):
        #200 176 3  按行绘制RGB（200个矩阵）
        game_data = np.zeros((self.game_info.map_size[1], self.game_info.map_size[0], 3), np.uint8)

        #绘制己方所有单元
        draw_dict = {
                     UnitTypeId.NEXUS: [15, (0, 255, 0)],
                     UnitTypeId.PYLON: [3, (20, 235, 0)],
                     UnitTypeId.PROBE: [1, (55, 200, 0)],
                     UnitTypeId.ASSIMILATOR: [2, (55, 200, 0)],
                     UnitTypeId.GATEWAY: [3, (200, 100, 0)],
                     UnitTypeId.CYBERNETICSCORE: [3, (150, 150, 0)],
                     UnitTypeId.STARGATE: [5, (255, 0, 0)],
                     UnitTypeId.VOIDRAY: [3, (255, 100, 0)],
                     UnitTypeId.OBSERVER: [1, (255, 255, 255)],
                     UnitTypeId.ROBOTICSFACILITY: [5, (215, 155, 0)],
                    }
        for unit in draw_dict:
            for n in self.units(unit).ready:
                n_pos = n.position
                cv2.circle(game_data, (int(n_pos[0]), int(n_pos[1])), draw_dict[unit][0], draw_dict[unit][1], -1)

        #绘制敌方的单元
        #建筑
        main_base_names = ["nexus", "commandcenter", "hatchery"]
        for enemy_building in self.known_enemy_structures:
            pos = enemy_building.position
            #非主基地
            if enemy_building.name.lower() not in main_base_names:
                cv2.circle(game_data, (int(pos[0]), int(pos[1])), 5, (200, 50, 212), -1)
        for enemy_building in self.known_enemy_structures:
            pos = enemy_building.position
            #主基地
            if enemy_building.name.lower() in main_base_names:
                cv2.circle(game_data, (int(pos[0]), int(pos[1])), 15, (0, 0, 255), -1)
        #敌方单位
        for enemy_unit in self.known_enemy_units:
            if not enemy_unit.is_structure:
                worker_names = ["probe",
                                "scv",
                                "drone"]
                pos = enemy_unit.position
                #工人
                if enemy_unit.name.lower() in worker_names:
                    cv2.circle(game_data, (int(pos[0]), int(pos[1])), 1, (55, 0, 155), -1)
                #军队
                else:
                    cv2.circle(game_data, (int(pos[0]), int(pos[1])), 3, (50, 0, 215), -1)

        #其他数据的可视化
        line_max = 50
        #矿物数量/1500
        mineral_ratio = self.minerals / 1500
        if mineral_ratio > 1.0:
            mineral_ratio = 1.0
        #瓦斯气的数量/1500
        vespene_ratio = self.vespene / 1500
        if vespene_ratio > 1.0:
            vespene_ratio = 1.0
        #可用人口比例
        population_ratio = self.supply_left / self.supply_cap
        if population_ratio > 1.0:
            population_ratio = 1.0
        #人口上限数/200
        plausible_supply = self.supply_cap / 200.0
        #voidray占全部人口的比例
        military_weight = len(self.units(UnitTypeId.VOIDRAY)) / (self.supply_cap - self.supply_left)
        if military_weight > 1.0:
            military_weight = 1.0
        #绘制数据线line（图片， 起点， 终点， RGB， 粗细）
        # voidray占全部人口的比例
        cv2.line(game_data, (0, 19), (int(line_max * military_weight), 19), (250, 250, 200), 3)
        # 人口上限数/200
        cv2.line(game_data, (0, 15), (int(line_max * plausible_supply), 15), (220, 200, 200), 3)
        # 可用人口比例
        cv2.line(game_data, (0, 11), (int(line_max * population_ratio), 11), (150, 150, 150), 3)
        # 瓦斯气的数量/1500
        cv2.line(game_data, (0, 7), (int(line_max * vespene_ratio), 7), (210, 200, 0), 3)
        # 矿物数量/1500
        cv2.line(game_data, (0, 3), (int(line_max * mineral_ratio), 3), (0, 255, 25), 3)

        #图像垂直翻转
        self.flipped = cv2.flip(game_data, 0)
        #是否可视化
        if not HEADLESS:
            # 调整图像大小，原图像，输出图像所需大小，比例因子
            resized = cv2.resize(self.flipped, dsize=None, fx=2, fy=2)
            cv2.imshow("Intel", resized)
            cv2.waitKey(1)




"""
运行游戏，选择地图，自定义选手(AI vs computer) or (AI vs AI), 是否实时运行
"""
run_game(maps.get("AbyssalReefLE"),
         [Bot(Race.Protoss, SentBot(use_model=True)), Computer(Race.Terran, Difficulty.Hard)],
         realtime=False)

你可能感兴趣的:(Python)

  • 理解Gunicorn：Python WSGI服务器的基石 范范0825 ipythonlinux运维
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
  • Python数据分析与可视化实战指南 William数据分析 pythonpython数据
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
  • python os.environ 江湖偌大 python深度学习
    os.environ['TF_CPP_MIN_LOG_LEVEL']='0'#默认值，输出所有信息os.environ['TF_CPP_MIN_LOG_LEVEL']='1'#屏蔽通知信息（INFO）os.environ['TF_CPP_MIN_LOG_LEVEL']='2'#屏蔽通知信息和警告信息（INFO\WARNING）os.environ['TF_CPP_MIN_LOG_LEVEL']='
  • Python中os.environ基本介绍及使用方法 鹤冲天Pro #Pythonpython服务器开发语言
    文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
  • Pyecharts数据可视化大屏：打造沉浸式数据分析体验 我的运维人生 信息可视化数据分析数据挖掘运维开发技术共享
    Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例
  • Python教程：一文了解使用Python处理XPath 旦莫 Python进阶python开发语言
    目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
  • python os.environ_python os.environ 读取和设置环境变量 weixin_39605414 pythonos.environ
    >>>importos>>>os.environ.keys()['LC_NUMERIC','GOPATH','GOROOT','GOBIN','LESSOPEN','SSH_CLIENT','LOGNAME','USER','HOME','LC_PAPER','PATH','DISPLAY','LANG','TERM','SHELL','J2REDIR','LC_MONETARY','QT_QPA
  • 使用Faiss进行高效相似度搜索 llzwxh888 faisspython
    在现代AI应用中，快速和高效的相似度搜索是至关重要的。Faiss（FacebookAISimilaritySearch）是一个专门用于快速相似度搜索和聚类的库，特别适用于高维向量。本文将介绍如何使用Faiss来进行相似度搜索，并结合Python代码演示其基本用法。什么是Faiss？Faiss是一个由FacebookAIResearch团队开发的开源库，主要用于高维向量的相似性搜索和聚类。Faiss
  • python是什么意思中文-在python中%是什么意思 编程大乐趣
    Python中%有两种：1、数值运算：%代表取模，返回除法的余数。如：>>>7%212、%操作符（字符串格式化，stringformatting），说明如下：%[(name)][flags][width].[precision]typecode(name)为命名flags可以有+，-，''或0。+表示右对齐。-表示左对齐。''为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填
  • Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Pythonpython开发语言大数据数据分析数据挖掘
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
  • python八股文面试题分享及解析(1) Shawn________ python
    #1.'''a=1b=2不用中间变量交换a和b'''#1.a=1b=2a,b=b,aprint(a)print(b)结果：21#2.ll=[]foriinrange(3):ll.append({'num':i})print(11)结果:#[{'num':0},{'num':1},{'num':2}]#3.kk=[]a={'num':0}foriinrange(3):#0,12#可变类型，不仅仅改变
  • 每日算法&面试题，大厂特训二十八天——第二十天（树） 肥学 ⚡算法题⚡面试题每日精进java算法数据结构
    目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
  • Python快速入门 —— 第三节：类与对象 孤华暗香 Python快速入门python开发语言
    第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
  • pyecharts——绘制柱形图折线图 2224070247 信息可视化pythonjava数据可视化
    一、pyecharts概述自2013年6月百度EFE(ExcellentFrontEnd）数据可视化团队研发的ECharts1.0发布到GitHub网站以来，ECharts一直备受业界权威的关注并获得广泛好评，成为目前成熟且流行的数据可视化图表工具，被应用到诸多数据可视化的开发领域。Python作为数据分析领域最受欢迎的语言，也加入ECharts的使用行列，并研发出方便Python开发者使用的数据
  • Python 实现图片裁剪（附代码） | Python工具 剑客阿良_ALiang
    前言本文提供将图片按照自定义尺寸进行裁剪的工具方法，一如既往的实用主义。环境依赖ffmpeg环境安装，可以参考我的另一篇文章：windowsffmpeg安装部署_阿良的博客-CSDN博客本文主要使用到的不是ffmpeg，而是ffprobe也在上面这篇文章中的zip包中。ffmpy安装：pipinstallffmpy-ihttps://pypi.douban.com/simple代码不废话了，上代码
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（4) 算法大师 华为od面试python
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
  • python os 环境变量 CV矿工 python开发语言numpy
    环境变量：环境变量是程序和操作系统之间的通信方式。有些字符不宜明文写进代码里，比如数据库密码，个人账户密码，如果写进自己本机的环境变量里，程序用的时候通过os.environ.get（）取出来就行了。os.environ是一个环境变量的字典。环境变量的相关操作importos"""设置/修改环境变量：os.environ[‘环境变量名称’]=‘环境变量值’#其中key和value均为string类
  • Python爬虫解析工具之xpath使用详解 eqa11 python爬虫开发语言
    文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（1） 算法大师 华为od面试python
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.数据预处理流程数据预处理的主要步骤工具和库2.介绍线性回归、逻辑回归模型线性回归（LinearRegression）模型形式：关键点：逻辑回归（LogisticRegression）模型形式：关键点：参数估计与评估：3.python浅拷贝及深拷贝浅拷贝（Shal
  • nosql数据库技术与应用知识点 皆过客，揽星河 NoSQLnosql数据库大数据数据分析数据结构非关系型数据库
    Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
  • 《Python数据分析实战终极指南》 xjt921122 python数据分析开发语言
    对于分析师来说，大家在学习Python数据分析的路上，多多少少都遇到过很多大坑**，有关于技能和思维的**：Excel已经没办法处理现有的数据量了，应该学Python吗？找了一大堆Python和Pandas的资料来学习，为什么自己动手就懵了？跟着比赛类公开数据分析案例练了很久，为什么当自己面对数据需求还是只会数据处理而没有分析思路？学了对比、细分、聚类分析，也会用PEST、波特五力这类分析法，为啥
  • Python中深拷贝与浅拷贝的区别 yuxiaoyu.
    转自：http://blog.csdn.net/u014745194/article/details/70271868定义：在Python中对象的赋值其实就是对象的引用。当创建一个对象，把它赋值给另一个变量的时候，python并没有拷贝这个对象，只是拷贝了这个对象的引用而已。浅拷贝：拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。也就是，把对象复制一遍，但是该对象中引用的其他对象我不复
  • Python开发常用的三方模块如下： 换个网名有点难 python开发语言
    Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
  • Python编译器 鹿鹿~ Python编译器Pythonpython开发语言后端
    嘿嘿嘿我又来了啊有些小盆友可能不知道Python其实是有编译器的，也就是PyCharm。你们可能会问到这个是干嘛的又不可以吃也不可以穿好像没有什么用，其实你还说对了这个还真的不可以吃也不可以穿，但是它用来干嘛的呢。用来编译你所打出的代码进行运行（可能这里说的有点不对但是只是个人认为）现在我们来说说PyCharm是用来干嘛的。PyCharm是一种PythonIDE，带有一整套可以帮助用户在使用Pyt
  • 一文掌握python面向对象魔术方法（二） 程序员neil pythonpython开发语言
    接上篇：一文掌握python面向对象魔术方法（一）-CSDN博客目录六、迭代和序列化：1、__iter__(self):定义迭代器，使得类可以被for循环迭代。2、__getitem__(self,key):定义索引操作，如obj[key]。3、__setitem__(self,key,value):定义赋值操作，如obj[key]=value。4、__delitem__(self,key):定义
  • 一文掌握python常用的list（列表）操作 程序员neil pythonpython开发语言
    目录一、创建列表1.直接创建列表：2.使用list()构造器3.使用列表推导式4.创建空列表二、访问列表元素1.列表支持通过索引访问元素，索引从0开始：2.还可以使用切片操作访问列表的一部分：三、修改列表元素四、添加元素1.append()：在末尾添加元素2.insert()：在指定位置插入元素五、删除元素1.del：删除指定位置的元素2.remove()：删除指定值的第一个匹配项3.pop()：
  • Python实现简单的机器学习算法 master_chenchengg pythonpython办公效率python开发IT
    Python实现简单的机器学习算法开篇：初探机器学习的奇妙之旅搭建环境：一切从安装开始必备工具箱第一步：安装Anaconda和JupyterNotebook小贴士：如何配置Python环境变量算法初体验：从零开始的Python机器学习线性回归：让数据说话数据准备：从哪里找数据编码实战：Python实现线性回归模型评估：如何判断模型好坏逻辑回归：从分类开始理论入门：什么是逻辑回归代码实现：使用skl
  • python中的深拷贝与浅拷贝 anshejd70787 python
    深拷贝和浅拷贝浅拷贝的时候，修改原来的对象，浅拷贝的对象不会发生改变。1、对象的赋值对象的赋值实际上是对象之间的引用：当创建一个对象，然后将这个对象赋值给另外一个变量的时候，python并没有拷贝这个对象，而只是拷贝了这个对象的引用。当对对象做赋值或者是参数传递或者作为返回值的时候，总是传递原始对象的引用，而不是一个副本。如下所示：>>>aList=["kel","abc",123]>>>bLis
  • 用Python实现简单的猜数字游戏 程序媛了了 python游戏java
    猜数字游戏代码：importrandomdefpythonit():a=random.randint(1,100)n=int(input("输入你猜想的数字："))whilen!=a:ifn>a:print("很遗憾，猜大了")n=int(input("请再次输入你猜想的数字："))elifna::如果玩家猜的数字n大于随机数字a，则输出"很遗憾，猜大了"，并提示玩家再次输入。elifn
  • 用Python实现读取统计单词个数 程序媛了了 python游戏java
    完整实例代码：fromcollectionsimportCounterdefpythonit():danci={}withopen("pythonit.txt","r",encoding="utf-8")asf:foriinf:words=i.strip().split()forwordinwords:ifwordnotindanci:danci[word]=1else:danci[word]+=
  • 面向对象面向过程 3213213333332132 java
    面向对象：把要完成的一件事，通过对象间的协作实现。 面向过程：把要完成的一件事，通过循序依次调用各个模块实现。 我把大象装进冰箱这件事为例，用面向对象和面向过程实现，都是用java代码完成。 1、面向对象 package bigDemo.ObjectOriented; /** * 大象类 * * @Description * @author FuJian
  • Java Hotspot: Remove the Permanent Generation bookjovi HotSpot
      openjdk上关于hotspot将移除永久带的描述非常详细，http://openjdk.java.net/jeps/122   JEP 122: Remove the Permanent Generation Author Jon Masamitsu Organization Oracle Created 2010/8/15 Updated 2011/
  • 正则表达式向前查找向后查找,环绕或零宽断言 dcj3sjt126com 正则表达式
    向前查找和向后查找 1. 向前查找：根据要匹配的字符序列后面存在一个特定的字符序列(肯定式向前查找)或不存在一个特定的序列(否定式向前查找)来决定是否匹配。.NET将向前查找称之为零宽度向前查找断言。     对于向前查找，出现在指定项之后的字符序列不会被正则表达式引擎返回。 2. 向后查找：一个要匹配的字符序列前面有或者没有指定的
  • BaseDao 171815164 seda
    import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; import java.sql.PreparedStatement; import java.sql.ResultSet; public class BaseDao { public Conn
  • Ant标签详解--Java命令 g21121 Java命令
            这一篇主要介绍与java相关标签的使用         终于开始重头戏了，Java部分是我们关注的重点也是项目中用处最多的部分。           1
  • [简单]代码片段_电梯数字排列 53873039oycg 代码
           今天看电梯数字排列是9 18 26这样呈倒N排列的,写了个类似的打印例子，如下:       import java.util.Arrays; public class 电梯数字排列_S3_Test { public static void main(S
  • Hessian原理 云端月影 hessian原理
    Hessian 原理分析 一．      远程通讯协议的基本原理 网络通信需要做的就是将流从一台计算机传输到另外一台计算机，基于传输协议和网络 IO 来实现，其中传输协议比较出名的有 http 、 tcp 、 udp 等等， http 、 tcp 、 udp 都是在基于 Socket 概念上为某类应用场景而扩展出的传输协
  • 区分Activity的四种加载模式----以及Intent的setFlags aijuans android
      在多Activity开发中，有可能是自己应用之间的Activity跳转，或者夹带其他应用的可复用Activity。可能会希望跳转到原来某个Activity实例，而不是产生大量重复的Activity。 这需要为Activity配置特定的加载模式，而不是使用默认的加载模式。 加载模式分类及在哪里配置 Activity有四种加载模式： standard singleTop
  • hibernate几个核心API及其查询分析 antonyup_2006 html.netHibernatexml配置管理
    (一)  org.hibernate.cfg.Configuration类         读取配置文件并创建唯一的SessionFactory对象.(一般,程序初始化hibernate时创建.)         Configuration co
  • PL/SQL的流程控制 百合不是茶 oraclePL/SQL编程循环控制
    PL/SQL也是一门高级语言,所以流程控制是必须要有的,oracle数据库的pl/sql比sqlserver数据库要难,很多pl/sql中有的sqlserver里面没有   流程控制; 分支语句 if 条件 then 结果 else 结果 end if ; 条件语句 case when 条件 then 结果; 循环语句 loop
  • 强大的Mockito测试框架 bijian1013 mockito单元测试
    一.自动生成Mock类        在需要Mock的属性上标记@Mock注解，然后@RunWith中配置Mockito的TestRunner或者在setUp()方法中显示调用MockitoAnnotations.initMocks(this);生成Mock类即可。二.自动注入Mock类到被测试类  &nbs
  • 精通Oracle10编程SQL(11)开发子程序 bijian1013 oracle数据库plsql
    /* *开发子程序 */ --子程序目是指被命名的PL/SQL块，这种块可以带有参数，可以在不同应用程序中多次调用 --PL/SQL有两种类型的子程序：过程和函数 --开发过程 --建立过程：不带任何参数 CREATE OR REPLACE PROCEDURE out_time IS BEGIN DBMS_OUTPUT.put_line(systimestamp); E
  • 【EhCache一】EhCache版Hello World bit1129 Hello world
    本篇是EhCache系列的第一篇，总体介绍使用EhCache缓存进行CRUD的API的基本使用，更细节的内容包括EhCache源代码和设计、实现原理在接下来的文章中进行介绍   环境准备 1.新建Maven项目   2.添加EhCache的Maven依赖 <dependency> <groupId>ne
  • 学习EJB3基础知识笔记 白糖_ beanHibernatejbosswebserviceejb
    最近项目进入系统测试阶段，全赖袁大虾领导有力，保持一周零bug记录，这也让自己腾出不少时间补充知识。花了两天时间把“传智播客EJB3.0”看完了，EJB基本的知识也有些了解，在这记录下EJB的部分知识，以供自己以后复习使用。   EJB是sun的服务器端组件模型，最大的用处是部署分布式应用程序。EJB (Enterprise JavaBean)是J2EE的一部分，定义了一个用于开发基
  • angular.bootstrap boyitech AngularJSAngularJS APIangular中文api
    angular.bootstrap 描述：     手动初始化angular。     这个函数会自动检测创建的module有没有被加载多次，如果有则会在浏览器的控制台打出警告日志，并且不会再次加载。这样可以避免在程序运行过程中许多奇怪的问题发生。   使用方法：     angular .
  • java-谷歌面试题-给定一个固定长度的数组，将递增整数序列写入这个数组。当写到数组尾部时，返回数组开始重新写，并覆盖先前写过的数 bylijinnan java
    public class SearchInShiftedArray { /** * 题目：给定一个固定长度的数组，将递增整数序列写入这个数组。当写到数组尾部时，返回数组开始重新写，并覆盖先前写过的数。 * 请在这个特殊数组中找出给定的整数。 * 解答： * 其实就是“旋转数组”。旋转数组的最小元素见http://bylijinnan.iteye.com/bl
  • 天使还是魔鬼？都是我们制造 ducklsl 生活教育情感
    ----------------------------剧透请原谅，有兴趣的朋友可以自己看看电影，互相讨论哦！！！     从厦门回来的动车上，无意中瞟到了书中推荐的几部关于儿童的电影。当然，这几部电影可能会另大家失望，并不是类似小鬼当家的电影，而是关于“坏小孩”的电影！     自己挑了两部先看了看，但是发现看完之后，心里久久不能平
  • [机器智能与生物]研究生物智能的问题 comsci 生物
          我想,人的神经网络和苍蝇的神经网络,并没有本质的区别...就是大规模拓扑系统和中小规模拓扑分析的区别....       但是,如果去研究活体人类的神经网络和脑系统,可能会受到一些法律和道德方面的限制,而且研究结果也不一定可靠,那么希望从事生物神经网络研究的朋友,不如把
  • 获取Android Device的信息 dai_lm android
    String phoneInfo = "PRODUCT: " + android.os.Build.PRODUCT; phoneInfo += ", CPU_ABI: " + android.os.Build.CPU_ABI; phoneInfo += ", TAGS: " + android.os.Build.TAGS; ph
  • 最佳字符串匹配算法（Damerau-Levenshtein距离算法）的Java实现 datamachine java算法字符串匹配
    原文：http://www.javacodegeeks.com/2013/11/java-implementation-of-optimal-string-alignment.html------------------------------------------------------------------------------------------------------------
  • 小学5年级英语单词背诵第一课 dcj3sjt126com englishword
    long 长的 show 给...看，出示 mouth 口，嘴 write 写   use 用，使用 take 拿，带来 hand 手 clever 聪明的   often 经常 wash 洗 slow 慢的 house 房子   water 水 clean 清洁的 supper 晚餐 out 在外   face 脸，
  • macvim的使用实战 dcj3sjt126com macvim
    macvim用的是mac里面的vim, 只不过是一个GUI的APP, 相当于一个壳   1. 下载macvim https://code.google.com/p/macvim/   2. 了解macvim :h               vim的使用帮助信息 :h macvim  
  • java二分法查找 蕃薯耀 java二分法查找二分法java二分法
    java二分法查找 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 2015年6月23日 11:40:03 星期二 http:/
  • Spring Cache注解+Memcached hanqunfeng springmemcached
    Spring3.1 Cache注解  依赖jar包： <!-- simple-spring-memcached --> <dependency> <groupId>com.google.code.simple-spring-memcached</groupId> <artifactId>simple-s
  • apache commons io包快速入门 jackyrong apache commons
    原文参考 http://www.javacodegeeks.com/2014/10/apache-commons-io-tutorial.html   Apache Commons IO 包绝对是好东西，地址在http://commons.apache.org/proper/commons-io/，下面用例子分别介绍：   1）  工具类   2
  • 如何学习编程 lampcy java编程C++c
    首先,我想说一下学习思想.学编程其实跟网络游戏有着类似的效果.开始的时候,你会对那些代码,函数等产生很大的兴趣,尤其是刚接触编程的人,刚学习第一种语言的人.可是,当你一步步深入的时候,你会发现你没有了以前那种斗志.就好象你在玩韩国泡菜网游似的,玩到一定程度,每天就是练级练级,完全是一个想冲到高级别的意志力在支持着你.而学编程就更难了,学了两个月后,总是觉得你好象全都学会了,却又什么都做不了,又没有
  • 架构师之spring-----spring3.0新特性的bean加载控制@DependsOn和@Lazy nannan408 Spring3
    1.前言。    如题。 2.描述。    @DependsOn用于强制初始化其他Bean。可以修饰Bean类或方法，使用该Annotation时可以指定一个字符串数组作为参数，每个数组元素对应于一个强制初始化的Bean。 @DependsOn({"steelAxe","abc"}) @Comp
  • Spring4+quartz2的配置和代码方式调度 Everyday都不同 代码配置spring4quartz2.x定时任务
    前言：这些天简直被quartz虐哭。。因为quartz 2.x版本相比quartz1.x版本的API改动太多，所以，只好自己去查阅底层API……   quartz定时任务必须搞清楚几个概念： JobDetail——处理类 Trigger——触发器，指定触发时间，必须要有JobDetail属性，即触发对象 Scheduler——调度器，组织处理类和触发器，配置方式一般只需指定触发
  • Hibernate入门 tntxia Hibernate
      前言   使用面向对象的语言和关系型的数据库，开发起来很繁琐，费时。由于现在流行的数据库都不面向对象。Hibernate 是一个Java的ORM（Object/Relational Mapping）解决方案。   Hibernte不仅关心把Java对象对应到数据库的表中，而且提供了请求和检索的方法。简化了手工进行JDBC操作的流程。   如
  • Math类 xiaoxing598 Math
    一、Java中的数字（Math）类是final类，不可继承。 1、常数 PI：double圆周率 E：double自然对数 2、截取（注意方法的返回类型） double ceil(double d) 返回不小于d的最小整数 double floor(double d) 返回不大于d的整最大数 int round(float f) 返回四舍五入后的整数 long round
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他