• 造车先做三蹦子220101--机器学习字符(字母、和数字识别)的“小白鼠”与“果蝇”


    “0”数字字符零 的图片(16*16点阵):

    1. #Letter23Digital23R231006d.py
    2. import torch
    3. import torch.nn as nn
    4. import torch.optim as optim #optimizer = optim.SGD(model.parameters(), lr=0.01)
    5. from PIL import Image
    6. from PIL import ImageDraw
    7. from PIL import ImageFont
    8. #from PIL import ImageDraw, ImageFont
    9. from torchvision import transforms
    10. import matplotlib.pyplot as plt #matplotlib显示字符(结果)
    11. Times500=4590
    12. # 参数设置
    13. font_path = "arial.ttf" #"e:\\22Letter23r1002\\arial.ttf" #e:\\arial.ttf"
    14. #siz28e28 = 28
    15. siz28e14=32
    16. #characters = ["2","4","我"] +[str(i) for i in range(8,9)] + ["A","Z"] #["A", "B"]
    17. Characts01 = ["8","-","+","X","2"] +[str(i) for i in range(0,2)]
    18. print(Characts01)
    19. # 1. 生成字符和数字的点阵数据
    20. def render_char(char, siz28e14):
    21. image = Image.new("L", (siz28e14, siz28e14), "white")
    22. draw = ImageDraw.Draw(image)
    23. font = ImageFont.truetype(font_path, siz28e14)
    24. #-----------------------------------------
    25. w03 = draw.textlength(char, font=font)
    26. h03 = siz28e14
    27. print("{[w3",w03, "h3",w03 ,"]} ")
    28. #-----------------------------------------
    29. draw.text(((siz28e14-w03)/2, (siz28e14-h03)/2), char, font=font, fill="black")
    30. return image
    31. Data01 = []
    32. labels = []
    33. for i, char in enumerate(Characts01):
    34. img = render_char(char, siz28e14)
    35. Data01.append(transforms.ToTensor()(img))
    36. labels.append(i)
    37. print("i",i,char)
    38. #-----------------------------
    39. # 2. 显示取得的 arial.ttf 字体的图像
    40. for i in range(len(Data01)):
    41. plt.imshow(Data01[i].squeeze().cpu().numpy(), cmap="gray")
    42. plt.title("char:"+Characts01[i])
    43. plt.axis("off")
    44. # plt.show()
    45. #-----------------------------
    46. # 2. 训练神经网络模型
    47. class SimpleNet(nn.Module):
    48. def __init__(self, num_classes):
    49. super(SimpleNet, self).__init__()
    50. self.fc = nn.Linear(siz28e14 * siz28e14, num_classes)
    51. def forward(self, x):
    52. x = x.view(-1, siz28e14 * siz28e14)
    53. x = self.fc(x)
    54. return x
    55. model = SimpleNet(len(Characts01))
    56. loss_function = nn.CrossEntropyLoss()
    57. #optimizer = optim.SGD(model.parameters(), lr=0.01)
    58. optimizer = optim.SGD(model.parameters(), lr=0.003)
    59. for epoch in range(Times500):#8000):#1000):
    60. inputs = torch.stack(Data01)
    61. targets = torch.tensor(labels)
    62. optimizer.zero_grad()
    63. outputs = model(inputs)
    64. loss = loss_function(outputs, targets)
    65. loss.backward()
    66. optimizer.step()
    67. # 3. 使用模型进行预测
    68. def predict_image(img_path):
    69. model.eval()
    70. img = Image.open(img_path).convert("L").resize((siz28e14, siz28e14))
    71. img_tensor = transforms.ToTensor()(img).unsqueeze(0)
    72. output = model(img_tensor)
    73. _, predicted = output.max(1)
    74. return Characts01[predicted[0]]
    75. #01//8_"8"----
    76. im="f8_16x18.png"
    77. predicted_char = predict_image(im)
    78. print(f"预测的字符为: {predicted_char}")
    79. plt.imshow(Image.open(im))
    80. plt.title(f"Predicted: {predicted_char}")
    81. plt.show()
    82. #1//1-minus"1"----
    83. im="_1_16x16.png"
    84. predicted_char = predict_image(im)
    85. print(f"预测的字符为: {predicted_char}")
    86. plt.imshow(Image.open(im))
    87. plt.title(f"Predicted: {predicted_char}")
    88. plt.show()
    89. #2//我-"我"----
    90. im="wo19x19.png"
    91. predicted_char = predict_image(im)
    92. print(f"预测的字符为: {predicted_char}")
    93. plt.imshow(Image.open(im))
    94. plt.title(f"Predicted: {predicted_char}")
    95. plt.show()
    96. #3//8-"8"----
    97. im="8_16x16.png"
    98. predicted_char = predict_image(im)
    99. print(f"预测的字符为: {predicted_char}")
    100. # 使用matplotlib显示结果
    101. plt.imshow(Image.open(im))
    102. plt.title(f"Predicted: {predicted_char}")
    103. #plt.axis("off")
    104. plt.show()
    105. #4//minus-minus"-"----
    106. im="f:\\22Letter23r1002\minus16x16.png"
    107. predicted_char = predict_image(im)
    108. print(f"预测的字符为: {predicted_char}")
    109. plt.imshow(Image.open(im))
    110. plt.title(f"Predicted: {predicted_char}")
    111. plt.show()

    造车先做三蹦子的原理是:

    torch,tensorflew,pytorch这个相当于马达、发动机、变速器等底层原件……

    一、造车要不要先研究马达、轮子、发动机?
    当然!必须!

    二、

    研究完 元器件 马达、轮子、发动机  就该造……
    就可以 造 宝马?奔驰?Prius、本田、混动了吗?

    没那么简单……

    对于初级架构师傅来讲……

    学习 Prius的新型架构当然有用!

    但是,能完整的 架构出来一辆 五菱宏光、架构出一辆老头乐,架构出一辆三蹦子……那才是一位合格的架构师

    如果一个伪装的架构师问你:

    我需要 三年时间、三个亿$金钱 架构出一辆 特斯了、Prius混动汽车…… 给钱吧!?

    你应该这样回复他:

    那我只给你三个月时间,只给你10万~100万人民币…… 请你先给俺架构出一辆 老头乐的或五菱宏光!!

    做好了,

    咱们开展下个任务!!

    做不好,那您不叫架构师……  骗子 称号更适合您!

    同样道理,一个合格的 外科医生,

    在给 患者病人 做手术以前,当然应该是先 解剖 过 小白鼠、和青蛙;

    我读过 Caffe的完整代码,这相当于解剖尸体;

    重新遭过轮子。

    这次,就手工 撸 一个 文字(字符)识别 的框架 出来…… 作为 机器学习的“三蹦子”、小白鼠、或者“果蝇”

    下面Demo就是 字符(数字、字母)识别的基本框架……

    先用 torch完成……

    1. import torch
    2. import torch.nn as nn
    3. import torch.optim as optim
    4. from PIL import Image, ImageDraw, ImageFont
    5. from torchvision import transforms
    6. import matplotlib.pyplot as plt
    7. # 参数设置
    8. font_path = "e:\\arial.ttf"
    9. siz28e28 = 28
    10. characters = [str(i) for i in range(0, 10)] + ["A", "B"]
    11. # 1. 生成字符和数字的点阵数据
    12. def render_char(char, siz28e28):
    13. image = Image.new("L", (siz28e28, siz28e28), "white")
    14. draw = ImageDraw.Draw(image)
    15. font = ImageFont.truetype(font_path, siz28e28)
    16. #----------------------------------------------------------
    17. # w, h = draw.textsize(char, font=font)
    18. # 使用textbox方法来获取文本的边界框
    19. # left, upper, right, lower = draw.textbbox((0, 0), char, font=font)
    20. # w01, h01 = right - left, lower - upper
    21. # print("[right",right," _left",left, " _lower",lower, " _upper",upper ,")")
    22. # print("(w1",w01, "h1",h01 ,"] ")
    23. # w02, h02 = draw.textsize(char, font=font) //draw.textsize()函数新版本DeprecationWarning: textsize is deprecated and will be removed in Pillow 10 (2023-07-01). Use textbbox or textlength instead.
    24. # print("{[w2",w02, "h2",w02 ,"]} ")
    25. w03 = draw.textlength(char, font=font)
    26. h03 = siz28e28
    27. print("{[w3",w03, "h3",w03 ,"]} ")
    28. #=============================================
    29. draw.text(((siz28e28-w03)/2, (siz28e28-h03)/2), char, font=font, fill="black")
    30. return image
    31. data = []
    32. labels = []
    33. for i, char in enumerate(characters):
    34. img = render_char(char, siz28e28)
    35. data.append(transforms.ToTensor()(img))
    36. labels.append(i)
    37. # 2. 训练神经网络模型
    38. class SimpleNet(nn.Module):
    39. def __init__(self, num_classes):
    40. super(SimpleNet, self).__init__()
    41. self.fc = nn.Linear(siz28e28 * siz28e28, num_classes)
    42. def forward(self, x):
    43. x = x.view(-1, siz28e28 * siz28e28)
    44. x = self.fc(x)
    45. return x
    46. model = SimpleNet(len(characters))
    47. loss_function = nn.CrossEntropyLoss()
    48. optimizer = optim.SGD(model.parameters(), lr=0.01)
    49. for epoch in range(1000):
    50. inputs = torch.stack(data)
    51. targets = torch.tensor(labels)
    52. optimizer.zero_grad()
    53. outputs = model(inputs)
    54. loss = loss_function(outputs, targets)
    55. loss.backward()
    56. optimizer.step()
    57. # 3. 使用模型进行预测
    58. def predict_image(img_path):
    59. model.eval()
    60. img = Image.open(img_path).convert("L").resize((siz28e28, siz28e28))
    61. img_tensor = transforms.ToTensor()(img).unsqueeze(0)
    62. output = model(img_tensor)
    63. _, predicted = output.max(1)
    64. return characters[predicted[0]]
    65. # 预测E盘的图像
    66. #img_path = "E:\\i.png"
    67. img_path = "E:\\256A256.png"
    68. predicted_char = predict_image(img_path)
    69. print(f"预测的字符为: {predicted_char}")
    70. # 使用matplotlib显示结果
    71. plt.imshow(Image.open(img_path))
    72. plt.title(f"Predicted: {predicted_char}")
    73. plt.axis("off")
    74. plt.show()

  • 相关阅读:
    由浅入深,全面解析AMBA ACE&CHI协议
    java IO流【常用流对象二】
    华为OD七日集训第7期 - 按算法分类,由易到难,循序渐进,玩转OD
    新手必知!----哈夫曼树和哈夫曼编码
    【Kurbernetes资源管理】声明式资源管理+配置清单文件详解(附实例)
    MySQL入门 - 数据分组之 group by
    JavaSE之包装类
    某百亿头部量化私募企业在招岗位:AI算法工程师年base60-200万+bonus+cut965制度“岗位职责:base 北京 上海 杭州 深圳
    5、CSS——三种样式和样式优先级、CSS中颜色设置方式、标签选择器和基本选择器的优先级
    【TA-霜狼_may-《百人计划》】图形5.1 PBR基础 BRDF介绍
  • 原文地址:https://blog.csdn.net/aw344/article/details/133968948