Eight_Puzzle.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "b2d7ff5f",
   "metadata": {},
   "source": [
    "# 生成初始状态"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "1690ad0b",
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 6 4 7 1 8 3 2 0\n",
      "3 8 4 6 7 2 5 1 0\n",
      "1 5 0 4 8 7 3 6 2\n",
      "2 1 0 8 6 5 7 3 4\n",
      "1 8 3 4 7 5 2 6 0\n",
      "8 5 2 3 4 6 0 1 7\n",
      "3 5 8 0 6 7 2 4 1\n",
      "1 2 4 6 5 7 0 3 8\n",
      "7 5 8 3 0 4 6 2 1\n",
      "1 5 0 4 7 6 2 3 8\n",
      "4 1 6 3 8 7 2 0 5\n",
      "8 1 2 5 7 6 4 0 3\n",
      "3 7 8 4 0 6 5 2 1\n",
      "5 2 7 6 8 3 0 1 4\n",
      "8 2 0 5 3 1 7 4 6\n",
      "0 3 7 6 8 4 1 2 5\n",
      "6 3 1 2 8 5 0 7 4\n",
      "2 4 7 0 1 6 5 8 3\n",
      "6 0 3 8 7 2 1 5 4\n",
      "6 3 8 0 2 1 5 4 7\n",
      "8 4 1 2 6 7 3 0 5\n",
      "5 0 3 2 8 7 6 4 1\n",
      "3 4 5 7 6 1 0 8 2\n",
      "3 7 6 8 1 4 0 5 2\n",
      "6 5 8 3 0 1 4 7 2\n",
      "6 2 8 1 3 4 5 7 0\n",
      "6 1 2 5 3 0 4 8 7\n",
      "6 3 2 7 1 4 8 5 0\n",
      "2 7 8 0 3 6 5 4 1\n",
      "7 4 2 0 3 8 1 5 6\n",
      "2 7 8 0 1 5 6 3 4\n",
      "3 7 2 6 4 5 0 8 1\n",
      "1 2 0 7 8 3 4 5 6\n",
      "7 8 5 1 6 3 2 0 4\n",
      "0 5 8 3 2 6 4 7 1\n",
      "8 0 4 6 3 5 2 1 7\n",
      "4 2 0 7 1 6 8 5 3\n",
      "1 6 2 8 3 0 5 7 4\n",
      "4 1 6 3 2 5 7 8 0\n",
      "4 2 8 5 0 1 6 3 7\n",
      "6 7 4 2 1 5 8 3 0\n",
      "4 6 3 0 1 8 7 2 5\n",
      "3 0 5 2 6 8 4 1 7\n",
      "2 1 3 0 5 4 8 7 6\n",
      "3 2 7 4 8 0 1 6 5\n",
      "8 6 7 0 2 1 4 3 5\n",
      "6 2 1 4 0 8 7 5 3\n",
      "2 4 7 0 5 1 6 8 3\n",
      "6 0 5 3 8 2 7 1 4\n",
      "2 3 8 4 1 7 0 5 6\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "import time\n",
    "import math\n",
    "f = open(\"eightPuzzleTest.txt\", \"w\")\n",
    "testCaseCount = 50\n",
    "result = \"\"\n",
    "while testCaseCount > 0:\n",
    "    board = [0,1,2,3,4,5,6,7,8]\n",
    "    random.shuffle(board)\n",
    "  \n",
    "    testCaseCount -= 1\n",
    "    for i in range(0,8): # i = 0 1 2 3 4 5 6 7\n",
    "        result += str(board[i]) + ' '\n",
    "    result += str(board[i+1]) + '\\n' #! i+1=8\n",
    "print(result)\n",
    "f.write(result)\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d2d4991",
   "metadata": {},
   "source": [
    "计算启发式代价"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "2c4dca8d",
   "metadata": {
    "hide_input": true
   },
   "outputs": [],
   "source": [
    "# manhattan_distance\n",
    "def getManhattanDistance(board):\n",
    "    distance = 0\n",
    "    for i in range(len(board)):\n",
    "        distance += abs(i/3 - board[i]/3) + abs(i%3 - board[i]%3)\n",
    "    return distance"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7fabebd0",
   "metadata": {},
   "source": [
    "# 求解方法"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "663062a0",
   "metadata": {
    "hide_input": true
   },
   "source": [
    "## 最陡爬山\n",
    "移动到启发式代价最小的位置"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "aebd61c5",
   "metadata": {
    "hide_input": false
   },
   "outputs": [],
   "source": [
    "def step_steepestHillClimbing(board):\n",
    "    for i in range(len(board)):\n",
    "        if board[i] == 0:\n",
    "            break\n",
    "    distanceBoard = {}\n",
    "    if i >= 3:\n",
    "        upBoard = list(board)\n",
    "        upBoard[i] = board[i-3]\n",
    "        upBoard[i-3] = 0\n",
    "        distanceBoard[i-3] = getManhattanDistance(upBoard)\n",
    "    if i < 6:\n",
    "        downBoard = list(board)\n",
    "        downBoard[i] = board[i+3]\n",
    "        downBoard[i+3] = 0\n",
    "        distanceBoard[i+3] = getManhattanDistance(downBoard)\n",
    "    if i%3 != 0:\n",
    "        leftBoard = list(board)\n",
    "        leftBoard[i] = board[i-1]\n",
    "        leftBoard[i-1] = 0\n",
    "        distanceBoard[i-1] = getManhattanDistance(leftBoard)\n",
    "    if (i+1)%3 != 0:\n",
    "        rightBoard = list(board)\n",
    "        rightBoard[i] = board[i+1]\n",
    "        rightBoard[i+1] = 0\n",
    "        distanceBoard[i+1] = getManhattanDistance(rightBoard)\n",
    "    # 最小代价，改成 getManhattanDistance(board) - 1 即可寻找更优解\n",
    "    shortestDistance = getManhattanDistance(board)\n",
    "    for point,value in distanceBoard.items():\n",
    "        # \"<=\" means \"not worse than\" situation\n",
    "        # plain\n",
    "        if value <= shortestDistance:\n",
    "            shortestDistance = value\n",
    "    \n",
    "    shortestDistancePoints = []\n",
    "    for point,value in distanceBoard.items():\n",
    "        if value == shortestDistance:\n",
    "            shortestDistancePoints.append(point)\n",
    "    \n",
    "    # can not find a steeper move\n",
    "    # we have come to the peek(local optimization)\n",
    "    if len(shortestDistancePoints) == 0:\n",
    "        # print \"local optimization\"\n",
    "        global FAILED\n",
    "        FAILED = True\n",
    "        return board\n",
    "    \n",
    "    random.shuffle(shortestDistancePoints)\n",
    "    board[i] = board[shortestDistancePoints[0]]\n",
    "    board[shortestDistancePoints[0]]= 0\n",
    "    return board\n",
    "\n",
    "def solution_steepestHillClimbing(board):\n",
    "    # For each case, there are only several situations using this solution.\n",
    "    # In average, we will reach a local optimization within 100 steps\n",
    "    # or fall into a infinite loop (a plain) within 100 steps.\n",
    "    maxRound = 400\n",
    "    count = 0\n",
    "    while True:\n",
    "        count += 1\n",
    "        collisionNum = getManhattanDistance(board)\n",
    "        # print count, collisionNum\n",
    "        if collisionNum == 0:\n",
    "            return board\n",
    "        board = step_steepestHillClimbing(board)\n",
    "        global FAILED\n",
    "        if FAILED:\n",
    "            return board\n",
    "        if(count >= maxRound):\n",
    "            # for i in range(0,len(board)):\n",
    "            #     print board[i]\n",
    "            FAILED = True\n",
    "            return board"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8d25ec9",
   "metadata": {},
   "source": [
    "## 首选爬山\n",
    "随机生成下一个状态，只要不变差就转移"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "43c7bd03",
   "metadata": {},
   "outputs": [],
   "source": [
    "def step_FirstChoiceHillClimbing(board):\n",
    "    for i in range(len(board)):\n",
    "        if board[i] == 0:\n",
    "            break\n",
    "    distance = getManhattanDistance(board)\n",
    "    maxRound = 16 # 连续20次都不产生某个数的概率为 1%，可认为能够遍历四个方向。\n",
    "    count = 0\n",
    "    while True:\n",
    "        count += 1\n",
    "        if(count >= maxRound):\n",
    "            global FAILED\n",
    "            FAILED = True\n",
    "            return board\n",
    "        # 产生新解，如果空白块在边界则重新生成方向\n",
    "        while True:\n",
    "            randCase = random.randint(0,4)\n",
    "            newBoard = list(board)\n",
    "            if randCase == 0 and i>=3:\n",
    "                newBoard[i] = board[i-3]\n",
    "                newBoard[i-3] = 0\n",
    "                break\n",
    "            elif randCase == 1 and i<6:\n",
    "                newBoard[i] = board[i+3]\n",
    "                newBoard[i+3] = 0\n",
    "                break\n",
    "            elif randCase == 2 and i%3 != 0:\n",
    "                newBoard[i] = board[i-1]\n",
    "                newBoard[i-1] = 0\n",
    "                break\n",
    "            elif randCase == 3 and (i+1)%3 != 0:\n",
    "                newBoard[i] = board[i+1]\n",
    "                newBoard[i+1] = 0\n",
    "                break\n",
    "\n",
    "        if getManhattanDistance(newBoard) < distance:\n",
    "            return newBoard\n",
    "        break\n",
    "        \n",
    "    return board\n",
    "\n",
    "def solution_FirstChoiceHillClimbing(board):\n",
    "    maxRound = 400\n",
    "    count = 0\n",
    "    while True:\n",
    "        collisionNum = getManhattanDistance(board)\n",
    "        if collisionNum == 0:\n",
    "            return board\n",
    "        board = step_FirstChoiceHillClimbing(board)\n",
    "        count += 1\n",
    "        if(count >= maxRound):\n",
    "            global FAILED\n",
    "            FAILED = True\n",
    "            return board"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c51f957",
   "metadata": {},
   "source": [
    "## 随机重启爬山\n",
    "使用最陡爬山法，若找不到解，就生成一组新的初始状态。采用递归实现，递归结束条件：重启超过50轮，或者达到目标状态。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "c096bc0f",
   "metadata": {},
   "outputs": [],
   "source": [
    "global restart_cnt\n",
    "restart_cnt = 0\n",
    "\n",
    "def solution_RandomHillClimbing(board):\n",
    "    global restart_cnt\n",
    "    global FAILED\n",
    "    if restart_cnt > 1000:  # 最多重启500轮\n",
    "        FAILED = True\n",
    "        return board\n",
    "    board = solution_FirstChoiceHillClimbing(board)\n",
    "    if FAILED:  # 失败则重启\n",
    "        FAILED = False  # 一定要重置 FAILED 标志！\n",
    "        restart_cnt += 1\n",
    "        for col in range(0,7):\n",
    "            board[col] = random.randint(0,7)\n",
    "        # 再次搜索（递归）\n",
    "        board = solution_RandomHillClimbing(board)\n",
    "    return board"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b282c520",
   "metadata": {},
   "source": [
    "## 模拟退火\n",
    "以概率$e^{-\\frac{\\Delta E}{T}}$ 接受更差的状态。\n",
    "温度越低，接受更差状态的概率越小。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "5575ffd5",
   "metadata": {
    "hide_input": false
   },
   "outputs": [],
   "source": [
    "def solution_SimulatedAnnealing(board):\n",
    "    temperature = 20  # 初温\n",
    "    annealingRate = 0.80  # 降温速度\n",
    "    stop_temprature = temperature * annealingRate ** 100  # 停止温度\n",
    "    maxRound = 1000  # 每个温度循环次数\n",
    "    cnt = 0  # 记录搜索次数\n",
    "    while temperature > stop_temprature:\n",
    "        for iteration in range(maxRound):\n",
    "            cnt += 1\n",
    "            for i in range(len(board)):\n",
    "                if board[i] == 0:\n",
    "                    break\n",
    "            # 产生新解(如果在边界则重新生成方向)\n",
    "            while True:\n",
    "                randCase = random.randint(0,4)\n",
    "                newBoard = list(board)\n",
    "                if randCase == 0 and i>=3:\n",
    "                    newBoard[i] = board[i-3]\n",
    "                    newBoard[i-3] = 0\n",
    "                    break\n",
    "                elif randCase == 1 and i<6:\n",
    "                    newBoard[i] = board[i+3]\n",
    "                    newBoard[i+3] = 0\n",
    "                    break\n",
    "                elif randCase == 2 and i%3 != 0:\n",
    "                    newBoard[i] = board[i-1]\n",
    "                    newBoard[i-1] = 0\n",
    "                    break\n",
    "                elif randCase == 3 and (i+1)%3 != 0:\n",
    "                    newBoard[i] = board[i+1]\n",
    "                    newBoard[i+1] = 0\n",
    "                    break\n",
    "            newDistance = getManhattanDistance(newBoard)\n",
    "            originDistance = getManhattanDistance(board)\n",
    "            if newDistance == 0:\n",
    "                print(cnt)\n",
    "                return newBoard\n",
    "            # 接受新解条件，如果newDistance更小，下式一定成立！\n",
    "            if random.random() < math.exp(-(newDistance - originDistance) / temperature):\n",
    "                board = newBoard\n",
    "\n",
    "        temperature = temperature * annealingRate\n",
    "    global FAILED\n",
    "    FAILED = True\n",
    "    return board"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "e31ef36d",
   "metadata": {
    "hide_input": true
   },
   "outputs": [],
   "source": [
    "def step_SimulatedAnnealing(board):\n",
    "    temperature = len(board)\n",
    "    annealingRate = 0.95\n",
    "    \n",
    "    for i in range(len(board)):\n",
    "        if board[i] == 0:\n",
    "            break\n",
    "    distance = getManhattanDistance(board)\n",
    "    temperature = max(temperature * annealingRate, 0.02)\n",
    "    while True:\n",
    "        randCase = random.randint(0,4)\n",
    "        if randCase == 0:\n",
    "            if i >= 3:\n",
    "                upBoard = list(board)\n",
    "                upBoard[i] = board[i-3]\n",
    "                upBoard[i-3] = 0\n",
    "                if getManhattanDistance(upBoard) < distance:\n",
    "                    return upBoard\n",
    "                else:\n",
    "                    deltaE = getManhattanDistance(upBoard) - distance\n",
    "                    acceptProbability = min(math.exp(deltaE / temperature), 1)\n",
    "                    if random.random() <= acceptProbability:\n",
    "                        return upBoard\n",
    "        elif randCase == 1:\n",
    "            if i < 6:\n",
    "                downBoard = list(board)\n",
    "                downBoard[i] = board[i+3]\n",
    "                downBoard[i+3] = 0\n",
    "                if getManhattanDistance(downBoard) < distance:\n",
    "                    return downBoard\n",
    "                else:\n",
    "                    deltaE = getManhattanDistance(downBoard) - distance\n",
    "                    acceptProbability = min(math.exp(deltaE / temperature), 1)\n",
    "                    if random.random() <= acceptProbability:\n",
    "                        return downBoard\n",
    "        elif randCase == 2:\n",
    "            if i%3 != 0:\n",
    "                leftBoard = list(board)\n",
    "                leftBoard[i] = board[i-1]\n",
    "                leftBoard[i-1] = 0\n",
    "                if getManhattanDistance(leftBoard) < distance:\n",
    "                    return leftBoard\n",
    "                else:\n",
    "                    deltaE = getManhattanDistance(leftBoard) - distance\n",
    "                    acceptProbability = min(math.exp(deltaE / temperature), 1)\n",
    "                    if random.random() <= acceptProbability:\n",
    "                        return leftBoard\n",
    "        else:    \n",
    "            if (i+1)%3 != 0:\n",
    "                rightBoard = list(board)\n",
    "                rightBoard[i] = board[i+1]\n",
    "                rightBoard[i+1] = 0\n",
    "                if getManhattanDistance(rightBoard) < distance:\n",
    "                    return rightBoard\n",
    "                else:\n",
    "                    deltaE = getManhattanDistance(rightBoard) - distance\n",
    "                    acceptProbability = min(math.exp(deltaE / temperature), 1)\n",
    "                    if random.random() <= acceptProbability:\n",
    "                        return rightBoard\n",
    "                    \n",
    "    return board\n",
    "\n",
    "def solution_SimulatedAnnealing(board):\n",
    "    # the success rate will increase by increasing the maxRound\n",
    "    maxRound = 500000\n",
    "    count = 0\n",
    "    while True:\n",
    "        collisionNum = getManhattanDistance(board)\n",
    "        if collisionNum == 0:\n",
    "            print (count)\n",
    "            return board\n",
    "        board = step_SimulatedAnnealing(board)\n",
    "        count += 1\n",
    "        if(count >= maxRound):\n",
    "            global FAILED\n",
    "            FAILED = True\n",
    "            return board"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc6d67a9",
   "metadata": {},
   "source": [
    "# 求解结果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "5ac87231",
   "metadata": {
    "hide_input": false
   },
   "outputs": [],
   "source": [
    "def test(method):\n",
    "    startTime = time.perf_counter()\n",
    "    successCase = 0\n",
    "    totalCase = 0\n",
    "    result = \"EightPuzzle\" + method + \" result:\\n\\n\"\n",
    "    with open(\"eightPuzzleTest.txt\", \"r\") as ins:\n",
    "        for line in ins:\n",
    "            global FAILED\n",
    "            FAILED = False\n",
    "            global restart_cnt\n",
    "            restart_cnt = 0\n",
    "            totalCase += 1\n",
    "            board = []\n",
    "            for col in line.split():\n",
    "                board.append(int(col))\n",
    "            if method == 'SteepestHillClimbing':\n",
    "                board = solution_steepestHillClimbing(board)\n",
    "            elif method == 'FirstChoiceHillClimbing':\n",
    "                board = solution_FirstChoiceHillClimbing(board)\n",
    "            elif method == 'RandomHillClimbing':\n",
    "                board = solution_RandomHillClimbing(board)\n",
    "            else:\n",
    "                board = solution_SimulatedAnnealing(board)\n",
    "            if FAILED:\n",
    "                result += \"Failed!\"\n",
    "            else:\n",
    "                successCase += 1\n",
    "                for col in range(len(board)):\n",
    "                    result += str(board[col]) + \" \"\n",
    "            result += \"\\n\"\n",
    "\n",
    "    endTime = time.perf_counter()\n",
    "    performance = \"EightPuzz-\" + method +':\\n'\n",
    "    performance += \"Total time: \" + str(endTime - startTime) + '\\n'\n",
    "    performance += \"Total case number: \" + str(totalCase) + \", Success case number: \" + str(successCase) + '\\n'\n",
    "    performance += \"Success rate: \" + str(successCase / float(totalCase)) + '\\n'\n",
    "    f = open('EightPuzzle_ '+method+ '.txt', 'w')\n",
    "    f.write(result)\n",
    "    f.write(performance)\n",
    "    f.close()\n",
    "    print(performance)\n",
    "    return[endTime - startTime, successCase / float(totalCase)]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab3f6d26",
   "metadata": {},
   "source": [
    "## 测试"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "7b35355b",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "EightPuzz-SteepestHillClimbing:\n",
      "Total time: 0.014289800000000241\n",
      "Total case number: 50, Success case number: 0\n",
      "Success rate: 0.0\n",
      "\n",
      "EightPuzz-FirstChoiceHillClimbing:\n",
      "Total time: 0.44869290000000017\n",
      "Total case number: 50, Success case number: 0\n",
      "Success rate: 0.0\n",
      "\n",
      "EightPuzz-RandomHillClimbing:\n",
      "Total time: 282.4829698\n",
      "Total case number: 50, Success case number: 0\n",
      "Success rate: 0.0\n",
      "\n",
      "467632\n",
      "78067\n",
      "350052\n",
      "154646\n",
      "144424\n",
      "407214\n",
      "432482\n",
      "454573\n",
      "157892\n",
      "312618\n",
      "228102\n",
      "441477\n",
      "233963\n",
      "228969\n",
      "468418\n",
      "207564\n",
      "215957\n",
      "38919\n",
      "361126\n",
      "EightPuzz-SimulatedAnnealing:\n",
      "Total time: 330.7681511\n",
      "Total case number: 50, Success case number: 19\n",
      "Success rate: 0.38\n",
      "\n"
     ]
    }
   ],
   "source": [
    "[t1, a1] = test('SteepestHillClimbing')\n",
    "[t2, a2] = test('FirstChoiceHillClimbing')\n",
    "[t3, a3] = test('RandomHillClimbing')\n",
    "[t4, a4] = test('SimulatedAnnealing')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "adf5426d",
   "metadata": {
    "hide_input": false
   },
   "source": [
    "## 性能比较\n",
    "八数码问题的可解性由其逆序数决定.\n",
    "\n",
    "对初始状态随机的八数码问题，可解的概率为50%."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "4cb623a5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1600x1200 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib\n",
    "matplotlib.rcParams['font.family'] = 'STSong'\n",
    "matplotlib.rcParams['font.size'] = 10\n",
    "plt.rcParams['figure.dpi'] = 200\n",
    "t = np.array((round(t1,3), round(t2,3), round(t3,3), round(t4,3)))\n",
    "s = np.array((round(a1,3), round(a2,3), round(a3,3), round(a4,3)))\n",
    "\n",
    "ind = np.arange(len(t))  # the x locations for the groups\n",
    "width = 0.35  # the width of the bars\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(8,6))\n",
    "rects1 = ax.bar(ind - width/2, t, width, color='SkyBlue', label = 'time consume')\n",
    "par2 = ax.twinx()\n",
    "rects2 = par2.bar(ind + width/2, s, width, color='Pink', label = 'solving rate')\n",
    "\n",
    "\n",
    "# Add some text for labels, title and custom x-axis tick labels, etc.\n",
    "ax.set_ylabel('time/s')\n",
    "ax.set_title('Performances')\n",
    "ax.set_xticks(ind)\n",
    "ax.set_xticklabels(('SteepestHillClimbing', 'FirstChoiceHillClimbing', 'RandomHillClimbing', 'SimulatedAnnealing'))\n",
    "ax.legend()\n",
    "par2.set_ylabel('Solving Rate')\n",
    "par2.legend(bbox_to_anchor=(0.6,0.998))\n",
    "def autolabel(rects, xpos='center'):\n",
    "    \"\"\"\n",
    "    Attach a text label above each bar in *rects*, displaying its height.\n",
    "\n",
    "    *xpos* indicates which side to place the text w.r.t. the center of\n",
    "    the bar. It can be one of the following {'center', 'right', 'left'}.\n",
    "    \"\"\"\n",
    "\n",
    "    xpos = xpos.lower()  # normalize the case of the parameter\n",
    "    ha = {'center': 'center', 'right': 'left', 'left': 'right'}\n",
    "    offset = {'center': 0.5, 'right': 0.57, 'left': 0}  # x_txt = x + w*off\n",
    "\n",
    "    for rect in rects:\n",
    "        height = rect.get_height()\n",
    "        ax.text(rect.get_x() + rect.get_width()*offset[xpos], 1.01*height,\n",
    "                '{}'.format(height), ha=ha[xpos], va='bottom')\n",
    "        \n",
    "autolabel(rects1, \"left\")\n",
    "\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python [conda env:tensorflow] *",
   "language": "python",
   "name": "conda-env-tensorflow-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "681.25px",
    "left": "80px",
    "top": "99.0801px",
    "width": "165px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}