精华内容
下载资源
问答
  • 计算机组成内容来自用户:闫国只教学目的和要求1、学生了解计算机组成部分的名称和作用。2、学生知道什么是计算机软件,了解计算机软件的作用。3、学生了解计算机处理信息的过程。4、通过介绍国产软件,对学生进行...

    计算机组成

    内容来自用户:闫国只

    教学目的和要求

    1、学生了解计算机组成各部分的名称和作用。

    2、学生知道什么是计算机软件,了解计算机软件的作用。

    3、学生了解计算机处理信息的过程。

    4、通过介绍国产软件,对学生进行爱国主义教育。

    教学重点:1、学生了解计算机组成各部分设备的作用。

    2、学生了解计算机处理信息的过程。

    教学难点:计算机硬件和软件的概念。

    教学准备:计算机及相关软件。

    教学过程

    一、质疑导入

    我们知道计算机又叫信息处理机,因为它处理信息的能力很强。那么,同学们你们知道这样高性能的机器它究竟是由哪些部件组成的呢?

    通过今天的学习,大家就一定能解决这个问题。

    二、自主学习,探究新知

    1、先请同学们自己看书P.4-P.7上半部分,边看书边思考:

    ①计算机是由哪两部分组成?

    ②计算机硬件是由哪几部分组成?

    ③计算机软件有哪几类?它们各有什么用途?

    教师巡视检查学生自学情况。

    2、指名学生回答问题①,教师补充说明并注意纠正。

    学生答后,追问:谁来用自己的话说一说什么计算机的硬件和软件?

    教师说明:硬件是指看得见、摸得着的部件,像鼠标、显示器、打印机等;软件是用来指挥计算机工作的命令语言,它是看不见、摸不着的,但离开了软件,计算机就不能正常工作。若计算机只有硬件,就好比人有身体,却没有知识和思想,还不能为人们做事,要让它“活”起来,还要让它掌握“知识”、形成

    电脑主机,由哪几部分组成?完整点,谢谢

    一般电脑主机是由机箱、电源、主板、cpu、内存条、硬盘组成的,像声卡和显卡大多都是主板集成的。好点的电脑显卡、声卡等都是独立的。

    计算机硬件由哪几部分组成?各部分的作用是什么?

    计算机由运算器、控制器、存储器、输入设备和输出设备等五个逻辑部件组成。

    运算器:运算器由算术逻辑单元(ALU)、累加器、状态寄存器、通用寄存器组等组成。算术逻辑运算单元(ALU)的基本功能为加、减、乘、除四则运算,与、或、非、异或等逻辑操作,以及移位、求补等操作。

    控制器:控制器(ControlUnit),是整个计算机系统的控制中心,它指挥计算机各部分协调地工作,保证计算机按照预先规定的目标和步骤有条不紊地进行操作及处理。

    存储器:存储器(Memory)是计算机系统中的记忆设备,用来存放程序和数据。

    输入设备:向计算机输入数据和信息的设备。是计算机与用户或其他设备通信的桥梁。输入设备是用户和计算机系统之间进行信息交换的主要装置之一。

    输出设备:输出设备(OutputDevice)是计算机的终端设备,用于接收计算机数据的输出显示、打印、声音、控制外围设备操作等。也是把各种计算结果数据或信息以数字、字符、图像、声音等形式表示出来。

    计算机硬件五大部分又可以具体分为:主板、CPU、内存、电源、显卡、声卡、网卡、硬盘、软驱、光驱、显示器、键盘、鼠标等设备。

    主板由各种接口、扩展槽、插座以及芯片组成。其作用是在BIOS和操作系统的控制下规定的技术标准和规范,为微机系统中的CPU、内存条、图形卡等部件建立可靠、正确的安装、运行环境,为各种IDE接口存储以及其他外部设备提供方便、可靠的连接接口。

    CPU的接口标准分为两大类:一种是Socket类型,另一种是Slot类型。它的主要性能指标:主频、前端总线频率、L1和的容量和速率、支持的扩展指令集、CPU内核工作电压地址总线宽度等。

    内存是计算机系统中存放数据与指令的半导体存储单元。按其用途可分为主存储器和辅助存器。按工作原理分为ROM和RAM。

    展开全文
  • 01计算机硬件系统主要由五部分组成,分别是运算器、控制器、存储器、输入设备、输出设备;其中运算器和控制器是处理器,磁盘驱动器是存储器,键盘和鼠标是输入设备,显示器是输出设备。计算机俗称电脑,是现代一种...

    01

    计算机硬件系统主要由五部分组成,分别是运算器、控制器、存储器、输入设备、输出设备;其中运算器和控制器是处理器,磁盘驱动器是存储器,键盘和鼠标是输入设备,显示器是输出设备。

    5244bb0f7f9b434690e664cb54eb622c.png

    计算机俗称电脑,是现代一种用于高速计算的电子计算机器,可以进行数值计算,又可以进行逻辑计算,还具有存储记忆功能。是能够按照程序运行,自动、高速处理海量数据的现代化智能电子设备。由硬件系统和软件系统所组成,计算机硬件系统主要由五部分组成,分别是运算器、控制器、存储器、输入设备、输出设备;其中运算器和控制器是处理器,磁盘驱动器是存储器,键盘和鼠标是输入设备,显示器是输出设备。

    8f202938638e472244c8b198e2ee4aa0.png

    计算机发明者约翰·冯·诺依曼。计算机是20世纪最先进的科学技术发明之一,对人类的生产活动和社会活动产生了极其重要的影响,并以强大的生命力飞速发展。它的应用领域从最初的军事科研应用扩展到社会的各个领域,已形成了规模巨大的计算机产业,带动了全球范围的技术进步,由此引发了深刻的社会变革,计算机已遍及一般学校、企事业单位,进入寻常百姓家,成为信息社会中必不可少的工具。

    0f3a63a971272c708a67ab70f313fe3a.png

    计算机的应用已渗透到社会的各个领域,正在日益改变着传统的工作、学习和生活的方式,推动着社会的科学计算。科学计算是计算机最早的应用领域,是指利用计算机来完成科学研究和工程技术中提出的数值计算问题。在现代科学技术工作中,科学计算的任务是大量的和复杂的。利用计算机的运算速度高、存储容量大和连续运算的能力,可以解决人工无法完成的各种科学计算问题。例如,工程设计、地震预测、气象预报、火箭发射等都需要由计算机承担庞大而复杂的计算量。

    展开全文
  • 基于机器学习的车牌识别系统

    千次阅读 2021-11-22 10:52:30
    基于机器学习的车牌识别系统 本文设计的车牌处理系统主要用于通过手机、路口监视器拍到的车牌照片进行识别。由图像处理、车牌定位、字符分割和字符识别四个模块组成,该四部分需要依次执行,其中的每一模块需要利用...

    基于机器学习的车牌识别系统

    本文设计的车牌处理系统主要用于通过手机、路口监视器拍到的车牌照片进行识别。由图像处理、车牌定位、字符分割和字符识别四个模块组成,该四部分需要依次执行,其中的每一模块需要利用上一模块的结果,并为下一模块提供服务。
    算法流程分为预处理、车牌定位、字符分割和字符识别四部分。在图像处理部分,主要通过高斯去噪、灰度变化、二值化等技术去除与车牌无关的背景因素,最后通过Canny算法找到各个图像的边缘。在车牌定位部分,首先通过findContours函数寻找可能存在车牌的矩形区域并且面积和长宽比筛选不符合条件的矩形;然后再通过颜色定位的方法,根据色素分布选出车牌所在的区域;最后,再次通过颜色定位的方法去除矩形区域中不包含车牌区域的杂质边框,得到最终的车牌。在字符分割部分,先要对图像进行自适应的二值化处理使字符与背景分离开,接着通过水平直方图和垂直直方图的分布,分离出单个字符。在最后的字符识别部分,首先对图像进行HOG描述处理,然后分别对汉字和数字与字母构建SVM分类器,并将待识别的图像送入指定的分类器,从而完成车牌识别。

    import cv2
    import numpy as np
    from numpy.linalg import norm  # 求向量范数
    import matplotlib.pyplot as plt
    from matplotlib.font_manager import FontProperties
    import sys
    import os
    import json
    
    SZ = 20  # 训练图片长宽
    MAX_WIDTH = 1000  # 原始图片最大宽度
    Min_Area = 2000  # 车牌区域允许最小面积
    PROVINCE_START = 1000
    
    
    # 读取图片文件
    def imreadex(filename):
        return cv2.imdecode(np.fromfile(filename, dtype=np.uint8), cv2.IMREAD_COLOR)
    
    
    def point_limit(point):
        if point[0] < 0:
            point[0] = 0
        if point[1] < 0:
            point[1] = 0
    
    
    # 根据设定的阈值和图片直方图,找出波峰,用于分隔字符
    def find_waves(threshold, histogram):
        up_point = -1  # 上升点
        is_peak = False
        if histogram[0] > threshold:
            up_point = 0
            is_peak = True
        wave_peaks = []
        for i, x in enumerate(histogram):
            if is_peak and x < threshold:
                if i - up_point > 2:
                    is_peak = False
                    wave_peaks.append((up_point, i))
            elif not is_peak and x >= threshold:
                is_peak = True
                up_point = i
        if is_peak and up_point != -1 and i - up_point > 4:
            wave_peaks.append((up_point, i))
        return wave_peaks
    
    
    # 根据找出的波峰,分隔图片,从而得到逐个字符图片
    def seperate_card(img, waves):
        part_cards = []
        for wave in waves:
            part_cards.append(img[:, wave[0]:wave[1]])
        return part_cards
    
    
    # 来自opencv的sample,用于svm训练
    # 使用图片的二阶矩对图片进行抗扭斜处理
    def deskew(img):
        m = cv2.moments(img)  # 获得图片的矩
        if abs(m['mu02']) < 1e-2:
            return img.copy()
        skew = m['mu11'] / m['mu02']
        M = np.float32([[1, skew, -0.5 * SZ * skew], [0, 1, 0]])
        img = cv2.warpAffine(img, M, (SZ, SZ), flags=cv2.WARP_INVERSE_MAP | cv2.INTER_LINEAR)  # 仿射变换 矫正车牌
        return img
    
    
    # 来自opencv的sample,用于svm训练
    # 计算图像的hog描述符
    def preprocess_hog(digits):
        samples = []
        for img in digits:
            gx = cv2.Sobel(img, cv2.CV_32F, 1, 0)
            gy = cv2.Sobel(img, cv2.CV_32F, 0, 1)
            mag, ang = cv2.cartToPolar(gx, gy)
            bin_n = 16
            bin = np.int32(bin_n * ang / (2 * np.pi))
            bin_cells = bin[:10, :10], bin[10:, :10], bin[:10, 10:], bin[10:, 10:]
            mag_cells = mag[:10, :10], mag[10:, :10], mag[:10, 10:], mag[10:, 10:]
            hists = [np.bincount(b.ravel(), m.ravel(), bin_n) for b, m in zip(bin_cells, mag_cells)]
            hist = np.hstack(hists)
    
            # transform to Hellinger kernel
            eps = 1e-7
            hist /= hist.sum() + eps
            hist = np.sqrt(hist)
            hist /= norm(hist) + eps
    
            samples.append(hist)
        return np.float32(samples)
    
    
    # 不能保证包括所有省份
    provinces = [
        "zh_cuan", "川",
        "zh_e", "鄂",
        "zh_gan", "赣",
        "zh_gan1", "甘",
        "zh_gui", "贵",
        "zh_gui1", "桂",
        "zh_hei", "黑",
        "zh_hu", "沪",
        "zh_ji", "冀",
        "zh_jin", "津",
        "zh_jing", "京",
        "zh_jl", "吉",
        "zh_liao", "辽",
        "zh_lu", "鲁",
        "zh_meng", "蒙",
        "zh_min", "闽",
        "zh_ning", "宁",
        "zh_qing", "靑",
        "zh_qiong", "琼",
        "zh_shan", "陕",
        "zh_su", "苏",
        "zh_sx", "晋",
        "zh_wan", "皖",
        "zh_xiang", "湘",
        "zh_xin", "新",
        "zh_yu", "豫",
        "zh_yu1", "渝",
        "zh_yue", "粤",
        "zh_yun", "云",
        "zh_zang", "藏",
        "zh_zhe", "浙"
    ]
    
    
    class StatModel(object):
        def load(self, fn):
            self.model = self.model.load(fn)
    
        def save(self, fn):
            self.model.save(fn)
    
    
    class SVM(StatModel):
        def __init__(self, C=1, gamma=0.5):
            self.model = cv2.ml.SVM_create()
            self.model.setGamma(gamma)
            self.model.setC(C)
            self.model.setKernel(cv2.ml.SVM_RBF)
            self.model.setType(cv2.ml.SVM_C_SVC)
    
        # 训练svm
    
        def train(self, samples, responses):
            self.model.train(samples, cv2.ml.ROW_SAMPLE, responses)
    
        # 字符识别
        def predict(self, samples):
            r = self.model.predict(samples)
            return r[1].ravel()
    
    
    class CardPredictor:
    
        def __init__(self):
            # 车牌识别的部分参数保存在js中,便于根据图片分辨率做调整
            f = open('config.js')
            j = json.load(f)
            for c in j["config"]:
                if c["open"]:
                    self.cfg = c.copy()
                    break
            else:
                raise RuntimeError('没有设置有效配置参数')
    
        def __del__(self):
            self.save_traindata()
    
        def train_svm(self):
            # 识别英文字母和数字
            self.model = SVM(C=1, gamma=0.5)
            # 识别中文
            self.modelchinese = SVM(C=1, gamma=0.5)
            if os.path.exists("svm.dat"):
                self.model.load("svm.dat")
            else:
                chars_train = []
                chars_label = []
    
                # 数据提取和打标签
                for root, dirs, files in os.walk("train\\chars2"):
                    if len(os.path.basename(root)) > 1:
                        continue
                    root_int = ord(os.path.basename(root))
                    for filename in files:
                        filepath = os.path.join(root, filename)
                        digit_img = cv2.imread(filepath)
                        digit_img = cv2.cvtColor(digit_img, cv2.COLOR_BGR2GRAY)
                        chars_train.append(digit_img)
                        # chars_label.append(1)
                        chars_label.append(root_int)
    
                chars_train = list(map(deskew, chars_train))
                chars_train = preprocess_hog(chars_train)
                # chars_train = chars_train.reshape(-1, 20, 20).astype(np.float32)
                chars_label = np.array(chars_label)
                print(chars_train.shape)
                self.model.train(chars_train, chars_label)
            if os.path.exists("svmchinese.dat"):
                self.modelchinese.load("svmchinese.dat")
            else:
                chars_train = []
                chars_label = []
                for root, dirs, files in os.walk("train\\charsChinese"):
                    if not os.path.basename(root).startswith("zh_"):
                        continue
                    pinyin = os.path.basename(root)
                    index = provinces.index(pinyin) + PROVINCE_START + 1  # 1是拼音对应的汉字
                    for filename in files:
                        filepath = os.path.join(root, filename)
                        digit_img = cv2.imread(filepath)
                        digit_img = cv2.cvtColor(digit_img, cv2.COLOR_BGR2GRAY)
                        chars_train.append(digit_img)
                        chars_label.append(1)
                        chars_label.append(index)
                chars_train = list(map(deskew, chars_train))
                chars_train = preprocess_hog(chars_train)
                # chars_train = chars_train.reshape(-1, 20, 20).astype(np.float32)
                chars_label = np.array(chars_label)
                print(chars_train.shape)
                # self.model.train(chars_train, chars_label)
                self.modelchinese.train(chars_train, chars_label)
    
        def save_traindata(self):
            if not os.path.exists("svm.dat"):
                self.model.save("svm.dat")
            if not os.path.exists("svmchinese.dat"):
                self.modelchinese.save("svmchinese.dat")
    
        # 精确定位定位车牌
        def accurate_place(self, card_img_hsv, limit1, limit2, color):
            row_num, col_num = card_img_hsv.shape[:2]
            xl = col_num
            xr = 0
            yh = 0
            yl = row_num
            # col_num_limit = self.cfg["col_num_limit"]
            row_num_limit = self.cfg["row_num_limit"]
            col_num_limit = col_num * 0.8 if color != "green" else col_num * 0.5  # 绿色有渐变
            for i in range(row_num):
                count = 0
                for j in range(col_num):
                    H = card_img_hsv.item(i, j, 0)
                    S = card_img_hsv.item(i, j, 1)
                    V = card_img_hsv.item(i, j, 2)
                    if limit1 < H <= limit2 and 34 < S and 46 < V:
                        count += 1
                if count > col_num_limit:
                    if yl > i:
                        yl = i
                    if yh < i:
                        yh = i
            for j in range(col_num):
                count = 0
                for i in range(row_num):
                    H = card_img_hsv.item(i, j, 0)
                    S = card_img_hsv.item(i, j, 1)
                    V = card_img_hsv.item(i, j, 2)
                    if limit1 < H <= limit2 and 34 < S and 46 < V :
                        count += 1
                if count > row_num - row_num_limit:
                    if xl > j:
                        xl = j
                    if xr < j:
                        xr = j
            return xl, xr, yh, yl
    
        def predict(self, car_pic):
            if type(car_pic) == type(""):
                img = imreadex(car_pic)
            else:
                img = car_pic
            pic_hight, pic_width = img.shape[:2]
            # 图片裁剪为固定大小
            if pic_width > MAX_WIDTH:
                resize_rate = MAX_WIDTH / pic_width
                img = cv2.resize(img, (MAX_WIDTH, int(pic_hight * resize_rate)), interpolation=cv2.INTER_AREA)
    
            blur = self.cfg["blur"]
            # 高斯去噪
            if blur > 0:
                img = cv2.GaussianBlur(img, (blur, blur), 0)
            oldimg = img
            cv2.imshow(" img_Gaussi", img)
            cv2.waitKey(0)
            img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
            cv2.imshow(" img_Gray", img)
            cv2.waitKey(0)
            # 开操作和加权强化对比度
            kernel = np.ones((20, 20), np.uint8)
            img_opening = cv2.morphologyEx(img, cv2.MORPH_OPEN, kernel)
            img_opening = cv2.addWeighted(img, 1, img_opening, -1, 0);
    
            # 找到图像边缘
            ret, img_thresh = cv2.threshold(img_opening, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
            img_edge = cv2.Canny(img_thresh, 100, 200)
            cv2.imshow(" img_edge",  img_edge)
            cv2.waitKey(0)
            # 使用开运算和闭运算让图像边缘成为一个整体
            kernel = np.ones((self.cfg["morphologyr"], self.cfg["morphologyc"]), np.uint8)
            img_edge1 = cv2.morphologyEx(img_edge, cv2.MORPH_CLOSE, kernel)
            img_edge2 = cv2.morphologyEx(img_edge1, cv2.MORPH_OPEN, kernel)
            cv2.imshow("img_edge2", img_edge2   )
            cv2.waitKey(0)
    
            # #去除一些小的白点
            # kernelX = cv2.getStructuringElement(cv2.MORPH_RECT, (20, 1))
            # kernelY = cv2.getStructuringElement(cv2.MORPH_RECT, (1, 19))
            #
            # # 膨胀,腐蚀
            # img_edge2 = cv2.dilate(img_edge2, kernelX)
            # img_edge2 = cv2.erode(img_edge2, kernelX)
            # # 腐蚀,膨胀
            # img_edge2 = cv2.erode(img_edge2, kernelY)
            #img_edge2 = cv2.dilate(img_edge2, kernelY)
            #中值滤波去除噪点
            # img_edge2 = cv2.medianBlur(img_edge2, 15)
            # cv2.imshow("img_edge_medianBlur", img_edge2)
            # cv2.waitKey(0)
    
    
            # 查找图像边缘整体形成的矩形区域,可能有很多,车牌就在其中一个矩形区域中(寻找包络)
            try:
                contours, hierarchy = cv2.findContours(img_edge2, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE )
    
            except ValueError:
                image, contours, hierarchy = cv2.findContours(img_edge2, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
    
            contours = [cnt for cnt in contours if cv2.contourArea(cnt) > Min_Area]
            # if cv2.contourArea(cnt) > Min_Area
            print('找到矩形区域的数量为:', len(contours))
    
            # 一一排除不是车牌的矩形区域
            car_contours = []
            for cnt in contours:
                rect = cv2.minAreaRect(cnt)
                area_width, area_height = rect[1]
                if area_width < area_height :
                    area_width, area_height = area_height, area_width
                wh_ratio = area_width / area_height
                # 要求矩形区域长宽比在2到5.5之间,2到5.5是车牌的长宽比,其余的矩形排除
                if wh_ratio > 2 and wh_ratio < 5.5   :
                    car_contours.append(rect)
                    box = cv2.boxPoints(rect)
                    box = np.int0(box)
                    #oldimg = cv2.drawContours(oldimg, [box], 0, (0, 0, 255), 2)
                    # cv2.imshow("edge4", oldimg)
                    #cv2.waitKey(0)
                    #print(rect)
    
            print('确定为车牌的数量为 :',len(car_contours))
            #print("精确定位")
            card_imgs = []
            # 矩形区域可能是倾斜的矩形,需要矫正,以便使用颜色定位
            for rect in car_contours:
                if rect[2] > -1 and rect[2] < 1:  # 创造角度,使得左、高、右、低拿到正确的值
                    angle = 1
                else:
                    angle = rect[2]
                rect = (rect[0], (rect[1][0] + 5, rect[1][1] + 5), angle)  # 扩大范围,避免车牌边缘被排除
                box = cv2.boxPoints(rect)
                heigth_point = right_point = [0, 0]
                left_point = low_point = [pic_width, pic_hight]
                for point in box:
                    if left_point[0] > point[0]:
                        left_point = point
                    if low_point[1] > point[1]:
                        low_point = point
                    if heigth_point[1] < point[1]:
                        heigth_point = point
                    if right_point[0] < point[0]:
                        right_point = point
    
                if left_point[1] <= right_point[1]:  # 正角度
                    new_right_point = [right_point[0], heigth_point[1]]
                    pts2 = np.float32([left_point, heigth_point, new_right_point])  # 字符只是高度需要改变
                    pts1 = np.float32([left_point, heigth_point, right_point])
                    M = cv2.getAffineTransform(pts1, pts2)
                    dst = cv2.warpAffine(oldimg, M, (pic_width, pic_hight))
                    point_limit(new_right_point)
                    point_limit(heigth_point)
                    point_limit(left_point)
                    card_img = dst[int(left_point[1]):int(heigth_point[1]), int(left_point[0]):int(new_right_point[0])]
                    card_imgs.append(card_img)
                # cv2.imshow("card", card_img)
                # cv2.waitKey(0)
                elif left_point[1] > right_point[1]:  # 负角度
    
                    new_left_point = [left_point[0], heigth_point[1]]
                    pts2 = np.float32([new_left_point, heigth_point, right_point])  # 字符只是高度需要改变
                    pts1 = np.float32([left_point, heigth_point, right_point])
                    M = cv2.getAffineTransform(pts1, pts2)
                    dst = cv2.warpAffine(oldimg, M, (pic_width, pic_hight))
                    point_limit(right_point)
                    point_limit(heigth_point)
                    point_limit(new_left_point)
                    card_img = dst[int(right_point[1]):int(heigth_point[1]), int(new_left_point[0]):int(right_point[0])]
                    card_imgs.append(card_img)
            # cv2.imshow("card", card_img)
            # cv2.waitKey(0)
    
            # 开始使用颜色定位,排除不是车牌的矩形,目前只识别蓝、绿、黄车牌
            colors = []
            for card_index, card_img in enumerate(card_imgs):
                green = yello = blue = black = white = 0
                card_img_hsv = cv2.cvtColor(card_img, cv2.COLOR_BGR2HSV)
                # 有转换失败的可能,原因来自于上面矫正矩形出错
                if card_img_hsv is None:
                    print(1111111111111111111)
                    continue
                row_num, col_num = card_img_hsv.shape[:2]
                card_img_count = row_num * col_num
    
                for i in range(row_num):
                    for j in range(col_num):
                        H = card_img_hsv.item(i, j, 0)
                        S = card_img_hsv.item(i, j, 1)
                        V = card_img_hsv.item(i, j, 2)
                        if 11 < H <= 34 and S > 34:  # 图片分辨率调整
                            yello += 1
                        elif 35 < H <= 99 and S > 34 :  # 图片分辨率调整
                            green += 1
                        elif 99 < H <= 124 and S > 43 and  V > 46 :  # 图片分辨率调整
                            blue += 1
                        if 0 < H < 180 and 0 < S < 255 and 0 < V < 46:
                            black += 1
                        elif 0 < H < 180 and 0 < S < 43 and 221 < V < 225:
                            white += 1
                color = "no"
                # rgbs=[yello,green,blue,black,white]
                # print(rgbs)
                # rgbs_max=max(rgbs)
                # limit1 = limit2 = 0
                # if yello == rgbs_max:
                #     color = "yello"
                #     limit1 = 11
                #     limit2 = 34
                # elif green == rgbs_max:
                #     color = "green"
                #     limit1 = 35
                #     limit2 = 99
                # elif blue == rgbs_max:
                #     color = "blue".0
                #     limit1 = 100
                #     limit2 = 124  # 有的图片有色偏偏紫
    
                limit1 = limit2 = 0
                if yello * 2 >= card_img_count:
                    color = "yello"
                    limit1 = 11
                    limit2 = 34  # 有的图片有色偏偏绿
                elif green * 2 >= card_img_count:
                    color = "green"
                    limit1 = 35
                    limit2 = 99
                elif blue * 2 >= card_img_count:
                    color = "blue"
                    limit1 = 100
                    limit2 = 124  # 有的图片有色偏偏紫
                #elif black + white >= card_img_count * 0.7:  # TODO
                 #   color = "bw"
                print(color)
                colors.append(color)
                print('蓝色:' + str(blue) +'绿色: ' +str(green)+'黄色: ' +str(yello)+'黑色: ' +str(black)+'白色: ' + str(white)+'总区域:' + str(card_img_count))
                cv2.imshow("color", card_img_hsv)
                cv2.waitKey(0)
                # if limit1 == 0:
                #     continue
                # 以上为确定车牌颜色
                # 根据车牌颜色再定位,缩小边缘非车牌边界(根据颜色重新裁剪筛选)
                xl, xr, yh, yl = self.accurate_place(card_img_hsv, limit1, limit2, color)
                print('xl为: '+str(xl)+'   xr为: '+str(xr)+'   yh为: '+str(yh)+'   yl为: '+str(yl))
                if yl == yh and xl == xr:
                    continue
                need_accurate = False
                if yl >= yh:
                    yl = 0
                    yh = row_num
                    need_accurate = True
                if xl >= xr:
                    xl = 0
                    xr = col_num
                    need_accurate = True
                card_imgs[card_index] = card_img[yl:yh, xl:xr] if color != "green" or yl < (yh - yl) // 4 else card_img[ yl - (yh - yl) // 4:yh, xl:xr]
    
    
    
    
    
    
                if need_accurate:  # 可能x或y方向未缩小,需要再试一次
                    card_img = card_imgs[card_index]
                    card_img_hsv = cv2.cvtColor(card_img, cv2.COLOR_BGR2HSV)
                    xl, xr, yh, yl = self.accurate_place(card_img_hsv, limit1, limit2, color)
                    if yl == yh and xl == xr:
                        continue
                    if yl >= yh:
                        yl = 0
                        yh = row_num
                    if xl >= xr:
                        xl = 0
                        xr = col_num
                card_imgs[card_index] = card_img[yl:yh, xl:xr] if color != "green" or yl < (yh - yl) // 4 else card_img[yl - (yh - yl) // 4:yh,xl:xr]
            # 以上为车牌定位
    
            # 以下为识别车牌中的字符
            predict_result = []
            roi = None
            card_color = None
            for i, color in enumerate(colors):
                if color in ("blue", "yello", "green"):
                    card_img = card_imgs[i]
                    gray_img = cv2.cvtColor(card_img, cv2.COLOR_BGR2GRAY)
                    # 黄、绿车牌字符比背景暗、与蓝车牌刚好相反,所以黄、绿车牌需要反向
                    if color == "green" or color == "yello":
                        gray_img = cv2.bitwise_not(gray_img)
                    ret, gray_img = cv2.threshold(gray_img, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
                    # 查找水平直方图波峰
                    # cv2.imshow("gray_img", gray_img)
                    # cv2.waitKey(0)
                    x_histogram = np.sum(gray_img, axis=1)
                    print(x_histogram)
                    print(len(x_histogram)+1)
                    # l = []
                    # for i in range(len(x_histogram)+1):
                    #     l.append(i)
                    # print(l)
                    # x=range(len(x_histogram))
                    # plt.plot(x, x_histogram)
                    # plt.show()
    
    
    
                    x_min = np.min(x_histogram)
                    print(x_min)
                    x_average = np.sum(x_histogram) / x_histogram.shape[0]
                    x_threshold = (x_min + x_average) / 2
                    wave_peaks = find_waves(x_threshold, x_histogram)
                    print("水平峰值为:",wave_peaks)
                    if len(wave_peaks) == 0:
                        print("水平波峰未找到!( Error ! peak less 0)")
                        continue
    
    
                    # 认为水平方向,最大的波峰为车牌区域
                    wave = max(wave_peaks, key=lambda x: x[1] - x[0])
                    print("车牌区域为:", wave)
                    gray_img = gray_img[wave[0]:wave[1]]
                    # 查找垂直直方图波峰
                    row_num, col_num = gray_img.shape[:2]
                    # 去掉车牌上下边缘1个像素,避免白边影响阈值判断
                    gray_img = gray_img[1:row_num - 1]
                    y_histogram = np.sum(gray_img, axis=0)
                    # y = range(len(y_histogram))
                    # plt.plot(y, y_histogram)
                    # plt.show()
    
                    y_min = np.min(y_histogram)
    
                    y_average = np.sum(y_histogram) / y_histogram.shape[0]
                    y_threshold = (y_min + y_average) / 9  # U和0要求阈值偏小,否则U和0会被分成两半
    
                    wave_peaks = find_waves(y_threshold, y_histogram)
                    print("垂直峰值为:", wave_peaks)
                    # for wave in wave_peaks:
                    # 	cv2.line(card_img, pt1=(wave[0], 5), pt2=(wave[1], 5), color=(0, 0, 255), thickness=2)
                    # 车牌字符数应大于6
                    if len(wave_peaks) <= 6:
                        print("错误! 车牌字符小于6!识别的数量为:(error !peak less :)", len(wave_peaks))
                        continue
    
                    wave = max(wave_peaks, key=lambda x: x[1] - x[0])
    
                    max_wave_dis = wave[1] - wave[0]
    
                    # 判断是否是左侧车牌边缘
                    if wave_peaks[0][1] - wave_peaks[0][0] < max_wave_dis / 2  and wave_peaks[0][0] == 0:
                        wave_peaks.pop(0)
                    # 组合分离汉字
                    cur_dis = 0
    
                    #组合汉字
                    for i, wave in enumerate(wave_peaks):
                        if wave[1] - wave[0] + cur_dis > max_wave_dis * 0.8:
                            break
                        else:
                            cur_dis += wave[1] - wave[0]
                    if i > 0:
                        wave = (wave_peaks[0][0], wave_peaks[i][1])
                        wave_peaks = wave_peaks[i + 1:]
                        wave_peaks.insert(0, wave)
                    print("合并后的垂直峰值为:", wave_peaks)
    
    
    
    
                    # 去除车牌上的分隔点
                    point = wave_peaks[2]
                    if point[1] - point[0] < max_wave_dis / 3:
                        point_img = gray_img[:, point[0]:point[1]]
                        cv2.imshow(" point_img",  point_img)
                        cv2.waitKey(0)
                        if np.mean(point_img) < 255 / 5:
                            wave_peaks.pop(2)
                    print("去除分割点后的垂直峰值为:", wave_peaks)
                    if len(wave_peaks) <= 6:
                        print("错误! 去除分割点后的字符数量为:(peak less 2 :)", len(wave_peaks))
                        continue
    
                    part_cards = seperate_card(gray_img, wave_peaks)
    
    
                    # for i in range(7):
                    #     title = "The   " + str(i + 1) + "th  Number "
                    #         # 行,列,索引
                    #     plt.subplot(3, 3, i + 1)
                    #     plt.imshow(part_cards[i])
                    #     plt.title(title, fontsize=8)
                    #     plt.xticks([])
                    #     plt.yticks([])
                    # plt.show()
    
                    #
                    # mluti_part_cards = np.vstack(part_cards)
                    # # 展示多个
                    # for i in range(7):
                    #     cv2.imshow(" the "+i+" img",  part_cards[i])
                    #     cv2.waitKey(0)
                    for i, part_card in enumerate(part_cards):
                        # 可能是固定车牌的铆钉
                        if np.mean(part_card) < 255 / 5:
                            print("发现铆钉。")
                            continue
                        part_card_old = part_card
                        w = abs(part_card.shape[1] - SZ) // 2
    
                        part_card = cv2.copyMakeBorder(part_card, 0, 0, w, w, cv2.BORDER_CONSTANT, value=[0, 0, 0])
                        part_card = cv2.resize(part_card, (SZ, SZ), interpolation=cv2.INTER_AREA)
    
                        # part_card = deskew(part_card)
                        part_card = preprocess_hog([part_card])
    
                        if i == 0:
                            resp = self.modelchinese.predict(part_card)
                            charactor = provinces[int(resp[0]) - PROVINCE_START]
                        else:
                            resp = self.model.predict(part_card)
                            charactor = chr(resp[0])
                        # 判断最后一个数是否是车牌边缘,假设车牌边缘被认为是1
                        if charactor == "1" and i == len(part_cards) - 1:
                            if part_card_old.shape[0] / part_card_old.shape[1] >= 7:  # 1太细,认为是边缘
                                continue
                        predict_result.append(charactor)
                    roi = card_img
                    card_color = color
                    break
    
            return predict_result, roi, card_color  # 识别到的字符、定位的车牌图像、车牌颜色
    
    
    if __name__ == '__main__':
        c = CardPredictor()
        c.train_svm()
        r, roi, color = c.predict("car08.jpg")
        print(r)
    
    

    成果展示

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    目前方向

    在研究表面缺陷检测,对车牌识别系统改进可以联系734207011@qq.com

    展开全文
  • 机器学习并不是查询大量的操作数据去发现新的信息,而是寻找已数据中存在的规律。 2.【单选题】移动运营商对客户进行细分,设计套餐和营销活动可以使用下面哪种机器学习方法( )。 A、贝叶斯分类器 B、关联方法 C、...

    1.【单选题】以下有关机器学习理解不正确的是 ( )。

    A、查询大量的操作数据去发现新的信息

    B、从大量的业务数据中分析有兴趣的新颖知识辅助决策的过程

    C、机器学习的结果不一定能辅助决策

    D、需要借助统计学或机器学习的一些算法

    解:A

    机器学习并不是查询大量的操作数据去发现新的信息,而是寻找已有数据中存在的规律。

    2.【单选题】移动运营商对客户进行细分,设计套餐和营销活动可以使用下面哪种机器学习方法( )。

    A、贝叶斯分类器

    B、关联方法

    C、聚类算法

    D、多层前馈网络

    解:C

    移动运营商对客户进行细分,设计套餐和营销活动。首先客户是没有标签,我们需要对于没有标签的数据划分成不同的分类,这种机器学习方法属于聚类算法。

    3.【单选题】移动运营商对客户的流失进行预测,可以使用下面哪种机器学习方法比较合适 ( )。

    A、一元线性回归分析

    B、关联方法

    C、聚类方法

    D、多层前馈网络

    解:D

    移动运营商对客户的流失进行预测,我们可以将其看成一个分类问题。根据客户的已有信息,例如年龄、收入等等,然后判断他属于流失人员还是不属于流失人员。

    一元线性回归分析错在数据特征往往不会是一种。

    关联方法是用于发现数据特征之间的联系,通常用于减低数据维度,不能用于分类问题。

    聚类方法不能用于解决分类问题。

    多层前馈神经网络可以用于解决分类问题。

    4.【单选题】数据预处理对机器学习是很重要的,下面说法正确的是( )。

    A、数据预处理的效果直接决定了机器学习的结果质量

    B、数据噪声对神经网络的训练没什么影响

    C、对于有问题的数据都直接删除即可

    D、预处理不需要花费大量的时间

    解:A

    数据预处理的效果直接决定了机器学习的结果质量,正确。因为数据的好坏直接决定了我们从数据中学习到的规则,因此对数据进行预处理是十分必要的。

    数据噪声对神经网络的训练具有影响。神经网络中噪声的注入可以有很多种,如输入层,隐层,权重,输出层等。1.输入层注入噪声,其实可以看作是数据集增强的一种手段,本质是一种正则化。原因是神经网络对于噪声并不健壮,只好混入噪声再进行训练,提高鲁棒性。2.输出层注入噪声,其实是对标签噪声建模。

    对于有问题的数据,除了直接删除还可以进行平滑处理等操作使其有效。

    预处理是机器学习最为关键的一步,数据是机器学习的灵魂。如果数据足够精确,可以尽可能地降低训练难度。

    5.【单选题】以下哪个步骤不是机器学习所需的预处理工作( )。

    A、数值属性的标准化

    B、变量相关性分析

    C、异常值分析

    D、与用户讨论分析需求

    解:D

    与用户讨论分析需求不是对数据的预处理,而是明确我们需要完成的任务。

    6.【多选题】对于机器学习中的原始数据,存在的问题可能有( )。

    A、错误值

    B、重复

    C、异常值

    D、不完整

    我的答案:ABCD

    数据可能存在错误、重复、异常值、不完整等问题。

    展开全文
  • 主要思想:机器学习有传统代码需要维护的问题和机器学习特定的问题,这些特定的问题是系统层面的: 边界侵蚀(boundary erosion)、纠缠(entanglement)、隐藏反馈循环(hidden feedback loops)、未申明的访问者...
  • ↑↑↑关注后"星标"Datawhale每日干货&每月组队学习,不错过Datawhale干货译者:Ahong,来源:dataxon机器学习人人都在谈论,但除了...
  • 机器学习Author:louwillMachine Learning Lab 本文总共涉及了26种机器学习模型与算法,几乎涵盖了全部主流的机器学习算法。包括线性回归、逻辑回归、La...
  • 第四范式深耕于人工智能领域,在人工智能相关算法、应用、系统和底层架构设计等兼具广度和深度的理解。 随着近年先进存储技术的飞速发展,涌现出了具有颠覆性的存储技术,比如非易失性存储、SSD等。基于此类技术...
  • 链接:https://www.zhihu.com/question/431924548编辑:深度学习与计算机视觉声明:仅做学术分享,侵删作者:石塔西https://www.zhihu.c...
  • 机器学习算法是一种能够从数据中学习的算法。卡耐基梅隆大学计算机科学学院机器学习系主任Mitchell给出了机器学习算法的定义:对于某类任务TTT和性能度量PPP,一个计算机程序被认为可以从经验EEE中学习是指,通过...
  • 机器学习笔记(16)——推荐系统

    千次阅读 2021-11-25 18:29:27
    推荐系统机器学习中的一个重要应用,很多的网站都会通过推荐系统来推荐新产品给用户,如亚马逊推荐新书给你,网飞公司试图推荐新电影给你,这些推荐系统是根据浏览你过去买过什么书或评价过什么电影来判断。...
  • 本发明属于语音文字识别及声纹降噪领域,涉及到一种基于机器学习及深度学习的声纹降噪方法及系统。背景技术:地学数据采集过程中的智慧化是建设地学大数据中的一个基础环节,在地质生产的实际过程中占据重要地位。...
  • 现在市面上的机器学习教程大多先学习数学基础,然后学机器学习的数学算法,再建立机器学习的数学模型,再学习深度学习,再学习工程化,再考虑落地。这其中每个环节都在快速发展,唯独落地特别困难。我们花费大量时间...
  • 人工智能不是一回事。...机器学习一词是在 1959 年创造的,但随着贝叶斯定理的发现,它的历史可以追溯到预编码时代(大约 19 世纪中叶)。它在 90 年代开始流行,不应与“人工神经网络”或“深度学习”等其
  • 马尔科夫链 隐马尔科夫(HMM) 什么样的问题需要HMM HMM模型的定义 一个HMM模型实例 HMM模型的三个基本问题 前言 原创不易,转载请注明出处 机器学习中关于解决回归问题的总结 注:以下线性回归中,均可采用梯度下降、...
  • 【导读】:全面介绍机器学习发展的历史,从感知机、神经网络、决策树、SVM、Adaboost到随机森林、Deep Learning。 自科学技术和人工智能最初发展开始,科学家Blaise Pascal和Von Leibniz就思考着如何制造一台像...
  • 机器学习按照学习方式可以分为监督学习、无监督学习、半监督学习、强化学习。 机器学习按照模型可以分为几何模型、逻辑模型、网络模型、概率模型。 回归、分类、排序都是监督学习。聚类、降维、密度估计都属于无...
  • TensorFlow与机器学习

    2021-12-08 10:52:14
    TensorFlow 是一个端到端开源机器学习平台,一个核心开源库,可以帮助开发和训练机器学习模型,它拥有一个全面而灵活的生态系统,其中包含各种工具、库和社区资源,可助力研究人员推动先进机器学习技术的发展,并使...
  • 文章目录一、什么是机器学习二、机器学习的流程(一)数据收集(二)数据预处理(三)特征工程(四)模型构建和训练三、机器学习该如何学(一)AI时代首选Python(二)PyCharm可视化编辑器和Anaconda大礼包1、...
  • 机器学习的三个基本要素

    千次阅读 2021-03-20 20:05:46
    对于一个机器学习任务,首先要确定其输入空间???? 和输出空间????.不同机器学习任务的主要区别在于输出空间不同.在二分类问题中???? = {+1, −1},在???? 分类问题中???? = {1, 2, ⋯ , ????},而在回归问题中????...
  • 机器学习练习题

    千次阅读 2021-11-16 10:08:00
    机器学习考试练习题单项选择题多项选择题判断题填空题简答题 单项选择题 1.在NumPy中创建一个元素均为0的数组可以使用( )函数。 [A] A.zeros( ) B.arange( ) C.linspace( ) D.logspace( ) 2.通常( )误差作为...
  • 机器学习模型构成的三个部分是模型假设、评价函数(损失/优化目标)和优化算法。 可以把机器学习过程看作一个在所有假设(hypothesis)组成的空间中进行搜索的过程,搜索目标是找到与训练集“匹配fit”的假设。
  • 机器学习中,一些比较流行方法的包括:支持向量机(SVM)、人工神经网络(ANN)、聚类、k-最近邻、决策树和深度学习。OpenCV支持并实现几乎所有这些方法,并详细的文档说明。 OpenCV 4 机器学习算法 OpenCV...
  • 机器学习算法分类

    2021-02-16 21:46:38
    根据数据集组成不同,可以把机器学习算法分为: 监督学习 无监督学习 半监督学习 强化学习 1 监督学习 定义: 输入数据是由输入特征值和目标值所组成。 函数的输出可以是一个连续的值(称为回归...
  • code小生一个专注大前端领域的技术平台公众号回复Android加入安卓技术群选自towardsdatascience 作者:Kajal Yadav 机器之心编译编辑:小舟、杜伟经典...
  • 来源|AI前线作者 | Ben Dickson译者 | Sambodhi策划 | 刘燕随着机器学习的迅速普及,科技界必须制定一份保证人工智能系统免遭对抗攻击的路线图。否则,对抗机器学习...
  • 机器学习的数学基础

    2021-09-09 16:29:26
    我们知道,机器学习的特点就是:以计算机为工具和平台,以数据为研究对象,以学习方法为中心;是概率论、线性代数、数值计算、信息论、最优化理论和计算机科学等多个领域的交叉学科。所以本文就先介绍一下机器学习...
  • 机器学习与Python应用(一)

    热门讨论 2021-03-20 20:14:44
    机器学习与Python应用(一) 本贴为学习记录贴,任何问题随时可以交流。 课程名称:机器学习与数据挖掘 使用教材:《Python机器学习》/赵涓涓,强彦主编.——北京:机械工业出版社,2019.06 记录时间:2021.03.21 ...
  • 机器学习概述

    2021-03-14 15:33:40
    机器学习概述 1:人工智能概述 1.1 人工智能应用场景 1.2 人工智能案例 ⽹络安全、电⼦商务、计算模拟、社交⽹络 … … 1.3⼈⼯智能、机器学习和深度学习 机器学习是⼈⼯智能的⼀个实现途径 深度学习是机器学习...
  • 1.Anaconda和python的关系 Anaconda包括Conda、Python以及一大堆安装好的工具包,比如:...那么Anaconda在机器学习方面哪些优势呢。 优点: 包含conda:conda是一个环境管理器,其功能依靠conda包来实现,该环境

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 154,927
精华内容 61,970
关键字:

机器学习系统有几部分组成

友情链接: ubymr.rar