commit da5fde8f403b3547282def54f016f221020655b6
Author: karllzy
Date: Sat Jun 18 19:13:39 2022 +0800
First Commit
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..a4e57ec
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,577 @@
+### Project sepecified
+dataset/*
+models/*
+
+
+### VisualStudioCode template
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+*.code-workspace
+
+# Local History for Visual Studio Code
+.history/
+
+### VirtualEnv template
+# Virtualenv
+# http://iamzed.com/2009/05/07/a-primer-on-virtualenv/
+.Python
+[Bb]in
+[Ii]nclude
+[Ll]ib
+[Ll]ib64
+[Ll]ocal
+[Ss]cripts
+pyvenv.cfg
+.venv
+pip-selfcheck.json
+
+### Example user template template
+### Example user template
+
+# IntelliJ project files
+.idea
+*.iml
+out
+gen
+### VisualStudio template
+## Ignore Visual Studio temporary files, build results, and
+## files generated by popular Visual Studio add-ons.
+##
+## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore
+
+# User-specific files
+*.rsuser
+*.suo
+*.user
+*.userosscache
+*.sln.docstates
+
+# User-specific files (MonoDevelop/Xamarin Studio)
+*.userprefs
+
+# Mono auto generated files
+mono_crash.*
+
+# Build results
+[Dd]ebug/
+[Dd]ebugPublic/
+[Rr]elease/
+[Rr]eleases/
+x64/
+x86/
+[Ww][Ii][Nn]32/
+[Aa][Rr][Mm]/
+[Aa][Rr][Mm]64/
+bld/
+[Bb]in/
+[Oo]bj/
+[Ll]og/
+[Ll]ogs/
+
+# Visual Studio 2015/2017 cache/options directory
+.vs/
+# Uncomment if you have tasks that create the project's static files in wwwroot
+#wwwroot/
+
+# Visual Studio 2017 auto generated files
+Generated\ Files/
+
+# MSTest test Results
+[Tt]est[Rr]esult*/
+[Bb]uild[Ll]og.*
+
+# NUnit
+*.VisualState.xml
+TestResult.xml
+nunit-*.xml
+
+# Build Results of an ATL Project
+[Dd]ebugPS/
+[Rr]eleasePS/
+dlldata.c
+
+# Benchmark Results
+BenchmarkDotNet.Artifacts/
+
+# .NET Core
+project.lock.json
+project.fragment.lock.json
+artifacts/
+
+# ASP.NET Scaffolding
+ScaffoldingReadMe.txt
+
+# StyleCop
+StyleCopReport.xml
+
+# Files built by Visual Studio
+*_i.c
+*_p.c
+*_h.h
+*.ilk
+*.meta
+*.obj
+*.iobj
+*.pch
+*.pdb
+*.ipdb
+*.pgc
+*.pgd
+*.rsp
+*.sbr
+*.tlb
+*.tli
+*.tlh
+*.tmp
+*.tmp_proj
+*_wpftmp.csproj
+*.log
+*.vspscc
+*.vssscc
+.builds
+*.pidb
+*.svclog
+*.scc
+
+# Chutzpah Test files
+_Chutzpah*
+
+# Visual C++ cache files
+ipch/
+*.aps
+*.ncb
+*.opendb
+*.opensdf
+*.sdf
+*.cachefile
+*.VC.db
+*.VC.VC.opendb
+
+# Visual Studio profiler
+*.psess
+*.vsp
+*.vspx
+*.sap
+
+# Visual Studio Trace Files
+*.e2e
+
+# TFS 2012 Local Workspace
+$tf/
+
+# Guidance Automation Toolkit
+*.gpState
+
+# ReSharper is a .NET coding add-in
+_ReSharper*/
+*.[Rr]e[Ss]harper
+*.DotSettings.user
+
+# TeamCity is a build add-in
+_TeamCity*
+
+# DotCover is a Code Coverage Tool
+*.dotCover
+
+# AxoCover is a Code Coverage Tool
+.axoCover/*
+!.axoCover/settings.json
+
+# Coverlet is a free, cross platform Code Coverage Tool
+coverage*.json
+coverage*.xml
+coverage*.info
+
+# Visual Studio code coverage results
+*.coverage
+*.coveragexml
+
+# NCrunch
+_NCrunch_*
+.*crunch*.local.xml
+nCrunchTemp_*
+
+# MightyMoose
+*.mm.*
+AutoTest.Net/
+
+# Web workbench (sass)
+.sass-cache/
+
+# Installshield output folder
+[Ee]xpress/
+
+# DocProject is a documentation generator add-in
+DocProject/buildhelp/
+DocProject/Help/*.HxT
+DocProject/Help/*.HxC
+DocProject/Help/*.hhc
+DocProject/Help/*.hhk
+DocProject/Help/*.hhp
+DocProject/Help/Html2
+DocProject/Help/html
+
+# Click-Once directory
+publish/
+
+# Publish Web Output
+*.[Pp]ublish.xml
+*.azurePubxml
+# Note: Comment the next line if you want to checkin your web deploy settings,
+# but database connection strings (with potential passwords) will be unencrypted
+*.pubxml
+*.publishproj
+
+# Microsoft Azure Web App publish settings. Comment the next line if you want to
+# checkin your Azure Web App publish settings, but sensitive information contained
+# in these scripts will be unencrypted
+PublishScripts/
+
+# NuGet Packages
+*.nupkg
+# NuGet Symbol Packages
+*.snupkg
+# The packages folder can be ignored because of Package Restore
+**/[Pp]ackages/*
+# except build/, which is used as an MSBuild target.
+!**/[Pp]ackages/build/
+# Uncomment if necessary however generally it will be regenerated when needed
+#!**/[Pp]ackages/repositories.config
+# NuGet v3's project.json files produces more ignorable files
+*.nuget.props
+*.nuget.targets
+
+# Microsoft Azure Build Output
+csx/
+*.build.csdef
+
+# Microsoft Azure Emulator
+ecf/
+rcf/
+
+# Windows Store app package directories and files
+AppPackages/
+BundleArtifacts/
+Package.StoreAssociation.xml
+_pkginfo.txt
+*.appx
+*.appxbundle
+*.appxupload
+
+# Visual Studio cache files
+# files ending in .cache can be ignored
+*.[Cc]ache
+# but keep track of directories ending in .cache
+!?*.[Cc]ache/
+
+# Others
+ClientBin/
+~$*
+*~
+*.dbmdl
+*.dbproj.schemaview
+*.jfm
+*.pfx
+*.publishsettings
+orleans.codegen.cs
+
+# Including strong name files can present a security risk
+# (https://github.com/github/gitignore/pull/2483#issue-259490424)
+#*.snk
+
+# Since there are multiple workflows, uncomment next line to ignore bower_components
+# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
+#bower_components/
+
+# RIA/Silverlight projects
+Generated_Code/
+
+# Backup & report files from converting an old project file
+# to a newer Visual Studio version. Backup files are not needed,
+# because we have git ;-)
+_UpgradeReport_Files/
+Backup*/
+UpgradeLog*.XML
+UpgradeLog*.htm
+ServiceFabricBackup/
+*.rptproj.bak
+
+# SQL Server files
+*.mdf
+*.ldf
+*.ndf
+
+# Business Intelligence projects
+*.rdl.data
+*.bim.layout
+*.bim_*.settings
+*.rptproj.rsuser
+*- [Bb]ackup.rdl
+*- [Bb]ackup ([0-9]).rdl
+*- [Bb]ackup ([0-9][0-9]).rdl
+
+# Microsoft Fakes
+FakesAssemblies/
+
+# GhostDoc plugin setting file
+*.GhostDoc.xml
+
+# Node.js Tools for Visual Studio
+.ntvs_analysis.dat
+node_modules/
+
+# Visual Studio 6 build log
+*.plg
+
+# Visual Studio 6 workspace options file
+*.opt
+
+# Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
+*.vbw
+
+# Visual Studio LightSwitch build output
+**/*.HTMLClient/GeneratedArtifacts
+**/*.DesktopClient/GeneratedArtifacts
+**/*.DesktopClient/ModelManifest.xml
+**/*.Server/GeneratedArtifacts
+**/*.Server/ModelManifest.xml
+_Pvt_Extensions
+
+# Paket dependency manager
+.paket/paket.exe
+paket-files/
+
+# FAKE - F# Make
+.fake/
+
+# CodeRush personal settings
+.cr/personal
+
+# Python Tools for Visual Studio (PTVS)
+__pycache__/
+*.pyc
+
+# Cake - Uncomment if you are using it
+# tools/**
+# !tools/packages.config
+
+# Tabs Studio
+*.tss
+
+# Telerik's JustMock configuration file
+*.jmconfig
+
+# BizTalk build output
+*.btp.cs
+*.btm.cs
+*.odx.cs
+*.xsd.cs
+
+# OpenCover UI analysis results
+OpenCover/
+
+# Azure Stream Analytics local run output
+ASALocalRun/
+
+# MSBuild Binary and Structured Log
+*.binlog
+
+# NVidia Nsight GPU debugger configuration file
+*.nvuser
+
+# MFractors (Xamarin productivity tool) working folder
+.mfractor/
+
+# Local History for Visual Studio
+.localhistory/
+
+# BeatPulse healthcheck temp database
+healthchecksdb
+
+# Backup folder for Package Reference Convert tool in Visual Studio 2017
+MigrationBackup/
+
+# Ionide (cross platform F# VS Code tools) working folder
+.ionide/
+
+# Fody - auto-generated XML schema
+FodyWeavers.xsd
+
+### JupyterNotebooks template
+# gitignore template for Jupyter Notebooks
+# website: http://jupyter.org/
+
+.ipynb_checkpoints
+*/.ipynb_checkpoints/*
+
+# IPython
+profile_default/
+ipython_config.py
+
+# Remove previous ipynb_checkpoints
+# git rm -r .ipynb_checkpoints/
+
+### macOS template
+# General
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+### Python template
+# Byte-compiled / optimized / DLL files
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+# Usually these files are written by a python script from a template
+# before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+
+# IPython
+
+# pyenv
+# For a library or package, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+# However, in case of collaboration, if having platform-specific dependencies or dependencies
+# having no cross-platform support, pipenv may install dependencies that don't work, or not
+# install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
diff --git a/01_dataset_building.ipynb b/01_dataset_building.ipynb
new file mode 100755
index 0000000..228c99f
--- /dev/null
+++ b/01_dataset_building.ipynb
@@ -0,0 +1,149 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "collapsed": true,
+ "pycharm": {
+ "name": "#%% md\n"
+ }
+ },
+ "source": [
+ "# 数据集的制作"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "import pickle\n",
+ "import cv2\n",
+ "import numpy as np\n",
+ "from utils import split_xy"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "# 一些参数\n",
+ "blk_sz = 8\n",
+ "sensitivity = 8\n",
+ "selected_bands = [127, 201, 202, 294]\n",
+ "# [76, 146, 216, 367, 383, 406]\n",
+ "file_name, labeled_image_file = r\"F:\\zhouchao\\616\\calibrated1.raw\", \\\n",
+ "r\"F:\\zhouchao\\616\\label1.bmp\"\n",
+ "# file_name, labeled_image_file = \"./dataset/calibrated77.raw\", \"./dataset/label77.png\"\n",
+ "dataset_file = f'./dataset/data_{blk_sz}x{blk_sz}_c{len(selected_bands)}_sen{sensitivity}_1.p'"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "collapsed": false
+ },
+ "source": [
+ "## 波长选择"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "with open(file_name, \"rb\") as f:\n",
+ " data = np.frombuffer(f.read(), dtype=np.float32).reshape((600, 448, 1024)).transpose(0, 2, 1)\n",
+ "data = data[..., selected_bands]\n",
+ "label = cv2.imread(labeled_image_file)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%% md\n"
+ }
+ },
+ "source": [
+ "## 块分割与数据存储"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "color_dict = {(0, 0, 255): 1, (255, 255, 255): 0, (0, 255, 0): 2, (255, 0, 0): 1, (0, 255, 255): 4,\n",
+ " (255, 255, 0): 5, (255, 0, 255): 6}\n",
+ "x, y = split_xy(data, label, blk_sz, sensitivity=sensitivity, color_dict=color_dict)\n",
+ "with open(dataset_file, 'wb') as f:\n",
+ " pickle.dump((x, y), f)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ },
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3.9.7 ('base')",
+ "language": "python",
+ "name": "python3"
+ },
+ "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.9.7"
+ },
+ "vscode": {
+ "interpreter": {
+ "hash": "7f619fc91ee8bdab81d49e7c14228037474662e3f2d607687ae505108922fa06"
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
\ No newline at end of file
diff --git a/02_feature_design&training.ipynb b/02_feature_design&training.ipynb
new file mode 100755
index 0000000..2c3e9ed
--- /dev/null
+++ b/02_feature_design&training.ipynb
@@ -0,0 +1,471 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "collapsed": true,
+ "pycharm": {
+ "name": "#%% md\n"
+ }
+ },
+ "source": [
+ "# 特征设计与模型训练"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 29,
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "import pickle\n",
+ "\n",
+ "from sklearn.model_selection import train_test_split\n",
+ "import matplotlib.pyplot as plt\n",
+ "import numpy as np\n",
+ "\n",
+ "from utils import visualization_evaluation,visualization_y\n",
+ "%matplotlib inline"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 30,
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "# some parameters\n",
+ "tran_size = 10000\n",
+ "\n",
+ "blk_sz, sensitivity = 8, 8\n",
+ "selected_bands = [127, 201, 202, 294]\n",
+ "tree_num = 185\n",
+ "pic_row, pic_col= 600, 1024\n",
+ "\n",
+ "dataset_file = f'./dataset/data_{blk_sz}x{blk_sz}_c{len(selected_bands)}_sen{sensitivity}_7.p'\n",
+ "model_file = f'./models/rf_{blk_sz}x{blk_sz}_c{len(selected_bands)}_{tree_num}_7.model'"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%% md\n"
+ }
+ },
+ "source": [
+ "## 数据集与样本平衡"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 31,
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "数据量: 9819\n",
+ "x train (6873, 8, 8, 4), y train (6873,)\n",
+ "x test (2946, 8, 8, 4), y test (2946,)\n"
+ ]
+ }
+ ],
+ "source": [
+ "# 读取数据\n",
+ "with open(dataset_file, 'rb') as f:\n",
+ " x_list, y_list = pickle.load(f)\n",
+ "# 确保数据当中x和y数量对得上\n",
+ "assert len(x_list) == len(y_list)\n",
+ "print(\"数据量: \", len(x_list))\n",
+ "x, y = np.asarray(x_list), np.asarray(y_list, dtype=int)\n",
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3, random_state=5,\n",
+ " shuffle=True, stratify=y)\n",
+ "print(f\"x train {x_train.shape}, y train {y_train.shape}\\n\"\n",
+ " f\"x test {x_test.shape}, y test {y_test.shape}\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 32,
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "total (array([8937., 600., 41., 0., 190.]), array([0, 1, 2, 3, 4, 5]), ) \n",
+ "train (array([6256., 420., 29., 0., 132.]), array([0, 1, 2, 3, 4, 5]), ) \n",
+ "test (array([2681., 180., 12., 0., 58.]), array([0, 1, 2, 3, 4, 5]), )\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": "",
+ "image/png": "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\n"
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "fig, axs = plt.subplots(1, 3, figsize=(12, 6))\n",
+ "hist_res_total = axs[0].hist(y,[0, 1, 2, 3, 4, 5], align='mid')\n",
+ "hist_res_train = axs[1].hist(y_train,[0, 1, 2, 3, 4, 5], align='mid')\n",
+ "hist_res_test = axs[2].hist(y_test,[0, 1, 2, 3, 4, 5], align='mid')\n",
+ "print(f'total {hist_res_total} \\n'\n",
+ " f'train {hist_res_train} \\n'\n",
+ " f'test {hist_res_test}')\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 33,
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "train (array([ 6256., 6256., 6256., 0., 12512.]), array([0, 1, 2, 3, 4, 5]), ) \n",
+ "\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": "",
+ "image/png": "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\n"
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "train (array([1666., 1667., 1667., 0., 3333.]), array([0, 1, 2, 3, 4, 5]), ) \n",
+ "\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": "",
+ "image/png": "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\n"
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "10000\n"
+ ]
+ }
+ ],
+ "source": [
+ "# 发现样本实在是不平衡\n",
+ "from imblearn.over_sampling import RandomOverSampler\n",
+ "ros = RandomOverSampler(random_state=0)\n",
+ "x_train_shape = x_train.shape\n",
+ "x_train = x_train.reshape((x_train.shape[0], -1))\n",
+ "x_resampled, y_resampled = ros.fit_resample(x_train, y_train)\n",
+ "# 画图\n",
+ "fig, axs = plt.subplots(figsize=(10, 6))\n",
+ "hist_res_train = axs.hist(y_resampled, [0, 1, 2, 3, 4, 5], align='mid')\n",
+ "print(f'train {hist_res_train} \\n')\n",
+ "plt.show()\n",
+ "# 抽样\n",
+ "x_train, _, y_train, _ = train_test_split(x_resampled, y_resampled, train_size=tran_size, random_state=0,\n",
+ " shuffle=True, stratify=y_resampled)\n",
+ "# 画图\n",
+ "fig, axs = plt.subplots(figsize=(10, 6))\n",
+ "hist_res_train = axs.hist(y_train, [0, 1, 2, 3, 4, 5], align='mid')\n",
+ "print(f'train {hist_res_train} \\n')\n",
+ "plt.show()\n",
+ "x_train = x_train.reshape(x_train.shape[0], x_train_shape[1], x_train_shape[2], x_train_shape[3])\n",
+ "print(len(x_train))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%% md\n"
+ }
+ },
+ "source": [
+ "## 特征设计\n",
+ "设计特征"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 34,
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "from models import feature"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 35,
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "(2946, 256)\n"
+ ]
+ }
+ ],
+ "source": [
+ "features_train = feature(x_train)\n",
+ "features_test = feature(x_test)\n",
+ "print(features_test.shape)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%% md\n"
+ }
+ },
+ "source": [
+ "## 进行训练,验证特征好坏"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 36,
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "预测时间: 0.1156773567199707\n",
+ "RFC训练模型评分:1.0\n",
+ "RFC待测模型评分:0.9829921580609023\n",
+ "RFC预测结果:[0 0 0 ... 5 5 5]\n",
+ "---------------------------------------------------------------------------------------------------\n",
+ "RFC分类报告\n",
+ " precision recall f1-score support\n",
+ "\n",
+ " 0 1.00 0.99 0.99 8937\n",
+ " 1 0.84 0.98 0.91 600\n",
+ " 2 0.86 0.73 0.79 41\n",
+ " 4 0.97 0.71 0.82 42\n",
+ " 5 0.78 0.91 0.84 148\n",
+ " 6 0.87 0.80 0.84 51\n",
+ "\n",
+ " accuracy 0.98 9819\n",
+ " macro avg 0.89 0.85 0.86 9819\n",
+ "weighted avg 0.98 0.98 0.98 9819\n",
+ "\n",
+ "RFC混淆矩阵:\n",
+ "[[8827 81 0 0 28 1]\n",
+ " [ 3 590 1 1 5 0]\n",
+ " [ 0 8 30 0 1 2]\n",
+ " [ 0 12 0 30 0 0]\n",
+ " [ 3 8 0 0 134 3]\n",
+ " [ 0 2 4 0 4 41]]\n",
+ "rfc分类报告:\n",
+ " precision recall f1-score support\n",
+ "\n",
+ " 0 1.00 1.00 1.00 9537\n",
+ " 2 0.87 0.88 0.88 282\n",
+ "\n",
+ " accuracy 0.99 9819\n",
+ " macro avg 0.94 0.94 0.94 9819\n",
+ "weighted avg 0.99 0.99 0.99 9819\n",
+ "\n",
+ "rfc混淆矩阵:\n",
+ "[[9501 36]\n",
+ " [ 33 249]]\n"
+ ]
+ }
+ ],
+ "source": [
+ "from models import train_rf_and_report, SpecDetector\n",
+ "feature_x = feature(x)\n",
+ "clf = train_rf_and_report(features_train, y_train, feature_x, y, tree_num, save_path=model_file)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 37,
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": "",
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAADVCAYAAABe8ydPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABaVklEQVR4nO29ebxlaVnf+/2tvc9Uc3V3Vc8T0CCNAyJBCUpMQBn0Coma4ERj9KJRP8q9RoM4fEgCifpx4BoTDQYDBiKgohICKpcIBslV5sa2aeiRnrurax7OOXvv9dw/nndaa+9TQ+iq2t3n/dVn11nDu95pr/3M7/PKzKioqKio2HxozncHKioqKirODyoDqKioqNikqAygoqKiYpOiMoCKioqKTYrKACoqKio2KSoDqKioqNikqAygYiYkXSXpqKTB+e5LRUXF2UFlABUASLpT0vPjuZl9wcy2mdnkfPbrbEHSByV9/ynKvFHSLZJaSa/o3btB0sclHZZ0j6RflDScUcd1klYlvfUk7fxmYLbxsybpSHH/rZLuD2197lT9rqg4XVQGUFGxMT4N/BDwiRn3tgCvAi4Cvhp4HvDPZ5T798BHT9aImf1gYLbbzGwb8LvA7xVF/i1wjZntAL4FeJ2krzrDsVRUTKEygAok/RfgKuC/BQn0JyVdI8miVBsk5tdJ+kgo898kXSjpbUEy/aika4o6v0TS+yXtD1L0Pz5J+6+QdLukI5LukPRdxfW/lPTvJB2S9FlJzyue2ynpTUE6vjf0b1A8+2FJvyTpQKj3ReHe64GvA349jOXXZ/XLzP69mX0AWJ1x7zfM7H+a2bqZ3Qu8DXhOb1wvAw4CHziNryE+sxX4VuAtRVs3mdlaPA2fJ27wfJyzX5V0MMzr3w3X75b0kKQbivIvlvS3Ye7vlTSLiVU8XmFm9VM/AHcCzy/Or8EJzTCcfxC4FSc8O4G/BT4HPB8YAr8D/OdQditwN/C94d4zgH3A02a0uxU4DDwlnF8aywGvAMbA/wUsAP8EOARcEO7/EfAfQx17gb8GfqB4dgT8n8AA+GfAfYCK8Xz/ac7Nh4FXnKLMHwE/X5zvCPNzJfBa4K2n2dbLgdtjP4vr/wE4Hr6TTwDbNng+ztn3hnG/DvgCroksAd8IHInPA/cDXxeOdwPPON/vYv2cu0/VACrOBP/ZzG4zs0PA+4DbzOz/NbMxbrL4ylDum4E7zew/m9nYzD4B/AHwbRvU2wJfKmnFzO43s5uKew8BbzCzkZm9A7gF+CZJFwMvAl5lZsfM7CHgV4GXFc/eZWa/Ze7HeAvOXC5+NCaihKTvBZ4J/FJx+V8DbzKzu8+wuhuA3zGzTpIuM/shYDuuubwLWJvxbMQdYe4nwDtwJvSvzGzNzP4MWAeeFMqOgOsl7TCzA+G7qtgkqAyg4kzwYHF8Ysb5tnB8NfDVwQRxUNJB4LuAS/oVmtkxXLL/QeB+Sf9d0pcURe7tEcO7gMtCGwvhmdjGf8Q1gYgHinaOh8NtPIqQ9FLg54EXmdm+cO3puGb0q2dY15XA38O1qSmY2cTMPgxcgWs0G6H/vWBmG31X3wq8GLhL0ockPftM+lzx2MZU1ELFpsWjmRb2buBDZvYNp9Ww2Z8CfyppBTdZ/BYu6QJcLkkFE7gKeHdoYw24KGggZ4overySXhj6+k1m9pni1tfjJrQvSAIntgNJ15vZM05S5cuBj5jZ7adoesgGPoAzhZl9FHiJpAXgR4B34hpDxSZA1QAqIh4EnvAo1fUe4MmSvkfSQvj8HUlP7ReUdLGkbwnOzzXgKFCGnu4FfjTU8e3AU4H3mtn9wJ8Bvyxph6RG0hMl/b3T7OMpxytpUdIyIGBB0rKkJtz7B7jj91vN7K97j74RJ9BPD5/fBP478IJT9OnlwJt7fdgr6WWStkkaSHoB8B3A/zjlCE+BML7vkrTTzEa4L+ZxGfZbMRuVAVRE/FvgZ4I55YuKBDGzI7iz8WW44/UB4BdwJ2QfDfDjodx+3ATyQ8X9vwKuw53Irwe+zcweCfdeDiziDukDwO/jdv7Twf8DfFuIEPq1Dcr8GW4u+bs4UT8BPDfc+1ncGf5e5fj994XxHzezB+IHZ2qrZvYwdBbZXRUbCqaXK+iGf4JrKv8MuCeM8Zdwv8cfn+Y4T4XvAe6UdBg3w333o1RvxWMA6ppXKyrmB/LFV99vZl97vvtSUfF4RNUAKioqKjYpKgOoqKio2KSoJqCKioqKTYqqAVRUVFRsUmw6BqDTyAL5eGizYj4g6esl3XO++/FoQ0X2WEmvkfSfwnEnh9Q8QNKbJb3ufPdjHvGYYADhZTuhbsrcy8K9JUn7Qhz5pkGI355KMSxpj6T/GsI5D0h6W3HvH8uTuR2X9MHec1/Xm9+j4Yf8rZJ+etYPSNITJL0nJBLbJ+kXi3s/Iulj8tTGb57R97Kd46Gtuc9w+Vgm6JI+L+m6R7teM/s3ZnbWBJzwbjzp1CVPu77nyRMLHpf055KufrTqfqzhMcEAAv4PK1Lmmtl9AOZZEv8SX3q/mfAnwDfEhUkF3oXH3V+NL6Iq89PsB96Apy7owDyzZZmS+Jvx+PU/Ad4LfFNZXtIi8H58QdIleAx7yZDuw1f1/vaMtt7Wa+uH8ARo5ywPzTxJqOcQ78XTPswNzvX3IOki/Dfys8AFwMfwfEmn8+zj7p15LDGAk6HzYsvTGZcS5qgnhV4tT5l7RNKfhZciPvstkm4KEvQHy9WrfUmkr1pKeomkT8nTI98mTxVwOm3+nqQH5CmP/0LS04p7OyX9jqSHJd0l6WckNWEx1O14LvpY9hvxZfw/YWaHQgK1T8b7IXHbO3HifCrcAPx+SLT2SWBP1LoCXgHcZ2a/EsqsmtmNRVvvMrM/Ah7h1JiZAK2PMN+/KU8zfUSeu+bqcG/K9FCa3tRNk7wfeG3QHn9J0hckPRjqXjlJ+1vxJHiXlZpoqOcNku4LnzdIWuo9+5qgJd2pkO46XP8mSZ8M78zdkl7be+5r5VrbwXD/FeH6iqRfDu/EIXnq65Vwb6N3eIoBSLpS0rvC+/WIQmps+arq/xGu7ZOn/d61wby8VtPa6D8Nc3G/pB/vlf19+SY3h4FXSHqWpP8V+nu/pF+XCxhI+ovw6KfDfP+TcP2bw2/tYJifLy/a+EpJnwjvyDuA5aJf/wi4ycx+z8xW8UytX6Fu/qlybHdK+heSbgSOSRpKenX4fR+Rp9L+h0X5uxQ0WUnfHd7J68P590v6o1ntnC88ZhmA3PTw6nD6XjwzJABm9ouFdPlU4GE8x0nEd+LpcvfiK0n/eajzyfhmHK8C9oR6/1t8GU/Rn2fhSbx+AtiFrxi981RtBrwPX+26F5eC31bc+3f4itMn4KtkXx7qAU8vUP6gvwbPlvmW8MP9qE4/NUI5li145s63FJf/hGKOQ1t3SnpfIBAflPRl/xttXY3P1cwEaDPwXXimzYuAT9Gdq1Phq3GmuRdfVfwLwJPxdA1PAi4Hfm6jh0PiuhfhjK/URH8an4+nA18BPAv4meLRS0J/L8eZ3RslPSXcO4Z/p7twLeufyRPMIV8p/D78HdgT6v9UeO6XgK/CVylfAPwk0J7iHf4g8MzAyJDvnfAePMHeNaF/bw/1C18dfhn+G4pprU8Xfx9/p78ReLWK3eaAl+Crtnfh398ET/l9EfBsfHOdHwIws7jy+ivCfL9D0jNwzfIHgAvxJIDvDox4EU/N/V/CvPwenvAu4mn4Rj+E+o8Bt4XrG+E78O9mV8g7dRueq2on8C+Bt0qKK9A/hOeCAn+vb8d/t/H8Qydp59zj0c4vfTY+OCE9im+ucRD4oxllbgS+vHdtBfg48C+Kax8EfqY4/yHgT8LxzwLvLO41wL3A14dzA55U3H8z8Lpw/B+BX92g/xu2OaPsrtDOTjyf+xpwfXH/B4APhuNnAJ8o7r0xPPt9eKbMuCHJRb02vj/WsUEfvge4gyInPS45vas4/zM8lfCLcIb2E/jLvtir63XAm0/S1s+erC+9sm8G3l6cb8OJx5X09i8o5v37w/ErgC8U94QT3ycW156Np1I+WR++Hrind+024MXF+QvwdNix/BjYWtx/J/CzG9T/hvgeAT8F/OGMMg2eluIrNpjPk73D7wa+pRjvw+WcnWTcLwU+2ftNPj8cv5aw30HxPXxJUfYX8dTYsexfnKKtV5XjZvp39xvAv+49cwtOaJ9Lse9DuPcR8u/0TRT7NoRrf8kG+z2Ecf7TU/T3U8BLwvH3Ae8Oxzfjv7W3h/O7mLP9Fh5LGsBLzWxX+Lx0xv1Z9s03AbeY2S/0rj9QHB8np8a9DP+SADCzFs86eflp9O9KnBBshJltyhN8/XxQKQ+TtYaLwmex7FM4jv35JHBxIX2cwAnPm8zNP28P/e/sVHUamGWSeT/wXHnWyNjWh83sfWa2jkukF+LS4png5XQ1jVMh5dc3s6O4X+OyjYvPfhaXjrcAH1dOJ/0n4fqZovPekFNWRxwwlzSn7kv6arkj8mFJh/B8PNE8uNE7dRFu1ph171TvcPk7uRLfM2Eqm6o8Cd3b5buEHcb9Oxf1y50E5Vz356OzR4KkJweN/oHQ1r85RVtXAz+ubrrxK0MblzE7hXjEUXyznhI78E1yTmcsSHp5YX46CHxp0d8PAV8n6RJcgHsH8Bz5bnk7yRrcXOCxxABOhb4f4NXAU3COfLq4D3+5Yh3CX6x7w6XjONGIKPPb383/Xore78RV4ufjL8g1sXk8Adqo7BOeDvlegPCS/ynZNHMjX2SaY3lO+q+nZ5IxT/B2IzlN86PR1nPwH+zvn8FjKVWxpG24mn8fLs3Dxt8PdPu7D2diTysEi53mZsOTYdaYO+8N/h2Vfpbd6kaplff/Ky6VX2lmO/HMoQr3Nnqn9uHbVM66d6p3+L+T35e7gas027n5b/Gxfrn5XsTfXfTrdFCmlO7PR38OfwP4LHBdaOs1p2jrbuD1xfe2y8y2mNnv4jucXR7GXbYfcRNupgOSX+eJ4fpGSP0NJsvfwlNnX2hmu4C/if01s1txOvGjuKZzBBf+XokLTO1J2jnneDwxgI8AT5W0S77364/iWsOJM6jjnfhuU88Lku6P4yaYj4T7nwK+M0jtLyTb9sC1je8NzzaSLt/IsdTD9tDGIzjx+jfxhvmOTu8EXi9pe3j5/m+60TalH+APcWJzQ+jjt+GS319C0jaW8XzyjTy98QJdfA+ek36WdFm29VbgayQ9P9iSX4UTpptDW8PQ1gDPhb88g9DcAPxB+JGcLl4sd4wu4r6AvzKzu80zbd4LfHcY5z/lJAw5/BB/C/hVSXtDny+Xp1s+GR4ELpS0s7j2u3gm1T1y5/7P0f2OAP6lPP3y1+ERVjHr53Zgv5mtBj/SdxbPvA14vjx8dyjfg/npoe+/DfyK3Ak9kPRsueP5pO+w+Q5lhyV9Kb6F5v3Az0vaGr6j5xT9OgoclHQ5buI7E/yspC3ygIbv5eSRNtvxVNRHw2+mv9lNP3X3bwE/GLQnhb5/k6TtwP/CTW4/GubsH+E+mYg/xHef+9bwfv4ccKOZffY0x7UVZwgxs+v34hpAiQ/hDCLa+z/YO58fnG8b1Ol86O1XG669D3hN79o78N2l3oxLzkeLz2+GMh+k2AsWtw1/uDj/h3h64UP4F/a04t4zcUnhCO5k+l2CbbF49sZw/1bgBadqEzcF/XF45i7cJJJsnvg+rW/FX7i78Re2KeragRPehXD+dcBnwpg/RtjvtWjXep839+bws8D3bfA9PBW4uTj/R2Gch8MYy7l67Yy2XlvcX8b9E887g/fgzbiE/P4wvr8Ari3uvwj3XRwEfjl8f6UP4MO9+pZxhnt7GMPNwI+eRj9+G2fYB3ENZhn4NZyY3h+Ol0PZr8dTOf90+J6+AHxPUde3he/9CO6Q/XWK/YPD9/lXoX93AzeE6yu4v+Be/F39C2DlVO9wuP8LBL8YLh3/URjPPuDXwvWn4f6zo7jg8+MUvg9O7QN4JTkV+E/23ou39vrzXPy9Owr8T+Bf0f1N/mCY14PAPw7XXgh8NFy7H2eo24vf6SfDnL4jfMrf6fNDeyfw9/aa4t5rgPedgva8Hjc97gN+heI9C/d/IMzB1eH8m8P5V58rmnm6n8dVLiBJNwD/wMxuON99OZeQ9Of4nq9/fg7auh0n2nec7bZmtP1mnAj9zKnKVmwMeWTYvzKzv3fKwhWPazzeFja8B1cnNxteh2s85wI/gavBFY9d/CXuO6rY5HhcaQAVj31IuomuQzXiB4Bv4BxoAJJeg5sC+vifZvaiGdcrKh6TqAygoqKiYpPi8RQFVFFRUVFxBqgMoKKiomKTojKAioqKik2KygAqKioqNikqA6ioqKjYpKgMoKKiomKTojKAioqKik2KygAqKioqNikqA6ioqKjYpKgMoKKiomKTojKAioqKik2KygAqKioqNikqA6ioqKjYpKgMoKKiomKTojKAioqKik2KygAqKioqNikqA6ioqKjYpKgMoKKiomKTojKAioqKik2KygAqKioqNikqA6ioqKjYpKgMoKKiomKTojKAioqKik2KygAqKioqNikqA6ioqKjYpKgMoKKiomKTojKAioqKik2KygAqKioqNikqA6ioqKjYpKgMoKKiomKTojKAioqKik2KygAqKioqNikqA6ioqKjYpKgMoKKiomKTojKAioqKik2KygAqKioqNikqA6ioqKjYpKgMoKKiomKTojKAioqKik2KygAqKioqNikqA6ioqKjYpKgMoKKiomKTojKAioqKik2KygAqKioqNikqA6ioqKjYpKgMoKKiomKTojKAioqKik2KygAqKioqNikqA6ioqKjYpKgMoKKiomKTojKAioqKik2KygAqKioqNikqA6ioqKjYpKgMoKKiomKTojKAioqKik2KygAqKioqNikqA6ioqKjYpKgMoKKiomKTojKAioqKik2KygAqKioqNinOGgOQ9EJJt0i6VdKrz1Y7FRXnEvW9rng8QWb26FcqDYDPAd8A3AN8FPgOM/vbR72xiopzhPpeVzzecLY0gGcBt5rZ7Wa2DrwdeMlZaqui4lyhvtcVjyucLQZwOXB3cX5PuFZR8VhGfa8rHlcYnqV6NeNax9Yk6ZXAKwEG8FVbGLDABCHWMIbABBgBbaiwCZ94PTwL4dykTsOPvnHrJLBui8L7NukVWQLWw7HwPk/V07skumNRUfRU6H8R53RO+jAQlr7D+J2Cz9UIWADG5H7GOWzw96AsvzWUaxBLYeKGCKPFBOtNw9rui1hYXOKR++7eZ2Z7vsgRnPK9hv67PfiqLez4IputqJiGBgOON8cZrR+b9V6eFs4WA7gHuLI4vwK4ryxgZm8E3giwZTCwb2eBfSa2MWGEGACfkxODCbCCGAEngB3APomDiCfQsmDw0aahkVhAjEoKGY6FMAwZDDDGgfAm4mqhsAyz2b/0DswwVFBjY2jGCCdO2w1GgjWJiQRmbDFjGTjQNCj4XpqCAURKIoDAzCz0vTghsjnr057EhJTL9bhH6HUqP1UHInS386CZl4z9NbOij+bEXcpTHu+FcZr5cWMtC8AaYhcGZhzFX5B9ElebMQEekFhHbMM4jjPNIc5ArwCWzfgyM1rgQgbcS8vVtoMv4TgHGDECPrm8hQMv/U72XnUtb/m5H7trg2/yTHDK9zrMTXq3d+gC+2o971FouqKihxb+avKBL6qKs2UC+ihwnaRrJS0CLwPevVFhA04wYoe8Q/sD4d8CrAbCfxQ4gBOAfcAKYIKHEPuAgVmSEmGagCFLbY2ZJrrp7DRFZBMFc4lNOBMYAMcEa/JrsegQOCKlNjSD+HeJ9cm6NqOjAhSJf9G3guJ3NKQpTSMS90DwzcJxnM8erPu3r7xEphG/i4VAsFeBZYwVnLA3+PfbAHeG+5cafJkZV5lxjRmXm3GpGVeHzlxjxnXATla4B+NLreFSGj5Lw5itXM4ypiaN51HCGb3XFRXzjrOiAZjZWNKPAH+KC8S/bWY3bVRewD5WWOIYh4D9wFhwGGhwiXAJ4xiuDRjiOLAYiOt6qCeaiobARP0ffhCFexLxLPOKMdMS42ML15PkixKRW5dLz5OSwQia0MCEaN6wZP6IDCv1o9AoOhzGlZNC+p/ulKJEX0riGw10qpK+NhA0IRVU3nzuo4bgvCwzVlkxhkCo/brRGIzM2IozgZHEEWAocaHBCYyJwQVhXoYYtwEXA18GfBa4wIwLWOB4YOGPAC3H2csCrYYctSX+AeJhjnMLE47ZElGjeTRwpu91RcW842yZgDCz9wLvPb1OiB2MuIUBVzJhC3AEl/SfhOvdi4ht+K/uILALEhHYI7f9ruMXJ5JL3lJiCrlj3WPrEcYBTD8T0JVuuxUuYsEvoalnhCEzToTzgcW2AgNRyQiy2SabYuL10sdQmIGixK98JzKxPifodvskorHF2tUbkSWJ3rJ4H0bpxwptmrnJbQFjYkaDOIbYijPD6Ms5hLEVZ/aHgGvw73/ZYBtwLMytgEVGGO55XTPYomW2WMuaBjydY3yOdU4grmKBj9DSnIFWdzo4k/e6omLeMRcrgccY92JcbhN2AEfNieRVBkcMLkZMMLbjhOFi4BjuBBwDDwHrpa0jmBpKc5CZFUSvlGr9PP4/yncA70ckqE2sq+h7PB4Dgw1EzYUkGYsBbiKKjKYNZq9kZ1FJr5XMRDbDWt9FtklZ56yHDtEur1vncmqvMAcNzBmZtdE81BamojyXLZbMP21ocjkwkgVgGdiKWAzzBrAn3Lsa/27XgatwJrGG+30uAZZpuBhxH3CJYNXWMYyDtsZHWOUhjH2MWLFFdtPQmtGehbUuFRWPB5w1DeBMMAAuY8yYAQOGNKyxH7cFC5f4nYgYJxCPCLbjhKKFJB1GQj0Ix2ODRhYiTrLTdwiMEiHvUXQZQwvROxLjcF8oEKssE5fCdSR0cTzpXN6PCSTCu4JxtIhYmuD+gCYSq2DH7zhsUbAKlTL5NCvqS+uhonRq1pIKBm4WnbfJoBMcHOowy0Cso/PaYCHxW2OkcmaKJgQjxCiMpQUOAS3uEL8wOH3vDuUfMmMgsYJ/7w8L7kRcAuwwuBl4WGIQfC33ydjGAjtZ5ZgZ17KMyfgsh9muLRwN32NFRcU05oIBtMCeBhYnLfsZswY8legshE9iXIG4ixhWKYbAPuRagbruzRaxgDEULJg4EW8IzBSMCBZoYI5kiXbsKJWqlByVGcWUfR2PjonhjS0URKeQ3SUWgmS80LZsRzzSOMMwyUNClevvCuuRwDdFvflWOu5pEOVhUjJ6JiEVZjAFs5iCvT8yCkkpogdcc1kPZh9JKeontRrPLY89Pt0CO8P1AbAIXGse9TUMmkFrzuQP4xFDDwjeg3FhqOUBOUNexjjCCQ6b+32uQCwAN9OyZP4uDKsCUFExE3PBAEB80owGYwuTFO+/DnwoEI79eGfHuLngKB4qOo4CrgIhC9RtPfzoJ+q3lM0xGAzk5qJgSs8FpG4kkRU3bdocE01Oqf5QZhD67bZ/d4auYewMpiAZLKlgUiE0pxuhk2xImLphnGlcMz2+VpwXh1KS75uGbGaybPO3gpGkWmZI0orcorym6BiPbvIu42mBgxLLZqzj5p2bw/WLBYfNbf+fF6xKLOHf+yNNw1qYwyGwNfgMDPcRXcsCC6yxivGliI8GwaAf7VRRUeGYCwYgYE/40V8B3I8ToP3A0zCOIB7GJcVduM9gG04U2imjQxdW0kBzuXmIm2WiI7MQgAtzSZeoWeemY4HAaJRNS3ERU2kaWgmPrmAhqklMTIzlhGvUqdVS86VMHb0UkReo02tlH0dhOlLBxEriHQ1YKuYEpgl81Ijyg5HbWq47rJsoNY9+ANOCGQvmDL1cf7GGmDRi1WCXjKMYhwKjOIA7g+/DfTzLwJYQZrsYKp/g/pULgEtZZI8ZK4iBFnkKLR/BNZVx1QAqKmZiLpzA4M6/B7XA51hkN0qOwtuCpO/hn273XyNL2yNi2CDTHlroekMVQi8Lotdq+hFCnYMZ10uMSOZ6IK9uXejZ448DRzAO4usa1gXjRhxr/HgEIWLG/Q9mBFORdQgpoVx2DkdSntjDjLF0+9KofDabZaJ5Z4pRxP9KE0+PUUjTkUK5nBjLI7TMYFg4h9vQl0kjHlFDqwEH1WCIwzgzXcO/h91mXGnGszEuxzghX0D2RImnsswO4FJGLGHsYZ330KaVw8OqAVRUzMRcMADD+DhgjBjSMpBxPMi4A/IqUMMXh7XBbn8UJ5QDoDXzCJsUjeKUXSVlNI81V5SkU6z6NNlsyWkcTleAjM2UC80UFqhtDYTwUNNwXA2HJFYLAjwgx78vmLES1jhETSTL+jPSXcRxRvVgig/2InwsT4qgY9vvZ4dNp7OsSQrEv/gkplIw4xjttDW0t5XAsHs2JgMOCg7JV37vB44FzXAvcJUZ28y/l13m2uDFZgxZZZV17mYJw9ijPXzJQIGB+3deUVExjblgAANgL2InAy5kzJ04sTgCXIgTjAtwW/Eo3GsxLsCJw8DM7cRGCEGE0mhj6Z+vJF4Kd1xa70rOs2hFlJejvexUk1aGRi4KBsGWPZGYIEZKDguyFO+Ech2YBDNRdxRFZ+hqB50SocrSC9CfgzQv1vc1lHMRFpMpf6bZT3+WvFz04ZSMdSJhatgR2y0mXWS/Rlwct4LPmQSHJVZDyYPAXXiAwB7gasQCi+xC7Nc6l7OF5fY4ixN3EhduoYqKih7mwgcAbuNdpmUFj/8+AuzFgvlEbMFSugAhjiKux/0FQ7k2EAn6SHkNQESkASOVErqbXNbDMcE1OkQpEohUsogOgs4irXgtrlpuYm1yO3efZpbJ7RSeaUvSqhwCmzQEcyk6FrBe49Gynnhf8LymOqKJhy6T8/N8NR2JzB1Ed7AzkVmVEG2m7u4oxkNf3QRnPt7AzOJ8RRPamsTdcq3mknDvELAi2IZSlNI2M+4ElhlyC2MmGOuMuU9wTC0XSRzIs1JRUdHDXGgABlxJywEsLO8XR83V/3XzNBALDGkQe82J/NMwDuOEYRR8Bi1OcJNjuEN4/aTFzTKLYeHTOu5cLh0FfeLfx4RMD7NEbSHW37nqForJTRQ1d8hw+mpJxA7rB+Tjn3Tq7pqAun+781hejM9tKABrY9KYjTmWB1vWO+PByGgSK5lhGopEPufHDPfC9MR1HdF+fwDjCW3LU82Z4seDFrUtlFllgU9znENqGSM+o0U+jDPMW6IZqtL/ioqZmAsNYAXYYkMuZUJDw8TEAmPuFHyFwX6DRzRhDdgdQiYfRtyJh1C6I7hP5nJ8f/wLsBiIQVwsFiX7M7ES9KXoeNWixC043quxdBaXz5YEehLLhP+iNL+gED0jUJMjfjILCCS3Z9IpzUAdhEabdD9I75HOl5pGeKC/+GyWWaVYKtEZbFfjEI3gRGKIlkJ1YxtRe2sxFnGG/6DgUGBYh/Dw3yOI9fDtXQ1MGHCII4xZYEg072nazlVRUQHMCQMYA3sXFxiO4EFrGLLGEuIq4Kj8/lGMrYgHwjMNmXD73gGlCQKceDmVjIu9wGjlydpiArkNt8RUTCBN1wE6RdDy9Rj/PkuDmBVlU/a3bKJbu3l9Ki3wvh7AhfNCOtc00e+Gi3YbKReoFR3F4iKAYGopO1syrBTb35+X0nJU3pD3dxy0g9i/tPqgR6cHiDXgLvMMsW1Y/LUeTUj4auI14AGMixlxFNjNiI8HhrFTNlVvRUWFYy4YQIv4mIk71PI1NuQgLuWv4sR0AbEbYw13+sbkaVvktv8hThwcXVNLkpTDf5OC4Pslj2dfIOcByiGPPeLZs/kbwY5vOWJIREZg0+VV0sJoLS/6UpZOxFydJ1rrUVqVrCPXWWo+Kust2s5Xy452zVTl4Atan5kHnUFRsql4qQ1P+KKx7j3hhH6i3P/YjRg6ek+wpY2K72o7xh5gJ3BbePIY/i5E89LEoLHqAaio2AhzwgCMJ9qEBVo+zyqmhkXE4UA6ojP1KDF1gDghTwexgjsNPXok2pxJEmm2SEdCVRJBh1QsFjpZyEjBD2LxdvbtJNFaSKOwAL0FX9PtdFlCZlw+pibn8Ske75hdQi3JFq/upjKZMRWqQqEFiNK2b937U1MRtQSlcuoWSI9LMDQ322SJP2sq/h3nB/ra0DrOJEAM8Q1lYsqOw7j2twW4ILCTEWNPNCdAbY0CqqjYAHPBAAbAI+Nt7NM6BzDGtBzGk74tQUqjfCGEHEBOAFq5nXeVGFlTSLYzLB+zkEwwBQHqsIdZRu0OohQ++340+aynEjPKhbZjqynkUpkhzBpO1BCiecv/73KEDaego0XQte10G+iUyyunS20jVNmzKJXMJ2+NaYE55RIWK07E381QAzxwNX63S2Y0IYZ0iEv/OzGWzaV/MHYDjyCuwrjEPGndhma+iopNjrlgAIY4yIhdNkSM2J4kyoY9GA/iMf+PBAq1iDEQPBTUg9YopDyXcEtJvC/cp20Kiz507dWBGgYbRUqQlltI5iNw6dSITGjGZiydXhSdDf1X0Z9I/PuWleRDIHfROmMuZef8XBx4lrA7A879IOb3L+q1gkEWN6bJqfX+QrnRQrmYbFYffavOrrEKM8/EipvZtpmxjC/qiprfLuBKxAmcIVwGXMQEGDC2ll24Vljpf0XFbMxFGGgLbGGJBQZcgbFIww48UVjcJHwCrGMMCZuHmG8KsmSE9Z8BQeKLaRXSRUj7ApQCb6J1fSoRCX7BE5w+FuJtwJjeVpRxIRj4xjQxbz5xi8QspcfVyA1RWygk8mKlcrlFYzKcBIIazSjTA1Am/uE8moK6DMqiYO61hXz/uY043Gy0EUKNijH027f8R71rvX7KYoqIzOQW4l2DFXP/zCXm60XA/64Cd9mQvYIvSHwUscqAbTRcTcMqDS2ef6miomIac6EBjIB7NeJKW2M/4n7EEbkPYD+eFmAfnlOnwaM+Dsvj91cxBh1DiWNI3qGrb9kY0CVFG5GHUlrt+Jinaiz1jeLKVBqHPj30s7a8XhjiY7I1mYq+eMmU8C3WKrqS7hSfsnQhN2HF3VJaz4S/9A10bOmhnjYqS5JrXtZ2TUHK48r9U2cazTzMNc2e8ire7fgeEBPc9Lcaen2IEA2kMcfUcBR4MsYRg+OMeQTjeNNyQTOgaeZCzqmomDvMBQMYYlxvLXcSV5BOOIbngxfwMMYT8AVfO/FtIC/BicHh8FeW/gNIawPSitSCOJaEuJSom3CxnaKmGamFQBEtGMWtUyIjagYeqtolyE5gI4EHaw0p7xccF5Z1+U1kdT2bFBQbu5TajUo7Tmo5akO5xtn9j87kaCIqU0eX5XMTgYw3yhpMMj8ppezutK2wuhdlU1vo79GizvvC3LQGDS2LiC3AUYlFjC+YuEsTjsojx9bV8GzVdNAVFRthLhjAEg0XDlqOTFqWTOyTsSvYeg8InomH9n0BJwjjYFEf4k7iFoK9OBNFmVI+ITdfx8RnpL2DIxaBdVM24xS3szWmvJojbdID3miuVHTs4Ll4EKUtm5gacsKy5GSNEnFHku9Rsq7aQMcDkYXpwrASzCw96b/MazEr53/SBLITpTvs2FijFHbZKK5ViGWz2UgSbRvbi59matMZyZLJLrbUhr77xj5e73owoa3iTuDtBsuC2yEk/6uoqJiFuWAALeJ+drLEMS5Xwz203Cb3AezHf8BX4rt/bcfSitCjuCNwDWMZX9zVEvLyy1eKYjCUS6ETMxYwxsr7ak3whVaNyo3ZC8hzzrs5yYlTTFjW31B++jhfSAGcKTQzL4AqHczgxD+zm5KYZzNJzuiZ70dCHwl1lK4jX/IcOnFTmUB5CyN/NsF0ZyE+H1chJ15oWetoIgGPvWgU2gptt20aQ/dvt89pDgr/R/eGE/0t+HqAIcY15pFiOzBOABcGzW8BjyGale21oqLiNJzAkq6U9OeSbpZ0k6QfC9cvkPR+SZ8Pf3cXz/yUpFsl3SLpBadqY2wTHpkcYB/GTUy4S8aTcFv9tTh9WguE+l58MdRhnKjeh5uGToRzLCdb885kjQGJUbgzCZ+YDsEnIxCijvPUE8gVE+KpC0qHqornNkDr80KT6g5EUEHaLxy13u3YD5emB03DoGlomiZJ0Sm/hNITjkg8zfIG7mRHMsXffEwi6JHNlOaqxCgCY0tMZcpiVJSNzyafhtFOWqxti75EU5xhbUsbPu5LaDt9jm035umyL8al/bXi+7zEPA/Tonk+oMZgIxvQuXi3KyrmGafjHRsDP25mTwW+BvhhSdcDrwY+YGbXAR8I54R7LwOeBrwQ+A+STrq3ylDia5sFdrLIwzRMgOPmWUEX8ZC/fbiZ51J8AdgwyHUDZeIKBBu+S9jhNBHZdEElgVOwQeeEZJGuFg9kQg+BpiXDO9HbGetcCH9nDXrKpA+BCMe7RclIS8sPmaDHfvQJfNv5Gwhp206VMzPa1jp1+DnpXpuIcqgr+ALapIHEelomkwmttVgb2g71xePYduxfHLs60n6s0w8b8/j/BTz8twnPLmCsmrEXuALjCRgXATsEWzCuSTWd1AR01t/tiop5xikZgJndb2afCMdH8O1bLwdeArwlFHsL8NJw/BLg7Wa2ZmZ3ALcCzzpZGyPg/7M17teEI2rB4GbBHXju9/04A4irgSXRELN2Bqk6HOd/FPZz/9eURFyR8M8adPdUxeUpx2mgVCrs/yOmbWtd6XzWLEyL1FGaniKciTF0JfluNVG6z2U75WK/ijnJz7SFiSkmzsttlQyyNEvFkcb+FgNJZRMHLcY4ie11xmDJNBZTSK+ZFVlCxXHgQYwT5ubA4+b7CR8K870Y6ms1c8LPybtdUTHPOKP4OEnXAF8J/BVwsZndD/5DwjdtAv8B3V08dk+41q/rlZI+Julja9bySdZ4iAkr5gt6thqMzB/cijuBYwMLZsEBGM0+xoqVm5C4XWExiPRZ/uxJgz2CGIXwTPrysc0qG63L6Va2No+gWP2aywMMsCmptGwzmWXokEqitF1K8snUU/TBpek40YXWEJhI+ALc8dpE233hJk7Mxe3/MUx11ora5A8IbUXTVtNkxhLXODTJvBRztzqRz5pNHkPcknMY5nKMx/6vmKfd3mm+L/QFuJa43eI2nuJiG7KMmxGBsB/ByXG23u0Ra6dsu6LifOG0ncCStgF/ALzKzA7PihaJRWdcm6IcZvZG4I0AuwYDew7iSQafZMACYy7Ak3yt4GGfvi+wO4bjhi5LuP1XwKq6pl4zK9Iv9Nv2LpkPLPoznXCW57lwGoSKm6meIopm1kTkuryPI6JEPXui8twG6tpRGoLpp2AZse/ejUzK6Y6kGH/eJN5LxJXCJdsr5ygPvmuq8tTOsUxabRy0ish0Goz4f3R8l8PrTGqa3LwP9DAUa8kLwY4Al/qwWcSFhKvDvG4HHrGGE3gOog0UgISz+W7v0AWnaL2i4vzhtDQASQv4D+RtZvaucPlBSZeG+5cCD4Xr9wBXFo9fgftqN8Qi8OW2kwmwnTG3A38r8bDE7TiRv4QY6eE5ga4MWoBLl91fZilf9399itIm2RrRseeT6VK4mP70rBedFkvE/X1jHQOLqQ4A8xz3s4h/2WLizIXEnwh+spkHEm1xYAUR7U5I6k1iLW12ssYRW+8R6zwf//ZiaqImUcwd0X8waRlay9hIfoikMpWdKThcDGTNewJkM9AwSPmLZqzgL1zkOfvw3eEuBy6i4UoGnjcIm9odrtv9s/tuV1TMM04nCkjAm4CbzexXilvvBm4IxzcAf1xcf5mkJUnXAtcBf32yNk4gPsWYO1jkFvxHvYhxjGi/h5sRh/Ddvk4AB6WwqYjn92+TRKsUWtiHx5Qb03fVoUldudmIET8buhOttG8TtnjMppNJcDJHrJ+M+uMMI+0poDieeDrlng4MsEmSd9RqykHFBVjlGCza+9sOuU+mG3XK5TKdHrhtqOAYXUl+FPsU+VSfMYVnM8PMzzd4vv8F8x3cmsDaB2RN4Om4lrgkd76vA8dZp8FSio6NUkGci3e7omKecTomoOcA3wN8RtKnwrXXAD8PvFPS9+FrtL4dwMxukvRO4G9x0+0Pm9lkqtYCBmyj4UFaduCZHQ8FJ99RwS5Tyvp5L07wh3gEUBzExCxTlw4hio34eSdElB5Boms8yfdtqrrOM53QzWnTTl867htoosQf00WP+0SyCbH8HUIcGE4w+USml3MdlWGhofgsCT6ak07GkyS602RAE5zvoU/lIrHQl2hVimatMuldl5lYWiVtRiL0Q/Pw3+gLwEhR/Qdwaf9j+J7QSzQcY8CdtEyYsIVxEgraXu8LnPV3u6JinnFKBmBmH2ZD0ZfnbfDM64HXn24nGuCztCzh3rZbzVdyRonugMQ1ZjyEx3gvBMHzQjMextcBdMxAkbJ2bTn5crSBz7DdTxt0Z9PGmdZ16xLXtAdASa97zzmtFKOCMTgNLVSS2Acrnup0YAbT2bCT4XJB1NXrd3b2egVNKB8baUxh4ZwlppQNTEr970QNqcGsN9/xtMd128TC/AWNcf4DuZO3NdcMlnDb/yGDrbSshXfoYbbyJI7xub5foYdz8W5XVMwz5iJLVgtchnENDUdZ5qk07MXt/ivAbvMVnjvx/ECLGIPg7DM8D4wCZVVBsbs27cLGXYaD+oVOfzpEWt1jp72aIpjWI6KQN5wvY+C77USCaSzhK1sjBsBKiM4phf5sl+l1qjCg9PufKT3QMRHBlEZQFg/lM/Pxylr5mow45mR2Ktrqzn2244cEomlTl3Lqp56Ra3sL+HsQtbcrcMI/AC7GhYatiCsZ0mBcwxq7WWAnShFOFRUV05gLBjDE+IKOcRNjBow4TMPnCat9zYnFAjkkdGye7KvFCco41CEspRGGyAyCqSFpCF2ikGzoU7Z1uucuNkMnM2fs//RERtq2XlxYCO2VpYaFKSSVlRhLnuQu1ZbbLNae9el/amtDo0ccdWEu65e1koj37UVYXvlM9jk0apKJK5l3Co7QWpv8IkAK441Di9J+bEfAusUVvmIFuCh8ncuh1jXcA9sCxzBGTLiMhpaGQ7QsGacVAlpRsVkxFwwA4AkGYxp2MGEJsRLMHGPB/cpmgGVgNx4PfhSPCIkWhJZIRKP5pCvtJnJUEL1kJJiK8S+OOzRk2qxQ7gcQMYvsxORlZV0xkmmt6GHsZ0HyixQNPWqfRP7MSDaKYsykuVhARo/GFxem9aI8fyWhDzUmBlveKrNVNFH87zOscBrNPIsohX6Cz80BPPSzxbgX2ANchLFu7jPy/aMHtAzYidjZtAxTDGhlAhUVszAXDGCM+LzENYzYjXE1E7aEyI8t5hu77AjE8iH8x74TuNicGQzIG7obceVqiSBHR9E5UMlBeKJvmpkiF4lWTlnvp9ChbT2tYlbpaN5o0pW+fqGuGaq4nuz8na5uQNR7fZsyFc3ArHvWayOZgMCZbZMzfkpNmgOFPEYlg4s1qqjLmbhH8CyRNTsBJwRb5ULAYXyHuEF4xp3IY06wnSMMuLDdya7xYGoBX0VFRcZcZAMVRkvDmBW26gSft4aL1LIPuAiX/nYDJzDWAtG8Vy4lHsbNQaPC3OCbAuaVuMmWHePpAzEvJeyM7orhlK3T8l3NINMR7jAF6xDoKBuXfls/Ginul5t9F0qdjj3IHcpS9izLvVG2FQefN44vnik0p6m+5VZTjR3/iWWJP2omaYFX4gWND2Hiz+Z0HRbqyP6D6Agu+2xhxe8irgEsEE09osGStndcsMV8s6D9wBKHOEbLNla5XVvYibLmUVFR0cFcaAAt8HdpWcFYGsAuJhxgyGU4AdgZiM0C8KW483clLAZqCStrC7uD4WaZjoRbWG5isra40rRvkugTQ3/Miir8KJkpivj7VlFe3VjCToSzWHWcVuNG23oqE5WWbOxPPVHBHEIZddopVjUXXCSuFi4ZXcdQUoZUFdqHivay41dpIW9OSZFTT0RMJhPG40m6Hn0vA0gpImKfIGzmIzge1lC0eND9VlwTAGcM0fS2Ll8o+BRa9gAnaGk6u8tUVFT0MRcaAIi7TYwY8pkRjGTssDFj4JBcshviUt4qhMyQnvTrBEHS75lbpohbIcXHOPsoK5flyjr6x31iHpPRRQJYysyR9Po297mOBiduk1MaX5reFev0N/s2vZ2pdAflfKhgAlbcCwQyrg9I5ppi5Opf7zCt3NtcIK9ASInrEmGPKSgUTDYhtXbncaW+DiGsC4BWcLvBSqj/ELAXYyvuLH+iuab4+TBPB4CHlXeVq6iomMacMAAQOxhxlAXtYBdHaDA+hed32Y4T+6OIS8y4Nwh2J5gtwXak6qINI9G8lKsGCvt+NCNZ1wzk65xixswZjIWQVbSTGc3rTgucin60qZPdO/FpJZG6w6noGG1KM5Z16y/ry/NbmsItMKw81tRMuairV2tuK2sgXRVL2QykPB2JOaUVwcU8naTv6/HhUGZBHhE0MGOHfE3AATNW5eGg11vDLhaY0LAPcUmq7WTJICoqNi/mggEMgQWdYGgTFlnnYflWjqsGN+IS/xhP//ywxEH8B++SoUK6YFCw9fqm71kPKJlAE2Pr05WS/BQ29ILWllE1/XDR8thm3UBZwi7uR0JpxXZgyfgzJbJGqXuaVEY+kkl2v39WXPPn8ybzlsd0ms7SctWwADWBsVo5B5nBJMnf7UZMr8VONJ6BAsOMvC+0M8G/t4kZq7j2dx9hS1CJY8BxM44w4VmIz9KyU8a9bOfJwTFdUVExjblgABOMtSFMRg3LrHOPERZ6iatwQr8L+DjGNsSDeFI48L10jxT0zaRg/y8MFFFqty4RtZ6k7yelhD2NUlremFwWBGfGAjFjBo0/6V1LKZOnGUS3J6X5q5T4p8w15fEMwp/qCCdKlXf0hdSveOLbRha+CcuaUtOINiVOKL60YkjTDM2fXTBSYmXhvoAt+LW4OdBRwV0YA1rGwLZQSVsVgIqKmZgTBgDtWGxnzKfxHO9DPPHbQYxDwDZgKUjCu3Cz0HJISXCHwVqPZmZalU07RtszccwixFEcn80ISnLbeXaW9JyIf49d9OxVPfm8U87iJUUDS7SRZxNRL4F1Os/5gbrtdEbSm484jL5G0zFPpRNCHqCkN+X/1XXrNoW5KI6hfMZwO393vlsG5tdH8u0dh/j7ciz8HWJci2cDPYq4iQmXIYbyFCJXqKu1VVRUZMwFAwCY2IRjDLmACZdg3IvYxYCHGHvYJx77fwiX+u4IIv09KIUI4pdAgVAkolkaQjLBmYlIAZOX1aZud+nJDF1gpimlLDdbB1gkJ4QDEgFv1Guh31zH8DOjhZ6EHQm688ZuqoRpWllwoU4l08eGJQtP9gV4gbiFZDIRlQ/G8r3BGb6BPXi18Xsep5Ben+q78Llbx9cI/C0uIByLTPBUGwJUVGxSzAUDGCAuW15kdXWJfawzpGWJY6AxQ/yHfRBnAMeAa3D/wEH5Iirhm4CvA4sy1nEzUCRuHXpcEL9ZyKTJev+rpGeprpMhawrWudbPrRlLjaJd3mJIqHe+DQRYnVrKJzPxtNDerG72e+Elp81H/X7NUmCwHNuvooxh2ccQCqpL69OceuhrMYJGtBNLTvCUZTqsGxiFioaWw4IlsRByKRnuJH4KviH8GjBpZ2+8U1FRMScMwIBt62OWaNnKiCMY2xjyAGMuMV/0tQsPu9xCWOQlD69cA07ItYCh/Ho0MWT7dUH6CvMFOGEpTcR9E088n0nrC06SUyJPG4j69ZWiuQpySP9+T+yPUU3TC9F6WspUf51A501pYFaKBCue7TZtxZ9wN8b/x75H806M9LGkChSdEmoa3xgmli1uD9QwWBi4tmBGzLRc9nJovhPYVlzavxOX9lfl24gu4e/JcWUG0dR8QBUVMzEXDGAJT+l7gjEjxuyhZQTsNLEfX+17HLfzbsElwmvwSJB1ci79vBAqkLFA7ZzeBSLQMwfEVAIwm8jHiKK4uUu/3CyJuUPz0hMznjbLYanx2XTbsr29qKMTaZqqzfXPluLpPzCtBtlsR/HG9cQqinGV9va4OA5SuO1gMAhKTenMtmRlMjOapvFFfRKDpqG1NjXRBBb1AL762/DVwgt4FFiDrxk5jq8LeMhm8rmKioqAuVgJbDKODgfcyAI7aBBLXIF4GDf7XISr+DuARcFBFJJ/eSrgSDzTxuLQWcwKkQ1YojnRNjRmGpkg5929QiXT5mSLpu5ujpsOnZ5hj4nO06kbhU2+7TiRy5L9Nb9Fo+FvcuaGiYh9S31V2VsywS4Id+p8WvGbK/IdKC3dJ67mjZJ+7E8xP408l786oZm5bjNjMpnQmtG2rYf29hhq/D5O4PmfJhjHcVPgQTxYYBG4G99QKK5OrqiomMZcaACLJq4aTVhljeOsAGtMaLheHs53H7Ab407EGmJdcLc5QzhMXJHrtnMaS4Soa86Iee3bWBowGivopmaS1UzM1SXsSfjesPy0PN4R2juPB2K6QYbOJGf325uhXKQypY0eZ7TuX5jxbHmpoJhlkU4z2RJEKf13cxRF4uvXJu2Etm2T9N9ZUyH5dxM2kHE+Mq2h+Nvh97cSM8S6GW8Y7u9EXIX4BIQM3pUDVFTMwlxoAOuIG5mwQMOQdQ7ScjstawZYwwC4F0/+tsuMhbBBzAjSwqDCclIQqoKQJY2gNMF0r/VpqwuwUV3IEnS+Mov+d4lW6k+QkvNzszmHWXyuGEjRYvn/RpaNKXKXmE1ptyeMvzRAhXKFhjCT+MfaIoNRrFs0zSDE/A8YhON4L+8cBlJTJIjr9SB+L1HLKBw364pZXH0luJv/3B90AfAUGzIB9jHJCwIr/a+omIm50AAMWGeBdY5zAs+fsxt37h1EHDO4RG7v3QYcMSdSY4KN3oxGStsHut03y/+JcCd6oxRGn9elqiCuyn97NuRMkyOVUvepQFkT0Y9diSXUT1DRn4ku1Ptb6h+pzZ4kP/VMMNWk2YiZQCNjiDb4qV54C922w7Vk+VFeC2DylcEWiH2/I73hJeYa00b3EshFk148a+gm8LvYfE3IUWCJAdfahCcy5oh5CPCaoJH5+oKKioopzIUG4ERgQsMyT6PhycBTWGAB2MOE3YIH8ODGLYhLgQsK2XyImwOS1EghvZux0JEoybSYXlqIFHdYUtOerby8b11i2cmR07HVFKTVunH3s45Led+sPC/sRj07fn8lQFIkTtZWkLC7mU5zwbxtZo+Cq7wWzTfZdBTDONsieijF7cc5t5a2zSsYym018xaa/rAsZA0N7cUN4teA+8w1wbgHxAM0PBFxMWKbEW1AVFRUTGMuNIAxxgTjIYxdLPIkJvxliIofKRA3wTGDm4B1iT246eeIPE+Q8PTBwpOGxQVVQrQYE4vyb494F4J+RndtbSSzszMKzFqGVdaUmitqzVoDxf3AH8oHOnX0mu0cpL2QFftfcLpiVJ3w0bKtLuWnnJSUKog8F5EJ+WPWWSCXzPmxbyoUpvCsW3Wis7hNmlMsmFdxe7vjgkO1UkoHbrgPaKdNOIHrCXcALWMeNthj1vUlVFRUJJy2BiBpIOmTkt4Tzi+Q9H5Jnw9/dxdlf0rSrZJukfSCU9VtuP12K8vchfEwxhLiVtwB/Dl8I5Bj8sVHA+ARPORvEijmCCNGjY+KilucQYAxME/FPIukOlFzDqKS8GZ+URZMxzlKpVunt5JtIP5Y17hSHkyxhIIpWfEp7Tv9GCFLz2TKHfvWtcZM27TiauOkIaWDQpNIHQjmmjYS+CZcMpfqrdQpynajWceKWP9i74A414kZ+J9t5gu74v1Wvu/CA7jkvxX83QBWGXNMYx5BHJZrjc1J6P/ZfK8rKuYdZ2IC+jHg5uL81cAHzOw64APhHEnXAy8Dnga8EPgPkgacFA27TexmjcuZ0CL20HApOQXElWZsMd8cZg2PABoAF2PssA1k8ILqSb6xSCaQfaLYJ9r54lQ6t5zfuHMnOjtLZpK9z4odKewzHXJd9KGQtGO9UXvo8IhuySyd901QGR2tJhHcbGtPtv2e2UdQbPVIyRHS/JiBtRPaSaErFapDfM4K4l/aqbrsMc/tUYwmfKJpaRWP+LkWX0eyyiKHgIeBK8O17bgfYnISDY2z+l5XVMw3TosBSLoC+CbgPxWXXwK8JRy/BXhpcf3tZrZmZncAtwLPOnkLxqpG3CHjZowvYNxLy6c19N2/yFs8rhssYmH7P18EdCT2M/0tiHsgZk2mbJmIEelkQSCm6T99Qh9E/x6Rnn4qHpXRN1hBZIsY/TQTpR29WMyQiHJ8Lva9Y5Mp2kiXC0aUxpKl9KxlFO0CfRk++wOi+QZS7H803RTqTMmW+iuFfbvIQucp56D4vsqIpXEo0YR6t+Ba4z7cBLSVdVqJT0ncGJ453Ot3H2f/va6omG+crgbwBuAn6ZrBLzaz+wHC373h+uXA3UW5e8K1DiS9UtLHJH1s3VruxFhhnftp2ceEVRm7w75ZhjOABfxHvWS+OGwbhFWh/onEZMqpWRCSPrEviVxpBp/qb/fJxGJmF5+tkajzXyTihbTecep2K88ZPbNRZ2Y8USSsHXtR2YFSi4j5jXK56IhN5qNeSGhnk3Xrag9FI1MzUEb0FGvHUj2x09E3EL/BAcY28+cn5nmAMPf/PD0M5TjGMWC3Gc/AuN58I6ElQtK4jRWAN/Aov9c+vvxuj1IS64qK+cMpGYCkbwYeMrOPn2ads35uU3TSzN5oZs80s2cuy7cIPAJcFYjScYNLMXYAD+K/tiE5HfBRfFvA7TixMbophzuNWpH3P/6nKJs7hsS0DzMYRW9w6p1PlYl19yOIZlSm0L9Ud9Mz32Sj/OxnIWkVnecUy0z3IZYtTT2RN0RpXgWRTweJghdaQNeoRCT9U6O2vimtO/9JE+iNa4L7frzfvg6gNWPZjKO4yWeCOIJrikcM7pP7jry+huEMDnC23mvovtsLLJ1m9RUV5x6nEwX0HOBbJL0Yz7+1Q9JbgQclXWpm90u6FHgolL8HN8NGXEH4PW6EFriUBVZsnR0scog17sa41zyCZ6fc3LMNsRIaOoyxioKT11hUw5rCXrtF3DtEulYSNEs0NVqbx0zvwpvCV4p6NmYLXVoQzR4Fec1HBeEtN0+PmTRL80g2jRSjKQL/O612/AO9i/3FAsShWTE1lodNnpu+gJ+If2SsTRPqybb7mfNkpB3ECPqLxXYLBuJdFShsIB98PI3cGbyMcYE17GdCC7R4RJCbhcQVJh6UcbEZshbTzPits/5eV1TMO06pAZjZT5nZFWZ2De4E+x9m9t3Au4EbQrEbgD8Ox+8GXiZpSdK1wHXAX5+sjSFwByPuY8gJRixi7EJcB2xBLOM/7tvwH79wJ/AOPPHXBLFmBm2bY8n7spkVBC9eS2ZxP4j792YJ1Dp/+5J/XuVa1KNsxw/N0ie8bupoaUN/U4lucx22UTKC7LcI7uGoaWTFpjvm0lTT4xidiJvSNBXajM8kRhbKdwh8qLtso+NYnmovM5iuCSn4JmIkkcGCWdLMJuYLAZdxAeAR3NSzlQHLLIYcUQNWEbuJG+eIWa/5uXivKyrmHV/MOoCfB94p6fuALwDfDmBmN0l6J74vxxj4YYt5fTfAGFin4ZjgDmtZRWxhgc8zYoecMD+EE4H7EcfkyeDW8X1kI3GKewBEWTceRUKQ0iFHRMKWJFpCeXWIFqH+uGRWfVML+do00Qv9CBfKjeh9tWyhI3TiT2ObnVo6t0r4OLIJpt+/PJQiJXS8aL2mQilLXYpEWh3thc7fNteXysUmFWLxlYvEA03PVWlUysn4PIHcQYOBGQP5ArExsErLl5txiAWeyjojxO00ISKol9zu1HjU3uuKinnHGTEAM/sg8MFw/AjwvA3KvR54/enWuwjsHrSsTJzo7AakEZin+TXBYtAEDuJx3wt4LphVxKggGnHFaMzy2ZXFuyaOSKHc9AJ5tVJmAnHTdn9mlqknDTpd6xOcMgomEv0Owe+jtIh0a6GgyjP6UZYJxpiU72F2U9PIY0x97HKMwsRjKZLJc+z5RMXZixJ+t/ZCQyvDfJJtzFJ7MXfQCv5dR+1uCZiY8SScQYyAQ2q5wta5HHgI45nWcsT8BWp7fZiau7P0XldUzDvmIhXEUcQX2iFH8OX998g3+lgOTr8TKBGBAb4AbIRzry0Q6E6OwR8RyX3xwy/EylLC7MizyTFcmlzC48l8kjNexlQTs0xEJbKpI0r/RZRSfjwjmpaKLuQyvVas+HQ72i1QXJ/qZ0f0746pS/zjvW7tiXYX38GUHW7K/NS/lTWjslu+uMtLDc3YZZ4TaEfo8y78nTiCCwU3ATexwDYZJyITrSuBKypmYi4YwDIe6vcIAybyfQAuJizkCaRhGx6PtxNYx9iZjgtpHjrO3GzLLxqzrnDttvyNxeNctkdpAyFc6FYdblm3tFmvhB9bIMr95kWXXlqyVfUaK1fRkhlMvN/nDbP62blu2fQTF80lwtyroRxbyvKZNKrpJ4CO72LatNXVriIzWSI7lQdmjM189zd8DcB94akWeFCLrLPCZYw4aLCl1O4qKiqmMBe5gBpgB2MmLDJixCMYN+LE/SLgAC7lreJagBAH5Db/o52ImW7MSpfsTl/PhHl6117SHabulKaN9SI6R+UTHUdwIXkXIakxaVoXebWyLGbdFNF4UpqTsJ6W0+l9Ua6M8+8dWb/s1Ki7dZfjiITcCm3BggnHus1O+U1k3fMmpG3A2twVeThwfHbRYC8tD5oYyQWA+yS2mXENDZfahL2s8wiLrLDMUmCuZ+gDqKjYNJgLBjDCU/q2rGM4MThmbt+9FzDBoVBmOZiDjuD7/wJJoJSgMQ8NVUGHpbi9oqWy0bFoEGLeC6oVzB7dPWvL+zNsIJbLdcM4gz3ccnx88hyGcNVUkUUbuDrRPH1JvfRdZBNNkZgtsqK+tagw53Sd1YojTH1RGGuH6He60F8d3Z0PlaWSgzwwQouMI7C1yDiSsyVHBjXp+xIm48HAOJYtLgD0KKFjDDDGHGXAOiPuw1hjJWh8VQWoqJiFuTABtYgRAwZ4jpe9Bq1gXZ7kawIh978bCmJagEGgEsMsgAJd009HKg9/m86VKJ1n+3Vfaozx7am2TnqBHHVjirQu57mxYKrxcQbGM7UUNvQt8rPicjbdW/5nsz4ttMmAk/pQmmk6idcSx7IOYyymLvOWYu6snOSC0WVzUalN5PHH0E5nUGU4qDp+mQ7MQz+j5eg47vQfCFYlDuOMYBW4mBH7aFjD2IG4mJat+D4RZnPxmldUzB3m4pcxwLgC3+PVtQHjEvNUvjvMXNozL2cYC7gdeBnAjJF1iUtUawoyl64YOUIoE1onxnnf2y5xjvvZSvKNzYO5osybA8HXaH3putuHuENV33TT7WWX+CYeYr2bpUSfLk/vcdBXWOhVkY8zW+yYTSIDKv+mY0tMpGQwbYi+McLfwnnsxdvi2dJPWzDU0LuRQRPKGcZ2XGsb4EEAI+BvcA1xHeNzGPvw0OGxMXPf54qKijkxAQF8jgkNnup5OZhtGtwZPME4ihia+wWOy7jQYL98odgInAngxHqSLEMlmVUidOE0HyQbNJnSlvS5UClysrYyTt5NN12JOSew61SVLVEbI0UZpe6l8/5z02zEKDrWqzLXO7uezB7yVor9cSlYyQqCnu70epVuRBtZaXDqMs+sKVnZDQYGKwp5gDAWMQ6Yhw5fGQodJZ4vcIkZ27XGU2j4RLg/pIbrV1TMwlxoACB2agHUcAJf6LWIUrK3w4ij8kVfa8CSuQN4KRCNIWCB4A0paVWXzMWY9cKa48Q/FrCekzVdJxH+vHo3BmoWFfWeixFJTWHbiUR9FgsYbqAV9KMys+Dcz7uTSXGP/DM9qDNFbinR6uLOrNYSHe9zMrpfQWZOXaYyAFbka0G2mXE9sILYC1wCPAX/vi8HrjUYcIKDmnA3DbczYSJ828/qBK6omIm50ADGwD5attKyABwVXGS+DeQWPO5/PdCGi4ATGAM8AdgSMDZjETFqVKj70VnbJYaFkaP0uSYTxhQioS2ISEOZPrLwAPfaGQDjwmncMQlZlH7zeuVRKNQh6GXVhRRe1gfk9VPRpm7TTuDSdTuLHUztGFYyFBVEf8bD007i4jhOUSTuyo7xk7ElwzgejlfJC/zWECcwbgUuZIEDNuZe4BqGXAPsoOUh+Wbxg455qaKiosRcMACnDb6Uf8SIrUHFP4wTkgZf/Rulwha3+24hm1lGgVgOFZmA15qND4WEXq5AxYlRIuh9ei7fSaxMJzYtXcdqs33fCM7qWUwlVJKYDx4Zk1bJllWLYgxl64XppHdvWsGY7vFs/0R5Uo6r+3d6LNlc1GW4RUvdQXQfbxQYQpetLiHW8YAAJA61xk6Mg3gI6D3AIzZiTWKvwWHG3ELWvA4o7yBXUVExjbkwAS3gC772M2IZYyvGEeAKBhwD9gZCPsIZw84QhXMkXCtV/FFR77ThI4qg1iG1KUSzSKp2MpQW5Snyrg1JajCdRFNHFtEtPNfQI/5T0noWpcuxeahlbn+a5XRF9+nhzWIHs0eRfLn9i/3qkm9kZpVeTKJpgoOdwkQXHh3L/T8eXSUWggmtlS8CWwEGEqsY+2TczZAllhgxZIybiwzfK7qiomIac8EAxvjv/kLc6bsf3/N3GxOuCWLjE4ELgmy9iLFIXhy2RvYBRELioZob7waVCs+6ZF2iG53Kp7Kk9zdH6ZePOfYXLJfPETQhWiWcD3CGQMeEMdt8I0KUzEYi9kbPBsI6FSevHuG2GdenXB6WigyK4unOrK4pM93ImkSQ2A1G5qG/MaP+WL7wbxlYlC8K3Ib7WK4GrmNMwxoXMOEhxLENZqKiosIxFwygJW/ruB+4DHfsLWA0iH3ykM+teOK3+/H0ETvwxWDJt9uPrQ+mg8wINOMzTVBPJkNn7SE30c3pP3udQSw7xLWUDa0pOAF1WT/3r5TRI5OKaIlayUlMTmkGeuagWXb4Ducqt7O0TtuzNImslZCZcKGAWPFtOK/rhZKCM9zwaeXz1ZglP9ASnhxwr8RBXCvcH+bgOAPuV29OTqXSVVRsUsyFD2ARsQfjML7P6+eDFHhCSj/km+XRIOuCdZQkf4/6kTtbCwysG/9tU0dTIiyS7zaViGT0XkYR1pyYdAwmPYIro2dy8JPIFKKVu+tIDn0OZWaGjtIlZckpG00tPf9GV+BW8Dkob7aCzbDchOuJwqtzd5ryq9O3iDSuOG8dhSKavpTtSYplylJBMzHzld0YQ9xRvl+iMeN2jKHcmbyKuBhju+BzwDH5O1GuqK6oqOhiLhhAC6yxwAIjDiGOyGP7l/HFPisGq3Kn3hAPDz2ErwzdAhwjmFOKFbptn7oDpWwf6WaHcM6Qnktyb+o/N6ONULxP4CNhj5i1OCneb6Czj23fq5CaLyTzQOHzRTOsXLHcsd2fLMWbV9yJBxKduVHvIOkWpcknNaUcBdRDtPlHrUIFV0t8KnCYNjDWMa4NLOCrgldwR+8RM/YJxrSsKqQJidphZQAVFTMxFwxAGDsZsccW+AzrXGQe5XG/YI/BCsZ95vsFr2GMJK4x3wh8FTcRrBW1gUuN0aRQEp+OJAodppGIa7ymbh1KBMk6Vcwek+eqiU7pSaeF2VgId8exhg636h52tBCgzKMfqd50S5ns+/hyautO39PgM3EuWUOy988YgyLljkwjhRDFttVpo2maYIYK81yuwDZnSmp8LsaGb+oTIr0G+KKwCb5e4D7E3a5M0BAFgv729BUVFRFzwQBGiGWDe2ydSwT3YhxB7MGjQEbAThQSxnnc/2FcynsAeoQjkDcrpNyY4mFGToSu1OpSdN4OMac/iKtfI53VDMJZYgIz1p9mojrr6VGnRF9ynSL5+Wog5HmtQmmuKdq0XEc2KSmtg5iJOHdtW1QX+xfNTSWR7W6RGec19qhcFKfik1N5hB4WnDvmXoqbA2G+h3OLO+gXzTiB7wc9FGxHHEbBwdVUBlBRsQHmwgk8BP4OQ3ZryB7c4ftkjCUzDpGJ6QBjF7A9fForCE9ywpYLugrRtSBwnVxBRVkFO/QsAp3cAKGujcl/f3XurBJdRMUCXPuIHUjEs7OCOR2kVgyQZrfY6Us46W94010opalnI5OZrjke9fUSOvdUHokO4Y8qRr+NFJErDxONnv5Yl0nJV7IelCV/T8QBsifDZobFVlRUwJwwgEWMo4zYSsuDwFX4Zt/b8TC/VcSlgj24OWgVzwOzSN4eEgrpORl+pw3AhpsSYvkYiXJyc46yUT6ZNTbaa7aU4fMWlfHaAi6Tdshsh6j3Oku3a0kAT0ObNvVsRPIyMe89F883MNanxWbFirBuxFUk6GTzUypLQex7f8Pgki+YLnOQmvxJDCRHfcXjRTxoIH5aeaBAm3pXUVExC3PBACbAPgbchuf1WcNDPYeIS/B47rvNF/4cw8MA7ysI1Tq+LiDGzXdQmBay7Zsp23TnkUCVyg3cS7NGcqR2l+EWz7upyqVS62yX7qtUo316lsRcDsHocIFEKMPK2dT/LvOYdVTWGG9NMZYZzyQTWK9s5gWZ8Hc2uI/3EkOOfwoTUVlOgqahCR9fJNbQNCoaJTP31F6urA3vigELinmYoONRr6ioSJgLH4Ah7pYxsoYTTNjLkDXG3IOxHuy868CR1rWCE/JnJkRTkJsBopmoLfyh8U+SLunziEwcUlil9UziBbHLJqOYH6evPUQSPV1/xFgxykaJEEdSlrtQXC2cwdNMI57P6vB0mX7pxBRxA7t6z0wrOZno5qIzjEDFXCfHcKovjjvY6YtGyu8KSA5iRQ2lzJQayq7jBH9MdLyLYWxDzGTyFRUVc8IABBxlyFOY8AgwZMSqwZpgD574bX84XwoMYb/5OoGYHiImDeuQwUhcC/ONBSJSMohsUyiJy7QXoMsUuq7P7mjygq9YUyy5EJhZJIJlDZHoR6d2QStpbZqVpGDNwBg6ET2p7txINwFbcnunOVBy2vZGVphrupafIoXDTChJ/XGzHIXak9RPTsXtX0FhwIp5s0t/SCjZyOckdnRkOROs8Kiw5cwBNuhfRcXmxlwwgDY4fB+kZcncCbwMbGHIMSYcNw8LHRrcqyFX25gBcAueDmAlkIWhebqAvpTo0TuB4FokQPleaViJeYG6Qv0Gq2VP4jgocxKpcz1Lsl3iP122RCSkKQw1dLJrmgl6hbrPJSaQLFal3B9IaydSKqk8TuAbtxRa23aejpvkZBNZv/dhXtN4vR8N8joDh26azLws1JvaS2avEIllcW/kctZCX80jxgaxZTmjGGzIoCoqNjfmggEsIp7LJdxhB1hklSsY0QAHbcxKoF1bgAeBi2zMqkJqCDO2ECI9zDWDJQtrAiQGQXs4Di6xW2AGyY6Ph3OWWgEkKTmZRk4LpZzfQyGBhwY60nppmkrdiY9FrSU1k/csUL7U6WfuySyCHK9nJuK2kp6fpHw2XMwaQm9wwcSiJo8v3otmrlxrViFKntGdPWfQ0Y8y1efOcCPDDum0MVrEEF8wZoLJ1JrriooKAM3MgX+uOyEdwQX6ecNFeOLJeULt0+mh36erzWzPue7EnL7bj4Xvax4wj32Cbr++qPd6LjQA4BYze+b57kQfkj42b/2qfTo9zFGf5u7dnqO5Sah9On08mv2aizDQioqKiopzj8oAKioqKjYp5oUBvPF8d2ADzGO/ap9OD/PSp3npR4nap9PDPPYJHsV+zYUTuKKioqLi3GNeNICKioqKinOM884AJL1Q0i2SbpX06nPY7pWS/lzSzZJukvRj4fprJd0r6VPh8+LimZ8K/bxF0gvOUr/ulPSZ0PbHwrULJL1f0ufD393nqk+SnlLMxackHZb0qnM9T5J+W9JDkv6muHbG8yLpq8L83irp17TxMuYvtr/1vZ7uW323Z/fj/L3bcU/W8/HBF23eBjwBz+jwaeD6c9T2pcAzwvF2fCfB64HXAv98RvnrQ/+WgGtDvwdnoV93Ahf1rv0i8Opw/GrgF85ln3rf1wN4stZzOk/Ac4FnAH/zxcwL8NfAs/ElZe8DXlTf63PzDtV3e/7e7fOtATwLuNXMbjezdeDtwEvORcNmdr+ZfSIcHwFuxvei3wgvAd5uZmtmdgdwK97/c4GXAG8Jx28BXnqe+vQ84DYzu+skZc5Kn8zsL/C93/ttnfa8SLoU2GFm/8v8F/M7xTOPJup7ffqo7/Z5fLfPNwO4HLi7OL+Hk7+sZwWSrgG+EvircOlHJN0YVLOoep2rvhrwZ5I+LumV4drFZnY/+A8c2HuO+xTxMuB3i/PzOU9w5vNyeTg+232r7/Vs1Hf79HFO3u3zzQBm2ajOaViSpG3AHwCvMrPDwG8ATwSeDtwP/HIsOuPxs9HX55jZM4AXAT8s6bknKXvO5k/SIvAtwO+FS+d7nk6Gjfpwrvp23udgDt9rqO/2o4FH9d0+3wzgHnxzr4grgPvOVeOSFvAfydvM7F0AZvagmU3MrAV+i6zinZO+mtl94e9DwB+G9h8MKh7h70Pnsk8BLwI+YWYPhv6d13kKONN5uSccn+2+1fd6Buq7fUY4J+/2+WYAHwWuk3Rt4MIvA959LhoOHvI3ATeb2a8U1y8tiv1DIHrm3w28TNKSpGuB63Cny6PZp62Stsdj4BtD++8GbgjFbgD++Fz1qcB3UKjI53OeCpzRvARV+oikrwnf/8uLZx5N1Pd6ul/13T4znJt3+2x51c/AA/5iPFLhNuCnz2G7X4urSDcCnwqfFwP/BfhMuP5u4NLimZ8O/byFsxM98gTcw/9p4KY4H8CFwAeAz4e/F5yrPoU2tgCPADuLa+d0nvAf6P34Vgv3AN/3vzMvwDPxH/RtwK8TFkPW9/qsv0P13Z7Dd7uuBK6oqKjYpDjfJqCKioqKivOEygAqKioqNikqA6ioqKjYpKgMoKKiomKTojKAioqKik2KygAqKioqNikqA6ioqKjYpKgMoKKiomKT4v8HvPRb3cQnIZoAAAAASUVORK5CYII=\n"
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": "",
+ "image/png": "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\n"
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": "",
+ "image/png": "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\n"
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": "",
+ "image/png": "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\n"
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "ename": "KeyboardInterrupt",
+ "evalue": "",
+ "output_type": "error",
+ "traceback": [
+ "\u001B[1;31m---------------------------------------------------------------------------\u001B[0m",
+ "\u001B[1;31mKeyboardInterrupt\u001B[0m Traceback (most recent call last)",
+ "Input \u001B[1;32mIn [37]\u001B[0m, in \u001B[0;36m\u001B[1;34m()\u001B[0m\n\u001B[0;32m 1\u001B[0m model \u001B[38;5;241m=\u001B[39m SpecDetector(model_path\u001B[38;5;241m=\u001B[39mmodel_file, blk_sz\u001B[38;5;241m=\u001B[39mblk_sz, channel_num\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mlen\u001B[39m(selected_bands))\n\u001B[0;32m 2\u001B[0m \u001B[38;5;66;03m# 画图验证效果\u001B[39;00m\n\u001B[1;32m----> 3\u001B[0m \u001B[43mvisualization_evaluation\u001B[49m\u001B[43m(\u001B[49m\u001B[43mdetector\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mmodel\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mdata_path\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;124;43mr\u001B[39;49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[38;5;124;43mF:\u001B[39;49m\u001B[38;5;124;43m\\\u001B[39;49m\u001B[38;5;124;43mzhouchao\u001B[39;49m\u001B[38;5;124;43m\\\u001B[39;49m\u001B[38;5;124;43m617\u001B[39;49m\u001B[38;5;124;43m\\\u001B[39;49m\u001B[38;5;124;43m617_pure_tobacco\u001B[39;49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mselected_bands\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mselected_bands\u001B[49m\u001B[43m)\u001B[49m\n",
+ "File \u001B[1;32m~\\PycharmProjects\\tobacco-sorting-industry\\utils.py:107\u001B[0m, in \u001B[0;36mvisualization_evaluation\u001B[1;34m(detector, data_path, selected_bands)\u001B[0m\n\u001B[0;32m 105\u001B[0m \u001B[38;5;28;01mfor\u001B[39;00m idx, image_path \u001B[38;5;129;01min\u001B[39;00m \u001B[38;5;28menumerate\u001B[39m(image_paths):\n\u001B[0;32m 106\u001B[0m \u001B[38;5;28;01mwith\u001B[39;00m \u001B[38;5;28mopen\u001B[39m(image_path, \u001B[38;5;124m'\u001B[39m\u001B[38;5;124mrb\u001B[39m\u001B[38;5;124m'\u001B[39m) \u001B[38;5;28;01mas\u001B[39;00m f:\n\u001B[1;32m--> 107\u001B[0m data \u001B[38;5;241m=\u001B[39m \u001B[43mf\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mread\u001B[49m\u001B[43m(\u001B[49m\u001B[43m)\u001B[49m\n\u001B[0;32m 108\u001B[0m img \u001B[38;5;241m=\u001B[39m np\u001B[38;5;241m.\u001B[39mfrombuffer(data, dtype\u001B[38;5;241m=\u001B[39mnp\u001B[38;5;241m.\u001B[39mfloat32)\u001B[38;5;241m.\u001B[39mreshape((nrows, \u001B[38;5;241m-\u001B[39m\u001B[38;5;241m1\u001B[39m, ncols))\u001B[38;5;241m.\u001B[39mtranspose(\u001B[38;5;241m0\u001B[39m, \u001B[38;5;241m2\u001B[39m, \u001B[38;5;241m1\u001B[39m)\n\u001B[0;32m 109\u001B[0m nbands \u001B[38;5;241m=\u001B[39m img\u001B[38;5;241m.\u001B[39mshape[\u001B[38;5;241m2\u001B[39m]\n",
+ "\u001B[1;31mKeyboardInterrupt\u001B[0m: "
+ ]
+ }
+ ],
+ "source": [
+ "model = SpecDetector(model_path=model_file, blk_sz=blk_sz, channel_num=len(selected_bands))\n",
+ "# 画图验证效果\n",
+ "visualization_evaluation(detector=model, data_path=r'F:\\zhouchao\\617\\617_pure_tobacco', selected_bands=selected_bands)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ },
+ "outputs": [],
+ "source": [
+ "visualization_y(y_list, blk_sz)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "outputs": [],
+ "source": [],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ }
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3.9.7 ('base')",
+ "language": "python",
+ "name": "python3"
+ },
+ "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.9.7"
+ },
+ "vscode": {
+ "interpreter": {
+ "hash": "7f619fc91ee8bdab81d49e7c14228037474662e3f2d607687ae505108922fa06"
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
\ No newline at end of file
diff --git a/03_data_update.ipynb b/03_data_update.ipynb
new file mode 100755
index 0000000..784bf9e
--- /dev/null
+++ b/03_data_update.ipynb
@@ -0,0 +1,301 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "collapsed": true,
+ "pycharm": {
+ "name": "#%% md\n"
+ }
+ },
+ "source": [
+ "# 数据集扩充"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "虽然当前的模型已经能够达到较好的效果,但是还不够好,对于一些较老的烟梗不能够做到有效的判别,我们为此增加数据集。"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%% md\n"
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "outputs": [],
+ "source": [
+ "import os\n",
+ "\n",
+ "import cv2\n",
+ "import matplotlib.pyplot as plt\n",
+ "import numpy as np\n",
+ "\n",
+ "from utils import read_raw_file, split_xy, generate_tobacco_label, generate_impurity_label\n",
+ "from models import SpecDetector\n",
+ "import pickle"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "outputs": [],
+ "source": [
+ "# some parameters\n",
+ "new_spectra_file = r\"F:\\zhouchao\\618\\bomo\\calibrated7.raw\"\n",
+ "new_label_file = r\"F:\\zhouchao\\618\\bomo\\picture\\label7.bmp\"\n",
+ "\n",
+ "target_class = 0\n",
+ "target_class_left, target_class_right = 5, 4\n",
+ "light_threshold = 0.5\n",
+ "add_background = False\n",
+ "\n",
+ "split_line = 500\n",
+ "\n",
+ "\n",
+ "blk_sz, sensitivity = 8, 8\n",
+ "selected_bands = [127, 201, 202, 294]\n",
+ "tree_num = 185\n",
+ "\n",
+ "pic_row, pic_col= 600, 1024\n",
+ "\n",
+ "color_dict = {(0, 0, 255): 1, (255, 255, 255): 0, (0, 255, 0): 2, (255, 0, 0): 1, (0, 255, 255): 4,\n",
+ " (255, 255, 0): 5, (255, 0, 255): 6}\n",
+ "\n",
+ "new_dataset_file = f'./dataset/data_{blk_sz}x{blk_sz}_c{len(selected_bands)}_sen{sensitivity}_7.p'\n",
+ "dataset_file = f'./dataset/data_{blk_sz}x{blk_sz}_c{len(selected_bands)}_sen{sensitivity}_6.p'\n",
+ "\n",
+ "model_file = f'./models/rf_{blk_sz}x{blk_sz}_c{len(selected_bands)}_{tree_num}_6.model'\n",
+ "selected_bands = None"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "outputs": [],
+ "source": [
+ "# if len(new_spectra_files) == 1:\n",
+ "data = read_raw_file(new_spectra_file, selected_bands)"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## 烟梗标签生成\n",
+ "这会将纯烟梗图片中识别为杂质的部分提取出来"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%% md\n"
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "outputs": [],
+ "source": [
+ "x_list, y_list = [], []\n",
+ "if (new_label_file is None) and (target_class == 1):\n",
+ " x_list, y_list = generate_tobacco_label(data, model_file, blk_sz, selected_bands)"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## 其他类别杂质阈值分割\n",
+ "通过阈值分割的形式获取其他类别的杂质"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%% md\n"
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "outputs": [],
+ "source": [
+ "if (new_label_file is None) and (target_class != 1):\n",
+ " img = generate_impurity_label(data, light_threshold, color_dict,\n",
+ " target_class_right=target_class_right,\n",
+ " target_class_left=target_class_left,\n",
+ " split_line=split_line)\n",
+ " root, _ = os.path.splitext(new_dataset_file)\n",
+ " cv2.imwrite(root+\"_generated.bmp\", img)"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## 读取标签"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%% md\n"
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "(600, 1024, 3)\n"
+ ]
+ }
+ ],
+ "source": [
+ "if new_label_file is not None:\n",
+ " label = cv2.imread(new_label_file)\n",
+ " print(label.shape)\n",
+ " x_list, y_list = split_xy(data, label, blk_sz, sensitivity=sensitivity, color_dict=color_dict, add_background=add_background)"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "148 148\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(len(x_list), len(y_list))"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## 读取旧数据合并"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%% md\n"
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "outputs": [],
+ "source": [
+ "with open(dataset_file, 'rb') as f:\n",
+ " x, y = pickle.load(f)\n",
+ "x.extend(x_list)\n",
+ "y.extend(y_list)\n",
+ "with open(new_dataset_file, 'wb') as f:\n",
+ " pickle.dump((x, y), f)"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## 批量数据的处理"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%% md\n"
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "outputs": [],
+ "source": [],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ }
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 2
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython2",
+ "version": "2.7.6"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
\ No newline at end of file
diff --git a/04_performance_tune.ipynb b/04_performance_tune.ipynb
new file mode 100755
index 0000000..3ef969f
--- /dev/null
+++ b/04_performance_tune.ipynb
@@ -0,0 +1,398 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "source": [
+ "# 性能优化"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%% md\n"
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "outputs": [],
+ "source": [
+ "import numpy as np\n",
+ "from utils import read_black_and_white_file\n",
+ "import matplotlib.pyplot as plt"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## 识别结果二值化"
+ ],
+ "metadata": {
+ "collapsed": false
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[[1 2]\n",
+ " [3 4]]\n"
+ ]
+ }
+ ],
+ "source": [
+ "a = np.array([[1, 2], [3, 4]])\n",
+ "print(a)"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "[[1 1 2 2]\n",
+ " [1 1 2 2]\n",
+ " [3 3 4 4]\n",
+ " [3 3 4 4]]\n"
+ ]
+ }
+ ],
+ "source": [
+ "a = a.repeat(2, axis=0).repeat(2, axis=1)\n",
+ "print(a)"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "## 黑帧稳定性测试"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%% md\n"
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "### 开机后短时间内黑帧变化"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%% md\n"
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "outputs": [],
+ "source": [
+ "root_dir = r\"F:\\\\zhouchao\\\\white_black_change\\\\\"\n",
+ "file_names = [root_dir + file_name for file_name in [\"black1\", \"black2\", \"black3\"]]"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 32,
+ "outputs": [],
+ "source": [
+ "black1 = read_black_and_white_file(file_names[0]).reshape((1024, 448)).T\n",
+ "black2 = read_black_and_white_file(file_names[1]).reshape((1024, 448)).T\n",
+ "black3 = read_black_and_white_file(file_names[2]).reshape((1024, 448)).T"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 33,
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "(448, 1024)\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(black1.shape)"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 41,
+ "outputs": [
+ {
+ "data": {
+ "text/plain": "",
+ "image/png": "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\n"
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "fig, axs = plt.subplots(2, 3)\n",
+ "axs[0, 0].matshow(black1)\n",
+ "axs[0, 1].matshow(black2)\n",
+ "axs[0, 2].matshow(black3)\n",
+ "axs[1, 0].matshow(np.abs(black1-black2))\n",
+ "error1 = np.sum(np.sum(np.abs(black1- black2)))/488/1024\n",
+ "axs[1,0].set_title(f\"1-2:{error1:.3f}\")\n",
+ "axs[1, 1].matshow(np.abs(black2-black3))\n",
+ "error2 = np.sum(np.sum(np.abs(black2- black3)))/488/1024\n",
+ "axs[1,1].set_title(f\"2-3 :{error2:.3f}\")\n",
+ "axs[1, 2].matshow(np.abs(black3-black1))\n",
+ "error3 = np.sum(np.sum(np.abs(black3- black1)))/488/1024\n",
+ "axs[1,2].set_title(f\"3-1 :{error3:.3f}\")\n",
+ "plt.show()"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "### 多次开机后黑帧的变化"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%% md\n"
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 51,
+ "outputs": [],
+ "source": [
+ "root_dir = r\"F:\\\\zhouchao\\\\white_black_change\\\\\"\n",
+ "file_names = [root_dir + file_name for file_name in [\"black1\", \"black21\", \"black31\", \"black4\"]]"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 52,
+ "outputs": [],
+ "source": [
+ "black1 = read_black_and_white_file(file_names[0]).reshape((1024, 448)).T\n",
+ "black21 = read_black_and_white_file(file_names[1]).reshape((1024, 448)).T\n",
+ "black31 = read_black_and_white_file(file_names[2]).reshape((1024, 448)).T\n",
+ "black4 = read_black_and_white_file(file_names[3]).reshape((1024, 448)).T"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 53,
+ "outputs": [
+ {
+ "data": {
+ "text/plain": "",
+ "image/png": "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\n"
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "fig, axs = plt.subplots(2, 4)\n",
+ "axs[0, 0].matshow(black1)\n",
+ "axs[0, 1].matshow(black21)\n",
+ "axs[0, 2].matshow(black31)\n",
+ "axs[0, 3].matshow(black4)\n",
+ "axs[1, 0].matshow(np.abs(black1-black21))\n",
+ "error1 = np.sum(np.sum(np.abs(black1- black21)))/488/1024\n",
+ "axs[1,0].set_title(f\"1-2:{error1:.3f}\")\n",
+ "axs[1, 1].matshow(np.abs(black21-black31))\n",
+ "error2 = np.sum(np.sum(np.abs(black21- black31)))/488/1024\n",
+ "axs[1,1].set_title(f\"2-3 :{error2:.3f}\")\n",
+ "axs[1, 2].matshow(np.abs(black31-black4))\n",
+ "error3 = np.sum(np.sum(np.abs(black31- black4)))/488/1024\n",
+ "axs[1,2].set_title(f\"3-4 :{error3:.3f}\")\n",
+ "axs[1, 3].matshow(np.abs(black1-black4))\n",
+ "error3 = np.sum(np.sum(np.abs(black1- black4)))/488/1024\n",
+ "axs[1,3].set_title(f\"1-4 :{error3:.3f}\")\n",
+ "plt.show()"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ }
+ },
+ {
+ "cell_type": "markdown",
+ "source": [
+ "### 采集数据前后黑帧的变化"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%% md\n"
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 48,
+ "outputs": [],
+ "source": [
+ "root_dir = r\"F:\\\\zhouchao\\\\white_black_change\\\\\"\n",
+ "file_names = [root_dir + file_name for file_name in [\"black3\", \"black_after_white\"]]"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 49,
+ "outputs": [],
+ "source": [
+ "black3 = read_black_and_white_file(file_names[0]).reshape((1024, 448)).T\n",
+ "black_w1 = read_black_and_white_file(file_names[1]).reshape((1024, 448)).T"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 50,
+ "outputs": [
+ {
+ "data": {
+ "text/plain": "",
+ "image/png": "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\n"
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "fig, axs = plt.subplots(2, 2)\n",
+ "axs[0, 0].matshow(black3)\n",
+ "axs[0, 1].matshow(black_w1)\n",
+ "axs[1, 0].matshow(np.abs(black3-black_w1))\n",
+ "error1 = np.sum(np.sum(np.abs(black3- black_w1)))/488/1024\n",
+ "axs[1,0].set_title(f\"1-2:{error1:.3f}\")\n",
+ "plt.show()"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "outputs": [],
+ "source": [],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ }
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 2
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython2",
+ "version": "2.7.6"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
\ No newline at end of file
diff --git a/05_evaluation.ipynb b/05_evaluation.ipynb
new file mode 100755
index 0000000..b5b43f8
--- /dev/null
+++ b/05_evaluation.ipynb
@@ -0,0 +1,225 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "outputs": [],
+ "source": [
+ "import pickle\n",
+ "\n",
+ "import numpy as np\n",
+ "\n",
+ "from models import SpecDetector, evaluation_and_report\n",
+ "from utils import visualization_evaluation"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "outputs": [],
+ "source": [
+ "blk_sz, sensitivity = 8, 8\n",
+ "selected_bands = [127, 201, 202, 294]\n",
+ "tree_num = 185"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "outputs": [],
+ "source": [
+ "dataset_file = f'./dataset/data_{blk_sz}x{blk_sz}_c{len(selected_bands)}_sen{sensitivity}_7.p'\n",
+ "model_file = f'./models/rf_{blk_sz}x{blk_sz}_c{len(selected_bands)}_{tree_num}_7.model'"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "outputs": [],
+ "source": [
+ "with open(dataset_file, 'rb') as f:\n",
+ " x_list, y_list = pickle.load(f)\n",
+ "x, y = np.asarray(x_list), np.asarray(y_list, dtype=int)"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "outputs": [
+ {
+ "data": {
+ "text/plain": "",
+ "image/png": "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\n"
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": "",
+ "image/png": "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\n"
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": "",
+ "image/png": "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\n"
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": "",
+ "image/png": "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\n"
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": "",
+ "image/png": "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\n"
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": "",
+ "image/png": "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\n"
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": "",
+ "image/png": "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\n"
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "C:\\Users\\FEIJINTI\\PycharmProjects\\tobacco-sorting-industry\\models.py:125: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
+ " blocks = np.array(blocks)\n"
+ ]
+ },
+ {
+ "ename": "ValueError",
+ "evalue": "could not broadcast input array from shape (8,8,8,4) into shape (8,)",
+ "output_type": "error",
+ "traceback": [
+ "\u001B[1;31m---------------------------------------------------------------------------\u001B[0m",
+ "\u001B[1;31mValueError\u001B[0m Traceback (most recent call last)",
+ "Input \u001B[1;32mIn [5]\u001B[0m, in \u001B[0;36m| \u001B[1;34m()\u001B[0m\n\u001B[0;32m 2\u001B[0m \u001B[38;5;66;03m# 画图验证效果\u001B[39;00m\n\u001B[0;32m 3\u001B[0m visualization_evaluation(detector\u001B[38;5;241m=\u001B[39mmodel, data_path\u001B[38;5;241m=\u001B[39m\u001B[38;5;124mr\u001B[39m\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mF:\u001B[39m\u001B[38;5;124m\\\u001B[39m\u001B[38;5;124mzhouchao\u001B[39m\u001B[38;5;124m\\\u001B[39m\u001B[38;5;124m618\u001B[39m\u001B[38;5;124m\\\u001B[39m\u001B[38;5;124mtobacco\u001B[39m\u001B[38;5;124m'\u001B[39m, selected_bands\u001B[38;5;241m=\u001B[39mselected_bands)\n\u001B[1;32m----> 5\u001B[0m \u001B[43mevaluation_and_report\u001B[49m\u001B[43m(\u001B[49m\u001B[43mmodel\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mx\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43my\u001B[49m\u001B[43m)\u001B[49m\n",
+ "File \u001B[1;32m~\\PycharmProjects\\tobacco-sorting-industry\\models.py:52\u001B[0m, in \u001B[0;36mevaluation_and_report\u001B[1;34m(model, test_x, test_y)\u001B[0m\n\u001B[0;32m 50\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21mevaluation_and_report\u001B[39m(model, test_x, test_y):\n\u001B[0;32m 51\u001B[0m t1 \u001B[38;5;241m=\u001B[39m time\u001B[38;5;241m.\u001B[39mtime()\n\u001B[1;32m---> 52\u001B[0m y_pred \u001B[38;5;241m=\u001B[39m \u001B[43mmodel\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mpredict\u001B[49m\u001B[43m(\u001B[49m\u001B[43mtest_x\u001B[49m\u001B[43m)\u001B[49m\n\u001B[0;32m 53\u001B[0m y_pred_binary \u001B[38;5;241m=\u001B[39m np\u001B[38;5;241m.\u001B[39mones_like(y_pred)\n\u001B[0;32m 54\u001B[0m y_pred_binary[(y_pred \u001B[38;5;241m==\u001B[39m \u001B[38;5;241m0\u001B[39m) \u001B[38;5;241m|\u001B[39m (y_pred \u001B[38;5;241m==\u001B[39m \u001B[38;5;241m1\u001B[39m)] \u001B[38;5;241m=\u001B[39m \u001B[38;5;241m0\u001B[39m\n",
+ "File \u001B[1;32m~\\PycharmProjects\\tobacco-sorting-industry\\models.py:125\u001B[0m, in \u001B[0;36mSpecDetector.predict\u001B[1;34m(self, data)\u001B[0m\n\u001B[0;32m 123\u001B[0m \u001B[38;5;28;01mdef\u001B[39;00m \u001B[38;5;21mpredict\u001B[39m(\u001B[38;5;28mself\u001B[39m, data):\n\u001B[0;32m 124\u001B[0m blocks \u001B[38;5;241m=\u001B[39m split_x(data, blk_sz\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mblk_sz)\n\u001B[1;32m--> 125\u001B[0m blocks \u001B[38;5;241m=\u001B[39m \u001B[43mnp\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43marray\u001B[49m\u001B[43m(\u001B[49m\u001B[43mblocks\u001B[49m\u001B[43m)\u001B[49m\n\u001B[0;32m 126\u001B[0m features \u001B[38;5;241m=\u001B[39m feature(np\u001B[38;5;241m.\u001B[39marray(blocks))\n\u001B[0;32m 127\u001B[0m y_pred \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mclf\u001B[38;5;241m.\u001B[39mpredict(features)\n",
+ "\u001B[1;31mValueError\u001B[0m: could not broadcast input array from shape (8,8,8,4) into shape (8,)"
+ ]
+ }
+ ],
+ "source": [
+ "model = SpecDetector(model_path=model_file, blk_sz=blk_sz, channel_num=len(selected_bands))\n",
+ "# 画图验证效果\n",
+ "visualization_evaluation(detector=model, data_path=r'F:\\zhouchao\\618\\tobacco', selected_bands=selected_bands)\n",
+ "\n",
+ "evaluation_and_report(model, x, y)"
+ ],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "outputs": [],
+ "source": [],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ }
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "outputs": [],
+ "source": [],
+ "metadata": {
+ "collapsed": false,
+ "pycharm": {
+ "name": "#%%\n"
+ }
+ }
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 2
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython2",
+ "version": "2.7.6"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}
\ No newline at end of file
diff --git a/main.py b/main.py
new file mode 100755
index 0000000..b116dd3
--- /dev/null
+++ b/main.py
@@ -0,0 +1,34 @@
+import os
+import numpy as np
+from models import SpecDetector
+from root_dir import ROOT_DIR
+
+nrows, ncols, nbands = 600, 1024, 4
+img_fifo_path = "/tmp/dkimg.fifo"
+mask_fifo_path = "/tmp/dkmask.fifo"
+selected_model = "rf_8x8_c4_400_13.model"
+
+def main():
+ model_path = os.path.join(ROOT_DIR, "models", selected_model)
+ detector = SpecDetector(model_path, blk_sz=8, channel_num=4)
+ total_len = nrows * ncols * nbands * 4
+ if not os.access(img_fifo_path, os.F_OK):
+ os.mkfifo(img_fifo_path, 0o777)
+ if not os.access(mask_fifo_path, os.F_OK):
+ os.mkfifo(mask_fifo_path, 0o777)
+
+ fd_img = os.open(img_fifo_path, os.O_RDONLY)
+ print("connect to fifo")
+
+ while True:
+ data = os.read(fd_img, total_len)
+ print("get img")
+ img = np.frombuffer(data, dtype=np.float32).reshape((nrows, nbands, -1)).transpose(0, 2, 1)
+ mask = detector.predict(img)
+ fd_mask = os.open(mask_fifo_path, os.O_WRONLY)
+ os.write(fd_mask, mask.tobytes())
+ os.close(fd_mask)
+
+
+if __name__ == '__main__':
+ main()
diff --git a/models.py b/models.py
new file mode 100755
index 0000000..1642fcb
--- /dev/null
+++ b/models.py
@@ -0,0 +1,142 @@
+import os
+import pickle
+import time
+
+import cv2
+import numpy as np
+
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.decomposition import PCA
+from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
+
+
+# def feature(x):
+# x = x.reshape((x.shape[0], -1, x.shape[-1]))
+# x = np.mean(x, axis=1)
+# return x
+
+def feature(x):
+ x = x.reshape((x.shape[0], -1))
+ return x
+
+
+def train_rf_and_report(train_x, train_y, test_x, test_y,
+ tree_num, save_path=None):
+ rfc = RandomForestClassifier(n_estimators=tree_num, random_state=42, class_weight={0:10, 1:10})
+ rfc = rfc.fit(train_x, train_y)
+ t1 = time.time()
+ y_pred = rfc.predict(test_x)
+ y_pred_binary = np.ones_like(y_pred)
+ y_pred_binary[(y_pred == 0) | (y_pred == 1)] = 0
+ y_pred_binary[(y_pred >1)] = 2
+ test_y_binary = np.ones_like(test_y)
+ test_y_binary[(test_y == 0) | (test_y == 1)] = 0
+ test_y_binary[(test_y >1) ] = 2
+ print("预测时间:", time.time() - t1)
+ print("RFC训练模型评分:" + str(accuracy_score(train_y, rfc.predict(train_x))))
+ print("RFC待测模型评分:" + str(accuracy_score(test_y, rfc.predict(test_x))))
+ print('RFC预测结果:' + str(y_pred))
+ print('---------------------------------------------------------------------------------------------------')
+ print('RFC分类报告\n' + str(classification_report(test_y, y_pred))) # 生成一个小报告呀
+ print('RFC混淆矩阵:\n' + str(confusion_matrix(test_y, y_pred))) # 这个也是,生成的矩阵的意思是有多少
+ print('rfc分类报告:\n' + str(classification_report(test_y_binary, y_pred_binary))) # 生成一个小报告呀
+ print('rfc混淆矩阵:\n' + str(confusion_matrix(test_y_binary, y_pred_binary))) # 这个也是,生成的矩阵的意思是有多少
+ if save_path is not None:
+ with open(save_path, 'wb') as f:
+ pickle.dump(rfc, f)
+ return rfc
+
+
+def evaluation_and_report(model, test_x, test_y):
+ t1 = time.time()
+ y_pred = model.predict(test_x)
+ y_pred_binary = np.ones_like(y_pred)
+ y_pred_binary[(y_pred == 0) | (y_pred == 1)] = 0
+ y_pred_binary[(y_pred >1)] = 2
+ test_y_binary = np.ones_like(test_y)
+ test_y_binary[(test_y == 0) | (test_y == 1)] = 0
+ test_y_binary[(test_y >1) ] = 2
+ print("预测时间:", time.time() - t1)
+ print("RFC待测模型 accuracy:" + str(accuracy_score(test_y, model.predict(test_x))))
+ print('RFC预测结果:' + str(y_pred))
+ print('---------------------------------------------------------------------------------------------------')
+ print('RFC分类报告\n' + str(classification_report(test_y, y_pred))) # 生成一个小报告呀
+ print('RFC混淆矩阵:\n' + str(confusion_matrix(test_y, y_pred))) # 这个也是,生成的矩阵的意思是有多少
+ print('rfc分类报告:\n' + str(classification_report(test_y_binary, y_pred_binary))) # 生成一个小报告呀
+ print('rfc混淆矩阵:\n' + str(confusion_matrix(test_y_binary, y_pred_binary))) # 这个也是,生成的矩阵的意思是有多少
+
+
+def train_pca_rf(train_x, train_y, test_x, test_y, n_comp,
+ tree_num, save_path=None):
+ rfc = RandomForestClassifier(n_estimators=tree_num, random_state=42,class_weight={0:100, 1:100})
+ pca = PCA(n_components=0.95)
+ rfc = rfc.fit(train_x, train_y)
+ t1 = time.time()
+ y_pred = rfc.predict(test_x)
+ y_pred_binary = np.ones_like(y_pred)
+ y_pred_binary[(y_pred == 0) | (y_pred == 1)] = 0
+ y_pred_binary[(y_pred == 2) | (y_pred == 3) | (y_pred == 4)] = 2
+ test_y_binary = np.ones_like(test_y)
+ test_y_binary[(test_y == 0) | (test_y == 1)] = 0
+ test_y_binary[(test_y == 2) | (test_y == 3) | (test_y == 4)] = 2
+ print("预测时间:", time.time() - t1)
+ print("RFC训练模型评分:" + str(accuracy_score(train_y, rfc.predict(train_x))))
+ print("RFC待测模型评分:" + str(accuracy_score(test_y, rfc.predict(test_x))))
+ print('RFC预测结果:' + str(y_pred))
+ print('---------------------------------------------------------------------------------------------------')
+ print('RFC分类报告:\n' + str(classification_report(test_y, y_pred))) # 生成一个小报告呀
+ print('RFC混淆矩阵:\n' + str(confusion_matrix(test_y, y_pred))) # 这个也是,生成的矩阵的意思是有多少
+ print('rfc分类报告:\n' + str(classification_report(test_y_binary, y_pred_binary))) # 生成一个小报告呀
+ print('rfc混淆矩阵:\n' + str(confusion_matrix(test_y_binary, y_pred_binary))) # 这个也是,生成的矩阵的意思是有多少
+ if save_path is not None:
+ with open(save_path, 'wb') as f:
+ pickle.dump((pca, rfc), f)
+ return pca, rfc
+
+
+def split_x(data: np.ndarray, blk_sz: int) -> list:
+ """
+ Split the data into slices for classification.将数据划分为多个像素块,便于后续识别.
+
+ ;param data: image data, shape (num_rows x 1024 x num_channels)
+ ;param blk_sz: block size
+ ;param sensitivity: 最少有多少个杂物点能够被认为是杂物
+ ;return data_x, data_y: sliced data x (block_num x num_charnnels x blk_sz x blk_sz)
+ """
+ x_list = []
+ for i in range(0, 600 // blk_sz):
+ for j in range(0, 1024 // blk_sz):
+ block_data = data[i * blk_sz: (i + 1) * blk_sz, j * blk_sz: (j + 1) * blk_sz, ...]
+ x_list.append(block_data)
+ return x_list
+
+
+class SpecDetector(object):
+ def __init__(self, model_path, blk_sz=8, channel_num=4):
+ self.blk_sz, self.channel_num = blk_sz, channel_num
+ if os.path.exists(model_path):
+ with open(model_path, "rb") as model_file:
+ self.clf = pickle.load(model_file)
+ else:
+ raise FileNotFoundError("Model File not found")
+
+ def predict(self, data):
+ blocks = split_x(data, blk_sz=self.blk_sz)
+ blocks = np.array(blocks)
+ features = feature(np.array(blocks))
+ y_pred = self.clf.predict(features)
+ y_pred_binary = np.ones_like(y_pred)
+ # classes merge
+ y_pred_binary[(y_pred == 0) | (y_pred == 1) | (y_pred == 3)] = 0
+ # transform to mask
+ mask = self.mask_transform(y_pred_binary, (1024, 600))
+ return mask
+
+ def mask_transform(self, result, dst_size):
+ mask_size = 600//self.blk_sz, 1024 // self.blk_sz
+ mask = np.zeros(mask_size, dtype=np.uint8)
+ for idx, r in enumerate(result):
+ row, col = idx // mask_size[1], idx % mask_size[1]
+ mask[row, col] = r
+ mask = mask.repeat(self.blk_sz, axis = 0).repeat(self.blk_sz, axis = 1)
+ return mask
diff --git a/root_dir.py b/root_dir.py
new file mode 100755
index 0000000..763d568
--- /dev/null
+++ b/root_dir.py
@@ -0,0 +1,10 @@
+# -*- codeing = utf-8 -*-
+# Time : 2022/6/18 9:32
+# @Auther : zhouchao
+# @File: root_dir.py
+# @Software:PyCharm
+import os.path
+import sys
+
+ROOT_DIR = os.path.split(sys.argv[0])[0]
+
diff --git a/test_files/models_test.py b/test_files/models_test.py
new file mode 100755
index 0000000..0c64fc8
--- /dev/null
+++ b/test_files/models_test.py
@@ -0,0 +1,19 @@
+import unittest
+
+import numpy as np
+
+from models import feature
+
+
+class ModelTestCase(unittest.TestCase):
+ def test_feature(self):
+ x_list = [np.ones((8, 8, 6)) * i for i in range(9600)]
+ features = feature(x_list=x_list)
+ self.assertEqual(features[0][0], 0) # add assertion here
+ self.assertEqual(features[0][5], 0) # add assertion here
+ self.assertEqual(features[-1][5], 9599) # add assertion here
+ self.assertEqual(features[-1][0], 9599) # add assertion here
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/test_files/utils_test.py b/test_files/utils_test.py
new file mode 100755
index 0000000..692fdd2
--- /dev/null
+++ b/test_files/utils_test.py
@@ -0,0 +1,119 @@
+import unittest
+
+import numpy as np
+
+from utils import determine_class, split_xy, split_x
+
+
+class DatasetTest(unittest.TestCase):
+ def test_determine_class(self):
+ pixel_block = np.zeros((8, 8), dtype=np.uint8)
+ pixel_block[2: 4, 5: 6] = 2
+ pixel_block[5: 7, 1: 2] = 1
+ pixel_block[4: 6, 1: 6] = 3
+ cls = determine_class(pixel_block, sensitivity=8)
+ self.assertEqual(cls, 3)
+ pixel_block = np.zeros((8, 8), dtype=np.uint8)
+ pixel_block[2: 4, 5: 6] = 2
+ pixel_block[5: 7, 1: 2] = 1
+ pixel_block[4: 6, 1: 6] = 2
+ cls = determine_class(pixel_block, sensitivity=8)
+ self.assertEqual(cls, 2)
+ pixel_block = np.zeros((8, 8), dtype=np.uint8)
+ pixel_block[2: 4, 5: 6] = 1
+ pixel_block[5: 7, 1: 2] = 2
+ pixel_block[4: 6, 1: 6] = 1
+ cls = determine_class(pixel_block, sensitivity=8)
+ self.assertEqual(cls, 1)
+
+ def test_split_xy(self):
+ x = np.arange(600*1024).reshape((600, 1024))
+ y = np.zeros((600, 1024, 3))
+ color_dict = {(0, 0, 255): 1, (255, 255, 255): 0, (0, 255, 0): 2, (255, 255, 0): 3, (0, 255, 255): 4}
+ trans_color_dict = {v: k for k, v in color_dict.items()}
+ # modify the first block
+ y[2: 4, 5: 6] = trans_color_dict[2]
+ y[5: 7, 1: 2] = trans_color_dict[1]
+ y[4: 6, 1: 6] = trans_color_dict[3]
+ # modify the last block
+ y[-4: -2, -6: -5] = trans_color_dict[1]
+ y[-7: -5, -2: -1] = trans_color_dict[2]
+ y[-6: -4, -6: -1] = trans_color_dict[1]
+ # modify the middle block
+ y[64+2: 64+4, 64+5: 64+6] = trans_color_dict[2]
+ y[64+5: 64+7, 64+1: 64+2] = trans_color_dict[1]
+ y[64+4: 64+6, 64+1: 64+6] = trans_color_dict[2]
+ x_list, y_list = split_xy(x, y, blk_sz=8, sensitivity=8)
+ first_block = np.array([[0, 1, 2, 3, 4, 5, 6, 7],
+ [1024, 1025, 1026, 1027, 1028, 1029, 1030, 1031],
+ [2048, 2049, 2050, 2051, 2052, 2053, 2054, 2055],
+ [3072, 3073, 3074, 3075, 3076, 3077, 3078, 3079],
+ [4096, 4097, 4098, 4099, 4100, 4101, 4102, 4103],
+ [5120, 5121, 5122, 5123, 5124, 5125, 5126, 5127],
+ [6144, 6145, 6146, 6147, 6148, 6149, 6150, 6151],
+ [7168, 7169, 7170, 7171, 7172, 7173, 7174, 7175],])
+ sum_value = np.sum(np.sum(x_list[0]-first_block))
+ self.assertEqual(sum_value, 0)
+ self.assertEqual(y_list[0], 3)
+ last_block = np.array(
+ [[607224, 607225, 607226, 607227, 607228, 607229, 607230, 607231],
+ [608248, 608249, 608250, 608251, 608252, 608253, 608254, 608255],
+ [609272, 609273, 609274, 609275, 609276, 609277, 609278, 609279],
+ [610296, 610297, 610298, 610299, 610300, 610301, 610302, 610303],
+ [611320, 611321, 611322, 611323, 611324, 611325, 611326, 611327],
+ [612344, 612345, 612346, 612347, 612348, 612349, 612350, 612351],
+ [613368, 613369, 613370, 613371, 613372, 613373, 613374, 613375],
+ [614392, 614393, 614394, 614395, 614396, 614397, 614398, 614399],])
+ sum_value = np.sum(np.sum(x_list[-1]-last_block))
+ self.assertEqual(sum_value, 0)
+ self.assertEqual(y_list[-1], 1)
+ middle_block = np.array([[65600, 65601, 65602, 65603, 65604, 65605, 65606, 65607],
+ [66624, 66625, 66626, 66627, 66628, 66629, 66630, 66631],
+ [67648, 67649, 67650, 67651, 67652, 67653, 67654, 67655],
+ [68672, 68673, 68674, 68675, 68676, 68677, 68678, 68679],
+ [69696, 69697, 69698, 69699, 69700, 69701, 69702, 69703],
+ [70720, 70721, 70722, 70723, 70724, 70725, 70726, 70727],
+ [71744, 71745, 71746, 71747, 71748, 71749, 71750, 71751],
+ [72768, 72769, 72770, 72771, 72772, 72773, 72774, 72775]])
+ sum_value = np.sum(np.sum(x_list[1032]-middle_block))
+ self.assertEqual(sum_value, 0)
+ self.assertEqual(y_list[1032], 2)
+
+ def test_split_x(self):
+ x = np.arange(600 * 1024).reshape((600, 1024))
+ x_list = split_x(x, blk_sz=8)
+ first_block = np.array([[0, 1, 2, 3, 4, 5, 6, 7],
+ [1024, 1025, 1026, 1027, 1028, 1029, 1030, 1031],
+ [2048, 2049, 2050, 2051, 2052, 2053, 2054, 2055],
+ [3072, 3073, 3074, 3075, 3076, 3077, 3078, 3079],
+ [4096, 4097, 4098, 4099, 4100, 4101, 4102, 4103],
+ [5120, 5121, 5122, 5123, 5124, 5125, 5126, 5127],
+ [6144, 6145, 6146, 6147, 6148, 6149, 6150, 6151],
+ [7168, 7169, 7170, 7171, 7172, 7173, 7174, 7175], ])
+ sum_value = np.sum(np.sum(x_list[0] - first_block))
+ self.assertEqual(sum_value, 0)
+ last_block = np.array(
+ [[607224, 607225, 607226, 607227, 607228, 607229, 607230, 607231],
+ [608248, 608249, 608250, 608251, 608252, 608253, 608254, 608255],
+ [609272, 609273, 609274, 609275, 609276, 609277, 609278, 609279],
+ [610296, 610297, 610298, 610299, 610300, 610301, 610302, 610303],
+ [611320, 611321, 611322, 611323, 611324, 611325, 611326, 611327],
+ [612344, 612345, 612346, 612347, 612348, 612349, 612350, 612351],
+ [613368, 613369, 613370, 613371, 613372, 613373, 613374, 613375],
+ [614392, 614393, 614394, 614395, 614396, 614397, 614398, 614399], ])
+ sum_value = np.sum(np.sum(x_list[-1] - last_block))
+ self.assertEqual(sum_value, 0)
+ middle_block = np.array([[65600, 65601, 65602, 65603, 65604, 65605, 65606, 65607],
+ [66624, 66625, 66626, 66627, 66628, 66629, 66630, 66631],
+ [67648, 67649, 67650, 67651, 67652, 67653, 67654, 67655],
+ [68672, 68673, 68674, 68675, 68676, 68677, 68678, 68679],
+ [69696, 69697, 69698, 69699, 69700, 69701, 69702, 69703],
+ [70720, 70721, 70722, 70723, 70724, 70725, 70726, 70727],
+ [71744, 71745, 71746, 71747, 71748, 71749, 71750, 71751],
+ [72768, 72769, 72770, 72771, 72772, 72773, 72774, 72775]])
+ sum_value = np.sum(np.sum(x_list[1032] - middle_block))
+ self.assertEqual(sum_value, 0)
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/utils.py b/utils.py
new file mode 100755
index 0000000..42918b7
--- /dev/null
+++ b/utils.py
@@ -0,0 +1,190 @@
+import cv2
+import numpy as np
+
+import glob
+import os
+import time
+
+import matplotlib.pyplot as plt
+
+from models import SpecDetector
+
+
+def trans_color(pixel: np.ndarray, color_dict: dict = None) -> int:
+ """
+ 将label转为类别
+
+ :param pixel: 一个 n x n 的像素块
+ :param color_dict: 用于转化的字典 {(0, 0, 255): 1, ....} 色彩采用bgr
+ :return:类别白噢好
+ """
+ # 0 表示的是背景, 1表示的是烟梗,剩下的都是杂质
+ if color_dict is None:
+ color_dict = {(0, 0, 255): 1, (255, 255, 255): 0, (0, 255, 0): 2, (255, 255, 0): 3, (0, 255, 255): 4}
+ if (pixel[0], pixel[1], pixel[2]) in color_dict.keys():
+ return color_dict[(pixel[0], pixel[1], pixel[2])]
+ else:
+ return -1
+
+
+def determine_class(pixel_blk: np.ndarray, sensitivity=8) -> int:
+ """
+ 决定像素块的类别
+
+ :param pixel_blk: 像素块
+ :param sensitivity: 敏感度
+ :return:
+ """
+ defect_dict = {0: 0, 1: 0, 2: 1, 3: 1, 4: 1, 5: 1, 6: 1}
+ color_numbers = {cls: pixel_blk.shape[0] ** 2 - np.count_nonzero(pixel_blk - cls)
+ for cls in defect_dict.keys()}
+ grant_cls = {0: 0, 1: 0}
+ for cls, num in color_numbers.items():
+ grant_cls[defect_dict[cls]] += num
+ if grant_cls[1] >= sensitivity:
+ color_numbers = {cls: color_numbers[cls] for cls in [2, 3, 4, 5, 6]}
+ return max(color_numbers, key=color_numbers.get)
+ else:
+ if color_numbers[1] >= sensitivity:
+ return 1
+ return 0
+
+
+def split_xy(data: np.ndarray, labeled_img: np.ndarray, blk_sz: int, sensitivity: int = 12,
+ color_dict=None, add_background=True) -> tuple:
+ """
+ Split the data into slices for classification.将数据划分为多个像素块,便于后续识别.
+
+ ;param data: image data, shape (num_rows x 1024 x num_channels)
+ ;param labeled_img: RGB labeled img with respect to the image!
+ make sure that the defect is (255, 0, 0) and background is (255, 255, 255)
+ ;param blk_sz: block size
+ ;param sensitivity: 最少有多少个杂物点能够被认为是杂物
+ ;return data_x, data_y: sliced data x (block_num x num_charnnels x blk_sz x blk_sz)
+ data y (block_num, ) 1 是杂质, 0是无杂质
+ """
+ assert (data.shape[0] == labeled_img.shape[0]) and (data.shape[1] == labeled_img.shape[1])
+ color_dict = {(0, 0, 255): 1, (255, 255, 255): 0, (0, 255, 0): 2, (255, 255, 0): 3, (0, 255, 255): 4}\
+ if color_dict is None else color_dict
+ class_img = np.zeros((labeled_img.shape[0], labeled_img.shape[1]), dtype=int)
+ for color, class_idx in color_dict.items():
+ truth_map = np.all(labeled_img == color, axis=2)
+ class_img[truth_map] = class_idx
+ x_list, y_list = [], []
+ for i in range(0, 600 // blk_sz):
+ for j in range(0, 1024 // blk_sz):
+ block_data = data[i * blk_sz: (i + 1) * blk_sz, j * blk_sz: (j + 1) * blk_sz, ...]
+ block_label = class_img[i * blk_sz: (i + 1) * blk_sz, j * blk_sz: (j + 1) * blk_sz, ...]
+ block_label = determine_class(block_label, sensitivity=sensitivity)
+ if add_background:
+ y_list.append(block_label)
+ x_list.append(block_data)
+ else:
+ if block_label != 0:
+ y_list.append(block_label)
+ x_list.append(block_data)
+ return x_list, y_list
+
+
+def split_x(data: np.ndarray, blk_sz: int) -> list:
+ """
+ Split the data into slices for classification.将数据划分为多个像素块,便于后续识别.
+
+ ;param data: image data, shape (num_rows x 1024 x num_channels)
+ ;param blk_sz: block size
+ ;param sensitivity: 最少有多少个杂物点能够被认为是杂物
+ ;return data_x, data_y: sliced data x (block_num x num_charnnels x blk_sz x blk_sz)
+ """
+ x_list = []
+ for i in range(0, 600 // blk_sz):
+ for j in range(0, 1024 // blk_sz):
+ block_data = data[i * blk_sz: (i + 1) * blk_sz, j * blk_sz: (j + 1) * blk_sz, ...]
+ x_list.append(block_data)
+ return x_list
+
+
+def visualization_evaluation(detector, data_path, selected_bands=None):
+ selected_bands = [76, 146, 216, 367, 383, 406] if selected_bands is None else selected_bands
+ nrows, ncols = 600, 1024
+ image_paths = glob.glob(os.path.join(data_path, "calibrated*.raw"))
+ for idx, image_path in enumerate(image_paths):
+ with open(image_path, 'rb') as f:
+ data = f.read()
+ img = np.frombuffer(data, dtype=np.float32).reshape((nrows, -1, ncols)).transpose(0, 2, 1)
+ nbands = img.shape[2]
+ t1 = time.time()
+ mask = detector.predict(img[..., selected_bands] if nbands == 448 else img)
+ time_spent = time.time() - t1
+ if nbands == 448:
+ rgb_img = np.asarray(img[..., [372, 241, 169]] * 255, dtype=np.uint8)
+ else:
+ rgb_img = np.asarray(img[..., [0, 1, 2]] * 255, dtype=np.uint8)
+ fig, axs = plt.subplots(1, 2)
+ axs[0].imshow(rgb_img)
+ axs[1].imshow(mask)
+ fig.suptitle(f"time spent {time_spent*1000:.2f} ms" + f"\n{image_path}")
+ plt.savefig(f"./dataset/{idx}.png", dpi=300)
+ plt.show()
+
+
+def visualization_y(y_list, k_size):
+ mask = np.zeros((600//k_size, 1024//k_size), dtype=np.uint8)
+ for idx, r in enumerate(y_list):
+ row, col = idx // (1024 // k_size), idx % (1024 // k_size)
+ mask[row, col] = r
+ fig, axs = plt.subplots()
+ axs.imshow(mask)
+ plt.show()
+
+
+def read_raw_file(file_name, selected_bands=None):
+ with open(file_name, "rb") as f:
+ data = np.frombuffer(f.read(), dtype=np.float32).reshape((600, -1, 1024)).transpose(0, 2, 1)
+ if selected_bands is not None:
+ data = data[..., selected_bands]
+ return data
+
+
+def read_black_and_white_file(file_name):
+ with open(file_name, "rb") as f:
+ data = np.frombuffer(f.read(), dtype=np.float32).reshape((1, 448, 1024)).transpose(0, 2, 1)
+ return data
+
+
+def label2pic(label, color_dict):
+ pic = np.zeros((label.shape[0], label.shape[1], 3))
+ for color, cls in color_dict.items():
+ pic[label == cls] = color
+ return pic
+
+
+def generate_tobacco_label(data, model_file, blk_sz, selected_bands):
+ model = SpecDetector(model_path=model_file, blk_sz=blk_sz, channel_num=len(selected_bands))
+ y_label = model.predict(data)
+ x_list, y_list = [], []
+ for i in range(0, 600 // blk_sz):
+ for j in range(0, 1024 // blk_sz):
+ if np.sum(np.sum(y_label[i * blk_sz: (i + 1) * blk_sz, j * blk_sz: (j + 1) * blk_sz, ...])) \
+ > 0:
+ block_data = data[i * blk_sz: (i + 1) * blk_sz, j * blk_sz: (j + 1) * blk_sz, ...]
+ x_list.append(block_data)
+ y_list.append(1)
+ return x_list, y_list
+
+
+def generate_impurity_label(data, light_threshold, color_dict, split_line=0, target_class_right=None,
+ target_class_left=None,):
+ y_label = np.zeros((data.shape[0], data.shape[1]))
+ for i in range(0, 600):
+ for j in range(0, 1024):
+ if np.sum(np.sum(data[i, j])) >= light_threshold:
+ if j > split_line:
+ y_label[i, j] = target_class_right
+ else:
+ y_label[i, j] = target_class_left
+ pic = label2pic(y_label, color_dict=color_dict)
+ fig, axs = plt.subplots(2, 1)
+ axs[0].matshow(y_label)
+ axs[1].matshow(data[..., 0])
+ plt.show()
+ return pic
| |