├── Data
    └── BOSSBase_512
    │   ├── 1.pgm
    │   ├── 10.pgm
    │   ├── 2.pgm
    │   ├── 3.pgm
    │   ├── 4.pgm
    │   ├── 5.pgm
    │   ├── 6.pgm
    │   ├── 7.pgm
    │   ├── 8.pgm
    │   └── 9.pgm
├── Implement
    ├── .idea
    │   ├── Implement.iml
    │   ├── misc.xml
    │   ├── modules.xml
    │   └── workspace.xml
    ├── SRM_Kernels.npy
    ├── YeNet.py
    ├── generator.py
    ├── layers.py
    ├── main.py
    ├── preprocessing.py
    ├── testfiles
    │   ├── command.sh
    │   ├── test_data_split.py
    │   └── utils_test.py
    └── utils.py
├── README.md
├── command_BOSS.sh
├── command_BOSSTEST.sh
├── command_SUNI_0.4_15000_No_1.sh
└── command_SUNI_0.4_15000_No_2.sh


/Data/BOSSBase_512/1.pgm:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/changshihyoung/TensorFlow-YeNet/ffa3778c350b1636f174d7fd0ab4bfec5ec79d83/Data/BOSSBase_512/1.pgm


--------------------------------------------------------------------------------
/Data/BOSSBase_512/10.pgm:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/changshihyoung/TensorFlow-YeNet/ffa3778c350b1636f174d7fd0ab4bfec5ec79d83/Data/BOSSBase_512/10.pgm


--------------------------------------------------------------------------------
/Data/BOSSBase_512/3.pgm:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/changshihyoung/TensorFlow-YeNet/ffa3778c350b1636f174d7fd0ab4bfec5ec79d83/Data/BOSSBase_512/3.pgm


--------------------------------------------------------------------------------
/Data/BOSSBase_512/4.pgm:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/changshihyoung/TensorFlow-YeNet/ffa3778c350b1636f174d7fd0ab4bfec5ec79d83/Data/BOSSBase_512/4.pgm


--------------------------------------------------------------------------------
/Data/BOSSBase_512/5.pgm:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/changshihyoung/TensorFlow-YeNet/ffa3778c350b1636f174d7fd0ab4bfec5ec79d83/Data/BOSSBase_512/5.pgm


--------------------------------------------------------------------------------
/Data/BOSSBase_512/6.pgm:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/changshihyoung/TensorFlow-YeNet/ffa3778c350b1636f174d7fd0ab4bfec5ec79d83/Data/BOSSBase_512/6.pgm


--------------------------------------------------------------------------------
/Data/BOSSBase_512/7.pgm:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/changshihyoung/TensorFlow-YeNet/ffa3778c350b1636f174d7fd0ab4bfec5ec79d83/Data/BOSSBase_512/7.pgm


--------------------------------------------------------------------------------
/Data/BOSSBase_512/8.pgm:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/changshihyoung/TensorFlow-YeNet/ffa3778c350b1636f174d7fd0ab4bfec5ec79d83/Data/BOSSBase_512/8.pgm


--------------------------------------------------------------------------------
/Data/BOSSBase_512/9.pgm:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/changshihyoung/TensorFlow-YeNet/ffa3778c350b1636f174d7fd0ab4bfec5ec79d83/Data/BOSSBase_512/9.pgm


--------------------------------------------------------------------------------
/Implement/.idea/Implement.iml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <module type="PYTHON_MODULE" version="4">
 3 |   <component name="NewModuleRootManager">
 4 |     <content url="file://$MODULE_DIR$" />
 5 |     <orderEntry type="inheritedJdk" />
 6 |     <orderEntry type="sourceFolder" forTests="false" />
 7 |   </component>
 8 |   <component name="TestRunnerService">
 9 |     <option name="projectConfiguration" value="py.test" />
10 |     <option name="PROJECT_TEST_RUNNER" value="py.test" />
11 |   </component>
12 | </module>


--------------------------------------------------------------------------------
/Implement/.idea/misc.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <project version="4">
3 |   <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.5" project-jdk-type="Python SDK" />
4 | </project>


--------------------------------------------------------------------------------
/Implement/.idea/modules.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <project version="4">
3 |   <component name="ProjectModuleManager">
4 |     <modules>
5 |       <module fileurl="file://$PROJECT_DIR$/.idea/Implement.iml" filepath="$PROJECT_DIR$/.idea/Implement.iml" />
6 |     </modules>
7 |   </component>
8 | </project>


--------------------------------------------------------------------------------
/Implement/.idea/workspace.xml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8"?>
  2 | <project version="4">
  3 |   <component name="ChangeListManager">
  4 |     <list default="true" id="a55bed33-2a00-460e-9653-59ee4230743f" name="Default" comment="" />
  5 |     <option name="EXCLUDED_CONVERTED_TO_IGNORED" value="true" />
  6 |     <option name="TRACKING_ENABLED" value="true" />
  7 |     <option name="SHOW_DIALOG" value="false" />
  8 |     <option name="HIGHLIGHT_CONFLICTS" value="true" />
  9 |     <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
 10 |     <option name="LAST_RESOLUTION" value="IGNORE" />
 11 |   </component>
 12 |   <component name="FileEditorManager">
 13 |     <leaf SIDE_TABS_SIZE_LIMIT_KEY="300">
 14 |       <file leaf-file-name="main.py" pinned="false" current-in-tab="false">
 15 |         <entry file="file://$PROJECT_DIR$/main.py">
 16 |           <provider selected="true" editor-type-id="text-editor">
 17 |             <state relative-caret-position="736">
 18 |               <caret line="44" column="36" lean-forward="false" selection-start-line="44" selection-start-column="25" selection-end-line="44" selection-end-column="36" />
 19 |               <folding>
 20 |                 <element signature="e#0#15#0" expanded="true" />
 21 |               </folding>
 22 |             </state>
 23 |           </provider>
 24 |         </entry>
 25 |       </file>
 26 |       <file leaf-file-name="preprocessing.py" pinned="false" current-in-tab="true">
 27 |         <entry file="file://$PROJECT_DIR$/preprocessing.py">
 28 |           <provider selected="true" editor-type-id="text-editor">
 29 |             <state relative-caret-position="298">
 30 |               <caret line="160" column="20" lean-forward="false" selection-start-line="160" selection-start-column="20" selection-end-line="160" selection-end-column="20" />
 31 |               <folding>
 32 |                 <element signature="e#0#9#0" expanded="true" />
 33 |               </folding>
 34 |             </state>
 35 |           </provider>
 36 |         </entry>
 37 |       </file>
 38 |       <file leaf-file-name="utils.py" pinned="false" current-in-tab="false">
 39 |         <entry file="file://$PROJECT_DIR$/utils.py">
 40 |           <provider selected="true" editor-type-id="text-editor">
 41 |             <state relative-caret-position="782">
 42 |               <caret line="286" column="86" lean-forward="true" selection-start-line="285" selection-start-column="12" selection-end-line="286" selection-end-column="86" />
 43 |               <folding>
 44 |                 <element signature="e#0#23#0" expanded="true" />
 45 |               </folding>
 46 |             </state>
 47 |           </provider>
 48 |         </entry>
 49 |       </file>
 50 |       <file leaf-file-name="generator.py" pinned="false" current-in-tab="false">
 51 |         <entry file="file://$PROJECT_DIR$/generator.py">
 52 |           <provider selected="true" editor-type-id="text-editor">
 53 |             <state relative-caret-position="1380">
 54 |               <caret line="60" column="25" lean-forward="true" selection-start-line="60" selection-start-column="25" selection-end-line="60" selection-end-column="25" />
 55 |               <folding>
 56 |                 <element signature="e#0#9#0" expanded="true" />
 57 |               </folding>
 58 |             </state>
 59 |           </provider>
 60 |         </entry>
 61 |       </file>
 62 |       <file leaf-file-name="layers.py" pinned="false" current-in-tab="false">
 63 |         <entry file="file://$PROJECT_DIR$/layers.py">
 64 |           <provider selected="true" editor-type-id="text-editor">
 65 |             <state relative-caret-position="-713">
 66 |               <caret line="14" column="43" lean-forward="true" selection-start-line="14" selection-start-column="43" selection-end-line="14" selection-end-column="43" />
 67 |               <folding>
 68 |                 <element signature="e#0#23#0" expanded="true" />
 69 |               </folding>
 70 |             </state>
 71 |           </provider>
 72 |         </entry>
 73 |       </file>
 74 |       <file leaf-file-name="YeNet.py" pinned="false" current-in-tab="false">
 75 |         <entry file="file://$PROJECT_DIR$/YeNet.py">
 76 |           <provider selected="true" editor-type-id="text-editor">
 77 |             <state relative-caret-position="276">
 78 |               <caret line="12" column="21" lean-forward="false" selection-start-line="12" selection-start-column="21" selection-end-line="12" selection-end-column="21" />
 79 |               <folding>
 80 |                 <element signature="e#0#23#0" expanded="true" />
 81 |               </folding>
 82 |             </state>
 83 |           </provider>
 84 |         </entry>
 85 |       </file>
 86 |     </leaf>
 87 |   </component>
 88 |   <component name="FileTemplateManagerImpl">
 89 |     <option name="RECENT_TEMPLATES">
 90 |       <list>
 91 |         <option value="Python Script" />
 92 |       </list>
 93 |     </option>
 94 |   </component>
 95 |   <component name="FindInProjectRecents">
 96 |     <findStrings>
 97 |       <find>global_st</find>
 98 |       <find>learning_rate_decay</find>
 99 |       <find>#</find>
100 |       <find>##</find>
101 |       <find>global_step</find>
102 |       <find>'''</find>
103 |       <find>\</find>
104 |       <find>local_learning_rate</find>
105 |       <find>reduce</find>
106 |       <find>learn</find>
107 |       <find>test_dataset</find>
108 |       <find>time</find>
109 |       <find>dataaug</find>
110 |       <find>glob</find>
111 |       <find>misc</find>
112 |       <find>random</find>
113 |       <find>rand</find>
114 |       <find>source_cover_list_shuf</find>
115 |       <find>tlu_threshold</find>
116 |       <find>split</find>
117 |     </findStrings>
118 |     <replaceStrings>
119 |       <replace># *</replace>
120 |       <replace>#</replace>
121 |       <replace>&quot;&quot;&quot;</replace>
122 |       <replace />
123 |       <replace>source_cover_list</replace>
124 |     </replaceStrings>
125 |   </component>
126 |   <component name="IdeDocumentHistory">
127 |     <option name="CHANGED_PATHS">
128 |       <list>
129 |         <option value="$PROJECT_DIR$/YeNet.py" />
130 |         <option value="$PROJECT_DIR$/layers.py" />
131 |         <option value="$PROJECT_DIR$/utils_test.py" />
132 |         <option value="$PROJECT_DIR$/test_data_split.py" />
133 |         <option value="$PROJECT_DIR$/utils.py" />
134 |         <option value="$PROJECT_DIR$/generator.py" />
135 |         <option value="$PROJECT_DIR$/main.py" />
136 |         <option value="$PROJECT_DIR$/preprocessing.py" />
137 |       </list>
138 |     </option>
139 |   </component>
140 |   <component name="JsBuildToolGruntFileManager" detection-done="true" sorting="DEFINITION_ORDER" />
141 |   <component name="JsBuildToolPackageJson" detection-done="true" sorting="DEFINITION_ORDER" />
142 |   <component name="JsGulpfileManager">
143 |     <detection-done>true</detection-done>
144 |     <sorting>DEFINITION_ORDER</sorting>
145 |   </component>
146 |   <component name="ProjectFrameBounds" extendedState="6">
147 |     <option name="x" value="78" />
148 |     <option name="y" value="-18" />
149 |     <option name="width" value="1400" />
150 |     <option name="height" value="980" />
151 |   </component>
152 |   <component name="ProjectView">
153 |     <navigator currentView="ProjectPane" proportions="" version="1">
154 |       <flattenPackages />
155 |       <showMembers />
156 |       <showModules />
157 |       <showLibraryContents />
158 |       <hideEmptyPackages />
159 |       <abbreviatePackageNames />
160 |       <autoscrollToSource />
161 |       <autoscrollFromSource />
162 |       <sortByType />
163 |       <manualOrder />
164 |       <foldersAlwaysOnTop value="true" />
165 |     </navigator>
166 |     <panes>
167 |       <pane id="Scratches" />
168 |       <pane id="ProjectPane">
169 |         <subPane>
170 |           <expand>
171 |             <path>
172 |               <item name="Implement" type="b2602c69:ProjectViewProjectNode" />
173 |               <item name="Implement" type="462c0819:PsiDirectoryNode" />
174 |             </path>
175 |           </expand>
176 |           <select />
177 |         </subPane>
178 |       </pane>
179 |       <pane id="Scope" />
180 |     </panes>
181 |   </component>
182 |   <component name="PropertiesComponent">
183 |     <property name="nodejs_interpreter_path.stuck_in_default_project" value="undefined stuck path" />
184 |     <property name="WebServerToolWindowFactoryState" value="false" />
185 |     <property name="last_opened_file_path" value="$PROJECT_DIR$" />
186 |   </component>
187 |   <component name="RecentsManager">
188 |     <key name="CopyFile.RECENT_KEYS">
189 |       <recent name="E:\@ChangShihyoung\TensorFlow-YeNet\Implement" />
190 |     </key>
191 |   </component>
192 |   <component name="RunDashboard">
193 |     <option name="ruleStates">
194 |       <list>
195 |         <RuleState>
196 |           <option name="name" value="ConfigurationTypeDashboardGroupingRule" />
197 |         </RuleState>
198 |         <RuleState>
199 |           <option name="name" value="StatusDashboardGroupingRule" />
200 |         </RuleState>
201 |       </list>
202 |     </option>
203 |   </component>
204 |   <component name="ShelveChangesManager" show_recycled="false">
205 |     <option name="remove_strategy" value="false" />
206 |   </component>
207 |   <component name="SvnConfiguration">
208 |     <configuration />
209 |   </component>
210 |   <component name="TaskManager">
211 |     <task active="true" id="Default" summary="Default task">
212 |       <changelist id="a55bed33-2a00-460e-9653-59ee4230743f" name="Default" comment="" />
213 |       <created>1520340817798</created>
214 |       <option name="number" value="Default" />
215 |       <option name="presentableId" value="Default" />
216 |       <updated>1520340817798</updated>
217 |     </task>
218 |     <servers />
219 |   </component>
220 |   <component name="ToolWindowManager">
221 |     <frame x="-8" y="-8" width="1696" height="1036" extended-state="6" />
222 |     <layout>
223 |       <window_info id="TODO" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="6" side_tool="false" content_ui="tabs" />
224 |       <window_info id="Event Log" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="7" side_tool="true" content_ui="tabs" />
225 |       <window_info id="Version Control" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="false" weight="0.33" sideWeight="0.5" order="7" side_tool="false" content_ui="tabs" />
226 |       <window_info id="Python Console" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="7" side_tool="false" content_ui="tabs" />
227 |       <window_info id="Run" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="2" side_tool="false" content_ui="tabs" />
228 |       <window_info id="Terminal" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="7" side_tool="false" content_ui="tabs" />
229 |       <window_info id="Project" active="false" anchor="left" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="true" show_stripe_button="true" weight="0.13154761" sideWeight="0.5" order="0" side_tool="false" content_ui="combo" />
230 |       <window_info id="Docker" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="false" weight="0.33" sideWeight="0.5" order="7" side_tool="false" content_ui="tabs" />
231 |       <window_info id="Database" active="false" anchor="right" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="3" side_tool="false" content_ui="tabs" />
232 |       <window_info id="SciView" active="false" anchor="right" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="3" side_tool="false" content_ui="tabs" />
233 |       <window_info id="Structure" active="false" anchor="left" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.13452381" sideWeight="0.5" order="1" side_tool="false" content_ui="tabs" />
234 |       <window_info id="Favorites" active="false" anchor="left" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="2" side_tool="true" content_ui="tabs" />
235 |       <window_info id="Debug" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.4" sideWeight="0.5" order="3" side_tool="false" content_ui="tabs" />
236 |       <window_info id="Cvs" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.25" sideWeight="0.5" order="4" side_tool="false" content_ui="tabs" />
237 |       <window_info id="Message" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="0" side_tool="false" content_ui="tabs" />
238 |       <window_info id="Commander" active="false" anchor="right" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.4" sideWeight="0.5" order="0" side_tool="false" content_ui="tabs" />
239 |       <window_info id="Inspection" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.4" sideWeight="0.5" order="5" side_tool="false" content_ui="tabs" />
240 |       <window_info id="Hierarchy" active="false" anchor="right" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.25" sideWeight="0.5" order="2" side_tool="false" content_ui="combo" />
241 |       <window_info id="Find" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="1" side_tool="false" content_ui="tabs" />
242 |       <window_info id="Ant Build" active="false" anchor="right" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.25" sideWeight="0.5" order="1" side_tool="false" content_ui="tabs" />
243 |     </layout>
244 |     <layout-to-restore>
245 |       <window_info id="TODO" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="6" side_tool="false" content_ui="tabs" />
246 |       <window_info id="Cvs" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.25" sideWeight="0.5" order="4" side_tool="false" content_ui="tabs" />
247 |       <window_info id="Message" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="0" side_tool="false" content_ui="tabs" />
248 |       <window_info id="Commander" active="false" anchor="right" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.4" sideWeight="0.5" order="0" side_tool="false" content_ui="tabs" />
249 |       <window_info id="Event Log" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="7" side_tool="true" content_ui="tabs" />
250 |       <window_info id="Inspection" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.4" sideWeight="0.5" order="5" side_tool="false" content_ui="tabs" />
251 |       <window_info id="Version Control" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="false" weight="0.33" sideWeight="0.5" order="8" side_tool="false" content_ui="tabs" />
252 |       <window_info id="Python Console" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="9" side_tool="false" content_ui="tabs" />
253 |       <window_info id="Run" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="2" side_tool="false" content_ui="tabs" />
254 |       <window_info id="Terminal" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="10" side_tool="false" content_ui="tabs" />
255 |       <window_info id="Project" active="false" anchor="left" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="true" show_stripe_button="true" weight="0.09642857" sideWeight="0.5" order="0" side_tool="false" content_ui="combo" />
256 |       <window_info id="Hierarchy" active="false" anchor="right" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.25" sideWeight="0.5" order="2" side_tool="false" content_ui="combo" />
257 |       <window_info id="Docker" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="false" weight="0.33" sideWeight="0.5" order="11" side_tool="false" content_ui="tabs" />
258 |       <window_info id="Database" active="false" anchor="right" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="3" side_tool="false" content_ui="tabs" />
259 |       <window_info id="Find" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="1" side_tool="false" content_ui="tabs" />
260 |       <window_info id="SciView" active="false" anchor="right" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="4" side_tool="false" content_ui="tabs" />
261 |       <window_info id="Structure" active="false" anchor="left" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.25" sideWeight="0.5" order="1" side_tool="false" content_ui="tabs" />
262 |       <window_info id="Ant Build" active="false" anchor="right" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.25" sideWeight="0.5" order="1" side_tool="false" content_ui="tabs" />
263 |       <window_info id="Favorites" active="false" anchor="left" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.33" sideWeight="0.5" order="2" side_tool="true" content_ui="tabs" />
264 |       <window_info id="Debug" active="false" anchor="bottom" auto_hide="false" internal_type="DOCKED" type="DOCKED" visible="false" show_stripe_button="true" weight="0.4" sideWeight="0.5" order="3" side_tool="false" content_ui="tabs" />
265 |     </layout-to-restore>
266 |   </component>
267 |   <component name="TypeScriptGeneratedFilesManager">
268 |     <option name="version" value="1" />
269 |   </component>
270 |   <component name="VcsContentAnnotationSettings">
271 |     <option name="myLimit" value="2678400000" />
272 |   </component>
273 |   <component name="XDebuggerManager">
274 |     <breakpoint-manager>
275 |       <option name="time" value="1" />
276 |     </breakpoint-manager>
277 |     <watches-manager />
278 |   </component>
279 |   <component name="editorHistoryManager">
280 |     <entry file="file://$PROJECT_DIR$/utils_test.py" />
281 |     <entry file="file://$PROJECT_DIR$/test_data_split.py" />
282 |     <entry file="file://$PROJECT_DIR$/layers.py">
283 |       <provider selected="true" editor-type-id="text-editor">
284 |         <state relative-caret-position="-713">
285 |           <caret line="14" column="43" lean-forward="true" selection-start-line="14" selection-start-column="43" selection-end-line="14" selection-end-column="43" />
286 |           <folding>
287 |             <element signature="e#0#23#0" expanded="true" />
288 |           </folding>
289 |         </state>
290 |       </provider>
291 |     </entry>
292 |     <entry file="file://$PROJECT_DIR$/YeNet.py">
293 |       <provider selected="true" editor-type-id="text-editor">
294 |         <state relative-caret-position="276">
295 |           <caret line="12" column="21" lean-forward="false" selection-start-line="12" selection-start-column="21" selection-end-line="12" selection-end-column="21" />
296 |           <folding>
297 |             <element signature="e#0#23#0" expanded="true" />
298 |           </folding>
299 |         </state>
300 |       </provider>
301 |     </entry>
302 |     <entry file="file://$PROJECT_DIR$/utils.py">
303 |       <provider selected="true" editor-type-id="text-editor">
304 |         <state relative-caret-position="782">
305 |           <caret line="286" column="86" lean-forward="true" selection-start-line="285" selection-start-column="12" selection-end-line="286" selection-end-column="86" />
306 |           <folding>
307 |             <element signature="e#0#23#0" expanded="true" />
308 |           </folding>
309 |         </state>
310 |       </provider>
311 |     </entry>
312 |     <entry file="file://$PROJECT_DIR$/generator.py">
313 |       <provider selected="true" editor-type-id="text-editor">
314 |         <state relative-caret-position="1380">
315 |           <caret line="60" column="25" lean-forward="true" selection-start-line="60" selection-start-column="25" selection-end-line="60" selection-end-column="25" />
316 |           <folding>
317 |             <element signature="e#0#9#0" expanded="true" />
318 |           </folding>
319 |         </state>
320 |       </provider>
321 |     </entry>
322 |     <entry file="file://$PROJECT_DIR$/main.py">
323 |       <provider selected="true" editor-type-id="text-editor">
324 |         <state relative-caret-position="736">
325 |           <caret line="44" column="36" lean-forward="false" selection-start-line="44" selection-start-column="25" selection-end-line="44" selection-end-column="36" />
326 |           <folding>
327 |             <element signature="e#0#15#0" expanded="true" />
328 |           </folding>
329 |         </state>
330 |       </provider>
331 |     </entry>
332 |     <entry file="file://$PROJECT_DIR$/preprocessing.py">
333 |       <provider selected="true" editor-type-id="text-editor">
334 |         <state relative-caret-position="298">
335 |           <caret line="160" column="20" lean-forward="false" selection-start-line="160" selection-start-column="20" selection-end-line="160" selection-end-column="20" />
336 |           <folding>
337 |             <element signature="e#0#9#0" expanded="true" />
338 |           </folding>
339 |         </state>
340 |       </provider>
341 |     </entry>
342 |   </component>
343 | </project>


--------------------------------------------------------------------------------
/Implement/SRM_Kernels.npy:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/changshihyoung/TensorFlow-YeNet/ffa3778c350b1636f174d7fd0ab4bfec5ec79d83/Implement/SRM_Kernels.npy


--------------------------------------------------------------------------------
/Implement/YeNet.py:
--------------------------------------------------------------------------------
  1 | import tensorflow as tf
  2 | from tensorflow.contrib import layers
  3 | from tensorflow.contrib.framework import add_arg_scope, arg_scope, arg_scoped_arguments
  4 | import layers as my_layers
  5 | from utils import *
  6 | 
  7 | SRM_Kernels = np.load('/home/carlchang/YeNetTensorflow/Implement/SRM_Kernels.npy')
  8 | 
  9 | class YeNet(Model):
 10 |     def __init__(self, is_training=None, data_format='NCHW',
 11 |                  with_bn=False, tlu_threshold=3):
 12 |         super(YeNet, self).__init__(is_training=is_training,
 13 |                                     data_format=data_format)
 14 |         self.with_bn = with_bn
 15 |         self.tlu_threshold = tlu_threshold
 16 | 
 17 |     def _build_model(self, inputs):
 18 |         self.inputs = inputs
 19 |         if self.data_format == 'NCHW':
 20 |             channel_axis = 1
 21 |             _inputs = tf.cast(tf.transpose(inputs, [0, 3, 1, 2]), tf.float32)
 22 |         else:
 23 |             channel_axis = 3
 24 |             _inputs = tf.cast(inputs, tf.float32)
 25 |         self.L = []
 26 |         with arg_scope([layers.avg_pool2d], 
 27 |                         padding='VALID', data_format=self.data_format):
 28 |             with tf.variable_scope('SRM_preprocess'):
 29 |                 W_SRM = tf.get_variable('W', initializer=SRM_Kernels, 
 30 |                                         dtype=tf.float32, 
 31 |                                         regularizer=None)
 32 |                 b = tf.get_variable('b', shape=[30], dtype=tf.float32, 
 33 |                                     initializer=tf.constant_initializer(0.))
 34 |                 self.L.append(tf.nn.bias_add( 
 35 |                                              tf.nn.conv2d(_inputs, 
 36 |                                                           W_SRM, [1,1,1,1], 'VALID', 
 37 |                                                           data_format=self.data_format), b, 
 38 |                                                           data_format=self.data_format, name='Layer1'))
 39 |                 self.L.append(tf.clip_by_value(self.L[-1], 
 40 |                               -self.tlu_threshold, self.tlu_threshold, 
 41 |                               name='TLU'))
 42 |             with tf.variable_scope('ConvNetwork'):
 43 |                 with arg_scope([my_layers.conv2d], 
 44 |                                 num_outputs=30, 
 45 |                                 kernel_size=3, stride=1, padding='VALID', 
 46 |                                 data_format=self.data_format, 
 47 |                                 activation_fn=tf.nn.relu, 
 48 |                                 weights_initializer=layers.xavier_initializer_conv2d(), 
 49 |                                 weights_regularizer=layers.l2_regularizer(5e-4), 
 50 |                                 biases_initializer=tf.constant_initializer(0.2), 
 51 |                                 biases_regularizer=None), arg_scope([layers.batch_norm], 
 52 |                                 decay=0.9, center=True, scale=True, 
 53 |                                 updates_collections=None, is_training=self.is_training, 
 54 |                                 fused=True, data_format=self.data_format):
 55 |                     if self.with_bn:
 56 |                         self.L.append(layers.batch_norm(self.L[-1],
 57 |                                       scope='Norm1'))
 58 |                     self.L.append(my_layers.conv2d(self.L[-1], 
 59 |                                   scope='Layer2'))
 60 |                     if self.with_bn:
 61 |                         self.L.append(layers.batch_norm(self.L[-1], 
 62 |                                       scope='Norm2'))
 63 |                     self.L.append(my_layers.conv2d(self.L[-1], 
 64 |                                   scope='Layer3'))
 65 |                     if self.with_bn:
 66 |                         self.L.append(layers.batch_norm(self.L[-1], 
 67 |                                       scope='Norm3'))
 68 |                     self.L.append(my_layers.conv2d(self.L[-1], 
 69 |                                   scope='Layer4'))
 70 |                     if self.with_bn:
 71 |                         self.L.append(layers.batch_norm(self.L[-1], 
 72 |                                       scope='Norm4'))
 73 |                     self.L.append(layers.avg_pool2d(self.L[-1], 
 74 |                                   kernel_size=[2,2], scope='Stride1'))
 75 |                     with arg_scope([my_layers.conv2d], kernel_size=5, 
 76 |                                     num_outputs=32):
 77 |                         self.L.append(my_layers.conv2d(self.L[-1], 
 78 |                                       scope='Layer5'))
 79 |                         if self.with_bn:
 80 |                             self.L.append(layers.batch_norm(self.L[-1], 
 81 |                                           scope='Norm5'))
 82 |                         self.L.append(layers.avg_pool2d(self.L[-1], 
 83 |                                       kernel_size=[3,3], 
 84 |                                       scope='Stride2'))
 85 |                         self.L.append(my_layers.conv2d(self.L[-1], 
 86 |                                       scope='Layer6'))
 87 |                         if self.with_bn:
 88 |                             self.L.append(layers.batch_norm(self.L[-1], 
 89 |                                           scope='Norm6'))
 90 |                         self.L.append(layers.avg_pool2d(self.L[-1], 
 91 |                                       kernel_size=[3,3], 
 92 |                                       scope='Stride3'))
 93 |                         self.L.append(my_layers.conv2d(self.L[-1], 
 94 |                                       scope='Layer7'))
 95 |                         if self.with_bn:
 96 |                             self.L.append(layers.batch_norm(self.L[-1], 
 97 |                                           scope='Norm7'))
 98 |                     self.L.append(layers.avg_pool2d(self.L[-1], 
 99 |                                   kernel_size=[3,3], 
100 |                                   scope='Stride4'))
101 |                     self.L.append(my_layers.conv2d(self.L[-1], 
102 |                                   num_outputs=16, 
103 |                                   scope='Layer8'))
104 |                     if self.with_bn:
105 |                         self.L.append(layers.batch_norm(self.L[-1], 
106 |                                       scope='Norm8'))
107 |                     self.L.append(my_layers.conv2d(self.L[-1], 
108 |                                   num_outputs=16, stride=3, 
109 |                                   scope='Layer9'))
110 |                     if self.with_bn:
111 |                         self.L.append(layers.batch_norm(self.L[-1], 
112 |                                       scope='Norm9'))
113 |                 self.L.append(layers.flatten(self.L[-1]))
114 |                 self.L.append(layers.fully_connected(self.L[-1], num_outputs=2, 
115 |                                                      activation_fn=None, normalizer_fn=None,
116 |                                                      weights_initializer=tf.random_normal_initializer(mean=0.,
117 |                                                                                                       stddev=0.01),
118 |                                                      biases_initializer=tf.constant_initializer(0.), scope='ip'))
119 |         self.outputs = self.L[-1]
120 |         return self.outputs
121 |     
122 | 


--------------------------------------------------------------------------------
/Implement/generator.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | import numpy as np
 3 | import tensorflow as tf
 4 | from scipy import misc, io
 5 | from random import shuffle
 6 | 
 7 | def get_files(cover_dir, stego_dir, use_shuf_pair=False):
 8 |     """
 9 |     从cover和stego文件夹中提取图片，返回到get_batches组成batch
10 |     shuf_pair决定了组成batch时，cover与stego是否成对
11 |     """
12 |     file = []
13 |     for filename in os.listdir(cover_dir + '/'):
14 |         file.append(filename)
15 |     shuffle(file)
16 |     file_shuf1 = file
17 | 
18 |     img = []
19 |     img_label = []
20 |     if use_shuf_pair:
21 |         shuffle(file)
22 |         file_shuf2 = file
23 |         for file_idx in range(len(file_shuf1)):
24 |             img.append(cover_dir + '/' + file_shuf1[file_idx])
25 |             img_label.append(0)
26 |             img.append(stego_dir + '/' + file_shuf2[file_idx])
27 |             img_label.append(1)
28 |     else:
29 |         for filename in file_shuf1:
30 |             img.append(cover_dir + '/' + filename)
31 |             img_label.append(0)
32 |             img.append(stego_dir + '/' + filename)
33 |             img_label.append(1)
34 | 
35 |     #将img_list和img_label写入cover路径下的img_label_list.txt
36 |     #with open(cover_dir + '/' + 'img_label_list.txt', 'w') as f:
37 |     #    for img_idx in range(len(img)):
38 |     #        f.write(img[img_idx]+' '+str(img_label[img_idx])+'\n')
39 |             
40 |     return img, img_label
41 | 
42 | def get_minibatches(img, img_label, batch_size):
43 |     """
44 |     替代get_batches函数的作用，批次读取数据，每次返回batch_size大小的数据
45 |     """
46 |     for start_idx in range(0, len(img) - batch_size + 1, batch_size):
47 |         excerpt = slice(start_idx, start_idx + batch_size)
48 |         img_minibatch = img[excerpt]
49 |         img_label_minibatch = img_label[excerpt]
50 |         yield img_minibatch, img_label_minibatch
51 | 
52 | def get_minibatches_content_img(train_img_minibatch_list, img_height, img_width):
53 |     """
54 |     读取get_minibatches函数返回路径对应的内容，将图片实际内容转换为batch，作为返回值
55 |     """
56 |     img_num = len(train_img_minibatch_list)
57 |     image_minibatch_content = np.zeros([img_num, img_height, img_width, 1], dtype=np.float32)
58 | 
59 |     i = 0
60 |     for img_file in train_img_minibatch_list:
61 |         content = misc.imread(img_file)
62 |         image_minibatch_content[i, :, :, 0] = content
63 |         i = i + 1
64 | 
65 |     return image_minibatch_content
66 | 
67 | """
68 | def get_batches(img, img_label, batch_size, capacity):
69 |     #
70 |     #根据get_files返回的图片列表和标签列表，生成训练用batch
71 |     #需要注意的是：输入图片应具有相同的高、宽
72 |     #
73 |     img = tf.cast(img, tf.string)
74 |     img_label = tf.cast(img_label, tf.int32)
75 | 
76 |     # 生成输入队列（queue），tensorflow有多种方法，这里展示image与label分开时的情况
77 |     input_queue = tf.train.slice_input_producer([img, img_label])
78 | 
79 |     # 从队列里读出label，image（需要对相应的图片进行解码）
80 |     label = input_queue[1]
81 |     image_contents = tf.read_file(input_queue[0])  #pgm图像不能这么使用
82 |     image = tf.image.decode_image(image_contents, channels=1)  #pgm图像不能这么使用
83 |     ##数据集augmentation的部分
84 | 
85 |     # 对数据进行大小标准化等操作，tf.image下有很多对image的处理，randomflip等
86 |     #image = tf.image.resize_image_with_crop_or_pad(image, image_W, image_H)
87 |     #image = tf.image.per_image_standardization(image)
88 | 
89 |     #[image, label]是tensor型变量
90 |     image_batch, label_batch = tf.train.batch([image, label],
91 |                                               batch_size=batch_size,
92 |                                               num_threads=64,
93 |                                               capacity=capacity)
94 |     label_batch = tf.reshape(label_batch, [batch_size])
95 | 
96 |     return image_batch, label_batch
97 | """


--------------------------------------------------------------------------------
/Implement/layers.py:
--------------------------------------------------------------------------------
  1 | import tensorflow as tf
  2 | from tensorflow.contrib import layers
  3 | from tensorflow.contrib.framework import add_arg_scope
  4 | 
  5 | @add_arg_scope
  6 | def conv2d(inputs,
  7 |            num_outputs,
  8 |            kernel_size,
  9 |            stride=1,
 10 |            padding='SAME',
 11 |            data_format=None,
 12 |            rate=1,
 13 |            activation_fn=tf.nn.relu,
 14 |            normalizer_fn=None,
 15 |            normalize_after_activation=True,
 16 |            normalizer_params=None,
 17 |            weights_initializer=layers.xavier_initializer(),
 18 |            weights_regularizer=None,
 19 |            biases_initializer=tf.zeros_initializer(),
 20 |            biases_regularizer=None,
 21 |            reuse=None,
 22 |            variables_collections=None,
 23 |            outputs_collections=None,
 24 |            trainable=True,
 25 |            scope=None):
 26 |     with tf.variable_scope(scope, 'Conv', reuse=reuse):
 27 |         if data_format == 'NHWC':
 28 |             num_inputs = inputs.get_shape().as_list()[3]
 29 |             height = inputs.get_shape().as_list()[1]
 30 |             width = inputs.get_shape().as_list()[2]
 31 |             if isinstance(stride, int):
 32 |                 strides = [1, stride, stride, 1]
 33 |             elif isinstance(stride, list) or isinstance(stride, tuple):
 34 |                 if len(stride) == 1:
 35 |                     strides = [1] + stride * 2 + [1]
 36 |                 else:
 37 |                     strides = [1, stride[0], stride[1], 1]
 38 |             else:
 39 |                 raise TypeError('stride is not an int, list or'
 40 |                                 + 'a tuple, is %s' % type(stride))
 41 |         else:
 42 |             num_inputs = inputs.get_shape().as_list()[1]
 43 |             height = inputs.get_shape().as_list()[2]
 44 |             width = inputs.get_shape().as_list()[3]
 45 |             if isinstance(stride, int):
 46 |                 strides = [1, 1, stride, stride]
 47 |             elif isinstance(stride, list) or isinstance(stride, tuple):
 48 |                 if len(stride) == 1:
 49 |                     strides = [1, 1] + stride * 2
 50 |                 else:
 51 |                     strides = [1, 1, stride[0], stride[1]]
 52 |             else:
 53 |                 raise TypeError('stride is not an int, list or'
 54 |                                 + 'a tuple, is %s' % type(stride))
 55 |         if isinstance(kernel_size, int):
 56 |             kernel_height = kernel_size
 57 |             kernel_width = kernel_size
 58 |         elif isinstance(kernel_size, list) or isinstance(kernel_size, tuple):
 59 |             kernel_height = kernel_size[0]
 60 |             kernel_width = kernel_size[1]
 61 |         else:
 62 |             raise ValueError('kernel_size is not an int, list or'
 63 |                              + 'a tuple, is %s' % type(kernel_size))
 64 |         weights = tf.get_variable('weights', [kernel_height,
 65 |                                   kernel_width, num_inputs, num_outputs],
 66 |                                   'float32', weights_initializer,
 67 |                                   weights_regularizer, trainable,
 68 |                                   variables_collections)
 69 |         outputs = tf.nn.conv2d(inputs, weights, strides, padding,
 70 |                             data_format=data_format)
 71 |         if biases_initializer is not None:
 72 |             biases = tf.get_variable('biases', [num_outputs], 'float32',
 73 |                                      biases_initializer,
 74 |                                      biases_regularizer,
 75 |                                      trainable, variables_collections)
 76 |             outputs = tf.nn.bias_add(outputs, biases, data_format)
 77 |         if normalizer_fn is not None  and  not normalize_after_activation:
 78 |             normalizer_params = normalizer_params or {}
 79 |             outputs = normalizer_fn(outputs, **normalizer_params)
 80 |         if activation_fn is not None:
 81 |             outputs = activation_fn(outputs)
 82 |         if normalizer_fn is not None and normalize_after_activation:
 83 |             normalizer_params = normalizer_params or {}
 84 |             outputs = normalizer_fn(outputs, **normalizer_params)
 85 |     return outputs
 86 | 
 87 | """
 88 | @add_arg_scope
 89 | def double_conv2d(ref_half, real_half,
 90 |                   num_outputs,
 91 |                   kernel_size,
 92 |                   stride=1,
 93 |                   padding='SAME',
 94 |                   data_format=None,
 95 |                   rate=1,
 96 |                   activation_fn=tf.nn.relu,
 97 |                   normalizer_fn=None,
 98 |                   normalize_after_activation=True,
 99 |                   normalizer_params=None,
100 |                   weights_initializer=layers.xavier_initializer(),
101 |                   weights_regularizer=None,
102 |                   biases_initializer=tf.zeros_initializer(),
103 |                   biases_regularizer=None,
104 |                   reuse=None,
105 |                   variables_collections=None,
106 |                   outputs_collections=None,
107 |                   trainable=True,
108 |                   scope=None):
109 |     with tf.variable_scope(scope, 'Conv', reuse=reuse):
110 |         if data_format == 'NHWC':
111 |             num_inputs = real_half.get_shape().as_list()[3]
112 |             height = real_half.get_shape().as_list()[1]
113 |             width = real_half.get_shape().as_list()[2]
114 |             if isinstance(stride, int):
115 |                 strides = [1, stride, stride, 1]
116 |             elif isinstance(stride, list) or isinstance(stride, tuple):
117 |                 if len(stride) == 1:
118 |                     strides = [1] + stride * 2 + [1]
119 |                 else:
120 |                     strides = [1, stride[0], stride[1], 1]
121 |             else:
122 |                 raise TypeError('stride is not an int, list or' 
123 |                                 + 'a tuple, is %s' % type(stride))
124 |         else:
125 |             num_inputs = real_half.get_shape().as_list()[1]
126 |             height = real_half.get_shape().as_list()[2]
127 |             width = real_half.get_shape().as_list()[3]
128 |             if isinstance(stride, int):
129 |                 strides = [1, 1, stride, stride]
130 |             elif isinstance(stride, list) or isinstance(stride, tuple):
131 |                 if len(stride) == 1:
132 |                     strides = [1, 1] + stride * 2
133 |                 else:
134 |                     strides = [1, 1, stride[0], stride[1]]
135 |             else:
136 |                 raise TypeError('stride is not an int, list or' \
137 |                                 + 'a tuple, is %s' % type(stride))
138 |         if isinstance(kernel_size, int):
139 |             kernel_height = kernel_size
140 |             kernel_width = kernel_size
141 |         elif isinstance(kernel_size, list) \
142 |                 or isinstance(kernel_size, tuple):
143 |             kernel_height = kernel_size[0]
144 |             kernel_width = kernel_size[1]
145 |         else:
146 |             raise ValueError('kernel_size is not an int, list or' 
147 |                              + 'a tuple, is %s' % type(kernel_size))
148 |         weights = tf.get_variable('weights', [kernel_height, 
149 |                                   kernel_width, num_inputs, num_outputs], 
150 |                                   'float32', weights_initializer, 
151 |                                   weights_regularizer, trainable, 
152 |                                   variables_collections)
153 |         ref_outputs = tf.nn.conv2d(ref_half, weights, strides, padding, 
154 |                                   data_format=data_format)
155 |         real_outputs = tf.nn.conv2d(real_half, weights, strides, padding, 
156 |                                     data_format=data_format)
157 |         if biases_initializer is not None:
158 |             biases = tf.get_variable('biases', [num_outputs], 'float32', 
159 |                                      biases_initializer, 
160 |                                      biases_regularizer, 
161 |                                      trainable, variables_collections)
162 |             ref_outputs = tf.nn.bias_add(ref_outputs, biases, data_format)
163 |             real_outputs = tf.nn.bias_add(real_outputs, biases, data_format)
164 |         if normalizer_fn is not None  and  not normalize_after_activation:
165 |             normalizer_params = normalizer_params or {}
166 |             ref_outputs, real_outputs = normalizer_fn(ref_outputs, 
167 |                                                       real_outputs, 
168 |                                                       **normalizer_params)
169 |         if activation_fn is not None:
170 |             ref_outputs = activation_fn(ref_outputs)
171 |             real_outputs = activation_fn(real_outputs)
172 |         if normalizer_fn is not None and normalize_after_activation:
173 |             normalizer_params = normalizer_params or {}
174 |             ref_outputs, real_outputs = normalizer_fn(ref_outputs, 
175 |                                                       real_outputs, 
176 |                                                       **normalizer_params)
177 |     return ref_outputs, real_outputs
178 | 
179 | class Vbn_double(object):
180 |     def __init__(self, x, epsilon=1e-5, scope=None):
181 |         shape = x.get_shape().as_list()
182 |         needs_reshape = len(shape) != 4
183 |         if needs_reshape:
184 |             orig_shape = shape
185 |             if len(shape) == 2:
186 |                 if data_format == 'NCHW':
187 |                     x = tf.reshape(x, [shape[0], shape[1], 0, 0])
188 |                 else:
189 |                     x = tf.reshape(x, [shape[0], 1, 1, shape[1]])
190 |             elif len(shape) == 1:
191 |                 x = tf.reshape(x, [shape[0], 1, 1, 1])
192 |             else:
193 |                 assert False, shape
194 |             shape = x.get_shape().as_list()
195 |         with tf.variable_scope(scope):
196 |             self.epsilon = epsilon
197 |             self.scope = scope
198 |             self.mean, self.var = tf.nn.moments(x, [0,2,3], \
199 |                                                 keep_dims=True)
200 |             self.inv_std = tf.rsqrt(self.var + epsilon)
201 |             self.batch_size = int(x.get_shape()[0])
202 |             out = self._normalize(x, self.mean, self.inv_std)
203 |             if needs_reshape:
204 |                 out = tf.reshape(out, orig_shape)
205 |             self.reference_output = out
206 | 
207 |     def __call__(self, x):
208 |         shape = x.get_shape().as_list()
209 |         needs_reshape = len(shape) != 4
210 |         if needs_reshape:
211 |             orig_shape = shape
212 |             if len(shape) == 2:
213 |                 if self.data_format == 'NCHW':
214 |                     x = tf.reshape(x, [shape[0], shape[1], 0, 0])
215 |                 else:
216 |                     x = tf.reshape(x, [shape[0], 1, 1, shape[1]])
217 |             elif len(shape) == 1:
218 |                 x = tf.reshape(x, [shape[0], 1, 1, 1])
219 |             else:
220 |                 assert False, shape
221 |         with tf.variable_scope(self.scope, reuse=True):
222 |             out = self._normalize(x, self.mean, self.inv_std)
223 |             if needs_reshape:
224 |                 out = tf.reshape(out, orig_shape)
225 |         return out
226 | 
227 |     def _normalize(self, x, mean, inv_std):
228 |         shape = x.get_shape().as_list()
229 |         assert len(shape) == 4
230 |         gamma = tf.get_variable("gamma", [1,shape[1],1,1],
231 |                         initializer=tf.constant_initializer(1.))
232 |         beta = tf.get_variable("beta", [1,shape[1],1,1],
233 |                         initializer=tf.constant_initializer(0.))
234 |         coeff = gamma * inv_std
235 |         return (x * coeff) + (beta - mean * coeff)
236 | 
237 | @add_arg_scope
238 | def vbn_double(ref_half, real_half, center=True, scale=True, epsilon=1e-5, \
239 |                data_format='NCHW', instance_norm=True, scope=None, \
240 |                reuse=None):
241 |     assert isinstance(epsilon, float)
242 |     shape = real_half.get_shape().as_list()
243 |     batch_size = int(real_half.get_shape()[0])
244 |     with tf.variable_scope(scope, 'VBN', reuse=reuse):
245 |         if data_format == 'NCHW':
246 |             if scale:
247 |                 gamma = tf.get_variable("gamma", [1,shape[1],1,1],
248 |                             initializer=tf.constant_initializer(1.))
249 |             if center:
250 |                 beta = tf.get_variable("beta", [1,shape[1],1,1],
251 |                             initializer=tf.constant_initializer(0.))
252 |             ref_mean, ref_var = tf.nn.moments(ref_half, [0,2,3], \
253 |                                               keep_dims=True)
254 |         else:
255 |             if scale:
256 |                 gamma = tf.get_variable("gamma", [1,1,1,shape[-1]],
257 |                             initializer=tf.constant_initializer(1.))
258 |             if center:
259 |                 beta = tf.get_variable("beta", [1,1,1,shape[-1]],
260 |                             initializer=tf.constant_initializer(0.))
261 |             ref_mean, ref_var = tf.nn.moments(ref_half, [0,1,2], \
262 |                                               keep_dims=True)
263 |         def _normalize(x, mean, var):
264 |             inv_std = tf.rsqrt(var + epsilon)
265 |             if scale:
266 |                 coeff = inv_std * gamma
267 |             else:
268 |                 coeff = inv_std
269 |             if center:
270 |                 return (x * coeff) + (beta - mean * coeff)
271 |             else:
272 |                 return (x - mean) * coeff
273 |         if instance_norm:
274 |             if data_format == 'NCHW':
275 |                 real_mean, real_var = tf.nn.moments(real_half, [2,3], \
276 |                                                   keep_dims=True)
277 |             else:
278 |                 real_mean, real_var = tf.nn.moments(real_half, [1,2], \
279 |                                                   keep_dims=True)
280 |             real_coeff = 1. / (batch_size + 1.)
281 |             ref_coeff = 1. - real_coeff
282 |             new_mean = real_coeff * real_mean + ref_coeff * ref_mean
283 |             new_var = real_coeff * real_var + ref_coeff * ref_var
284 |             ref_output = _normalize(ref_half, ref_mean, ref_var)
285 |             real_output = _normalize(real_half, new_mean, new_var)
286 |         else:
287 |             ref_output = _normalize(ref_half, ref_mean, ref_var)
288 |             real_output = _normalize(real_half, ref_mean, ref_var)
289 |         return ref_output, real_output
290 | 
291 | 
292 | @add_arg_scope
293 | def vbn_single(x, center=True, scale=True, \
294 |                epsilon=1e-5, data_format='NCHW', \
295 |                instance_norm=True, scope=None, \
296 |                reuse=None):
297 |     assert isinstance(epsilon, float)
298 |     shape = x.get_shape().as_list()
299 |     if shape[0] is None:
300 |         half_size = x.shape[0] // 2
301 |     else:
302 |         half_size = shape[0] // 2
303 |     needs_reshape = len(shape) != 4
304 |     if needs_reshape:
305 |         orig_shape = shape
306 |         if len(shape) == 2:
307 |             if data_format == 'NCHW':
308 |                 x = tf.reshape(x, [shape[0], shape[1], 0, 0])
309 |             else:
310 |                 x = tf.reshape(x, [shape[0], 1, 1, shape[1]])
311 |         elif len(shape) == 1:
312 |             x = tf.reshape(x, [shape[0], 1, 1, 1])
313 |         else:
314 |             assert False, shape
315 |         shape = x.get_shape().as_list()
316 |     batch_size = int(x.get_shape()[0])
317 |     with tf.variable_scope(scope, 'VBN', reuse=reuse):
318 |         ref_half = tf.slice(x, [0,0,0,0], [half_size, shape[1], \
319 |                             shape[2], shape[3]])
320 |         if data_format == 'NCHW':
321 |             if scale:
322 |                 gamma = tf.get_variable("gamma", [1,shape[1],1,1],
323 |                             initializer=tf.constant_initializer(1.))
324 |             if center:
325 |                 beta = tf.get_variable("beta", [1,shape[1],1,1],
326 |                             initializer=tf.constant_initializer(0.))
327 |             ref_mean, ref_var = tf.nn.moments(ref_half, [0,2,3], \
328 |                                               keep_dims=True)
329 |         else:
330 |             if scale:
331 |                 gamma = tf.get_variable("gamma", [1,1,1,shape[-1]],
332 |                             initializer=tf.constant_initializer(1.))
333 |             if center:
334 |                 beta = tf.get_variable("beta", [1,1,1,shape[-1]],
335 |                             initializer=tf.constant_initializer(0.))
336 |             ref_mean, ref_var = tf.nn.moments(ref_half, [0,1,2], \
337 |                                               keep_dims=True)
338 |         def _normalize(x, mean, var):
339 |             inv_std = tf.rsqrt(var + epsilon)
340 |             if scale:
341 |                 coeff = inv_std * gamma
342 |             else:
343 |                 coeff = inv_std
344 |             if center:
345 |                 return (x * coeff) + (beta - mean * coeff)
346 |             else:
347 |                 return (x - mean) * coeff
348 |         if instance_norm:
349 |             real_half = tf.slice(x, [half_size,0,0,0], \
350 |                                  [half_size, shape[1], shape[2], shape[3]])
351 |             if data_format == 'NCHW':
352 |                 real_mean, real_var = tf.nn.moments(real_half, [2,3], \
353 |                                                   keep_dims=True)
354 |             else:
355 |                 real_mean, real_var = tf.nn.moments(real_half, [1,2], \
356 |                                                   keep_dims=True)
357 |             real_coeff = 1. / (batch_size + 1.)
358 |             ref_coeff = 1. - real_coeff
359 |             new_mean = real_coeff * real_mean + ref_coeff * ref_mean
360 |             new_var = real_coeff * real_var + ref_coeff * ref_var
361 |             ref_output = _normalize(ref_half, ref_mean, ref_var)
362 |             real_output = _normalize(real_half, new_mean, new_var)
363 |             return tf.concat([ref_output, real_output], axis=0)
364 |         else:
365 |             return _normalize(x, ref_mean, ref_var)
366 | """
367 | 


--------------------------------------------------------------------------------
/Implement/main.py:
--------------------------------------------------------------------------------
  1 | import argparse
  2 | import numpy as np
  3 | import tensorflow as tf
  4 | from glob import glob
  5 | from preprocessing import *
  6 | from generator import *
  7 | from utils import *
  8 | from YeNet import YeNet
  9 | 
 10 | # *定义命令行输入变量
 11 | parser = argparse.ArgumentParser(description='Tensorflow implementation of YeNet')
 12 | 
 13 | # *根据不同操作进行不同的命令行参数定义
 14 | operation_set = ['train', 'test', 'datatransfer', 'dataaug', 'datasplit']
 15 | print('Operation set ', operation_set)
 16 | input_operation = input('The operation you want to perform: ')
 17 | if 'train' in input_operation:
 18 |     parser.add_argument('train_cover_dir', type=str, metavar='PATH',
 19 |                         help='directory of training cover images')
 20 |     parser.add_argument('train_stego_dir', type=str, metavar='PATH',
 21 |                         help='directory of training stego images')
 22 |     parser.add_argument('valid_cover_dir', type=str, metavar='PATH',
 23 |                         help='directory of validation cover images')
 24 |     parser.add_argument('valid_stego_dir', type=str, metavar='PATH',
 25 |                         help='directory of validation stego images')
 26 | if 'test' in input_operation:
 27 |     parser.add_argument('test_cover_dir', type=str, metavar='PATH',
 28 |                         help='directory of testing cover images')
 29 |     parser.add_argument('test_stego_dir', type=str, metavar='PATH',
 30 |                         help='directory of testing stego images')
 31 | if 'datatransfer' in input_operation:
 32 |     parser.add_argument('source_dir', type=str, metavar='PATH',
 33 |                         help='directory of source images')
 34 |     parser.add_argument('dest_dir', type=str, metavar='PATH',
 35 |                         help='directory of destination images')
 36 |     parser.add_argument('--required-size', type=int, default=256, metavar='N',
 37 |                         help='required size of destination images (default: 256)')
 38 |     parser.add_argument('--required-operation', type=str, default='resize,crop,subsample', metavar='S',
 39 |                         help='transfer operation for source image (default: resize,crop,subsample)')
 40 | if 'dataaug' in input_operation:
 41 |     parser.add_argument('source_dir', type=str, metavar='PATH',
 42 |                         help='directory of source images')
 43 |     parser.add_argument('dest_dir', type=str, metavar='PATH',
 44 |                         help='directory of destination images')
 45 |     parser.add_argument('--ratio-rot', type=float, default=0.5, metavar='F',
 46 |                         help='percentage of dataset augmented by rotation (default: 0.5)')
 47 | if 'datasplit' in input_operation:
 48 |     parser.add_argument('source_dir', type=str, metavar='PATH',
 49 |                         help='directory of source cover and stego images')
 50 |     parser.add_argument('dest_dir', type=str, metavar='PATH',
 51 |                         help='directory of separated dataset')
 52 |     parser.add_argument('--train-percent', type=float, default=0.6, metavar='F',
 53 |                         help='percentage of dataset used for training (default: 0.6)')
 54 |     parser.add_argument('--valid-percent', type=float, default=0.2, metavar='F',
 55 |                         help='percentage of dataset used for validation (default: 0.2)')
 56 |     parser.add_argument('--test-percent', type=float, default=0.2, metavar='F',
 57 |                         help='percentage of dataset used for testing (default: 0.2)')
 58 | 
 59 | if input_operation not in operation_set:
 60 |     raise NotImplementedError('invalid operation')
 61 | 
 62 | # *定义余下可选命令行参数
 63 | parser.add_argument('--use-shuf-pair', action='store_true', default=False,
 64 |                     help='matching cover and stego image when batch is constructed (default: False)')
 65 | parser.add_argument('--use-batch-norm', action='store_true', default=False,
 66 |                     help='use batch normalization after each activation (default: False)')
 67 | parser.add_argument('--batch-size', type=int, default=32, metavar='N',
 68 |                     help='input batch size for training, testing and validation (default: 32)')
 69 | parser.add_argument('--max-epochs', type=int, default=200, metavar='N',
 70 |                     help='number of epochs to train (default: 200)')
 71 | parser.add_argument('--lr', type=float, default=4e-1, metavar='F',
 72 |                     help='learning rate (default: 4e-1)')
 73 | parser.add_argument('--gpu', type=str, default='0', metavar='S',
 74 |                     help='index of gpu used (default: 0)')
 75 | parser.add_argument('--tfseed', type=int, default=1, metavar='S',
 76 |                     help='random seed (default: 1)')
 77 | parser.add_argument('--log-interval', type=int, default=20, metavar='N',
 78 |                     help='number of batches before logging training status')
 79 | parser.add_argument('--log-path', type=str, default='logs/',
 80 |                     metavar='PATH', help='directory of log file')
 81 | 
 82 | args = parser.parse_args()
 83 | 
 84 | import os
 85 | os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID'
 86 | os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu
 87 | 
 88 | # *设置tf随机种子
 89 | tf.set_random_seed(args.tfseed)
 90 | 
 91 | # *根据不同操作输入执行相应函数
 92 | if 'datatransfer' in input_operation:
 93 |     # *数据集预处理主函数
 94 |     data_transfer(args.source_dir, args.dest_dir,
 95 |                   required_size=args.required_size,
 96 |                   required_operation=args.required_operation)
 97 | 
 98 | if 'dataaug' in input_operation:
 99 |     # *数据集增广主函数
100 |     data_aug(args.source_dir, args.dest_dir, args.ratio_rot)
101 | 
102 | if 'datasplit' in input_operation:
103 |     # *数据集分割主函数
104 |     data_split(args.source_dir, args.dest_dir,
105 |                args.batch_size,
106 |                train_percent=args.train_percent,
107 |                valid_percent=args.valid_percent,
108 |                test_percent=args.test_percent)
109 | 
110 | if 'train' in input_operation:
111 |     # *计算train/valid数据集大小
112 |     train_ds_size = len(glob(args.train_cover_dir + '/*')) * 2
113 |     if train_ds_size % args.batch_size != 0:
114 |         raise ValueError('change batch size for training')
115 |     valid_ds_size = len(glob(args.valid_cover_dir + '/*')) * 2
116 |     if valid_ds_size % args.batch_size != 0:
117 |         raise ValueError('change batch size for validation')
118 |     # *训练主函数
119 |     train(YeNet, args.use_batch_norm, args.use_shuf_pair,
120 |           args.train_cover_dir, args.train_stego_dir,
121 |           args.valid_cover_dir, args.valid_stego_dir,
122 |           args.batch_size, train_ds_size, valid_ds_size,
123 |           args.log_interval, args.max_epochs, args.lr,
124 |           args.log_path)
125 | 
126 | if 'test' in input_operation:
127 |     # *计算test数据集大小
128 |     test_ds_size = len(glob(args.test_cover_dir + '/*')) * 2
129 |     if test_ds_size % args.batch_size != 0:
130 |         raise ValueError('change batch size for testing')
131 |     # *查找最佳模型主函数
132 |     test_dataset_findbest(YeNet, args.use_shuf_pair,
133 |                           args.test_cover_dir, args.test_stego_dir, args.max_epochs,
134 |                           args.batch_size, test_ds_size, args.log_path)
135 | 
136 | 
137 | 


--------------------------------------------------------------------------------
/Implement/preprocessing.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | import numpy as np
  3 | from scipy import misc
  4 | from glob import glob
  5 | import shutil
  6 | import random
  7 | from random import random as rand
  8 | from random import shuffle
  9 | 
 10 | # *数据集预处理主函数
 11 | def data_transfer(source_dir, dest_dir,
 12 |                   required_size,
 13 |                   required_operation):
 14 |     """
 15 |     将source_dir中的图像依operation中定义的操作扩展至dest_dir中
 16 |     包含resize，subsample和crop操作
 17 |     """
 18 |     dest_dir = dest_dir + '/' + source_dir.split("/")[-1]
 19 | 
 20 |     # 建立数据集路径
 21 |     size = required_size, required_size
 22 |     if 'resize' in required_operation:
 23 |         dest_resize_dir = dest_dir + '_' + str(required_size) + '_resize'
 24 |         if os.path.exists(dest_resize_dir + '/') is False:
 25 |             os.mkdir(dest_resize_dir + '/')
 26 |         os.mkdir(dest_resize_dir + '/cover/')
 27 |     if 'crop' in required_operation:
 28 |         dest_crop_dir = dest_dir + '_' + str(required_size) + '_crop'
 29 |         if os.path.exists(dest_crop_dir + '/') is False:
 30 |             os.mkdir(dest_crop_dir + '/')
 31 |         os.mkdir(dest_crop_dir + '/cover/')
 32 |     if 'subsample' in required_operation:
 33 |         dest_subsample_dir = dest_dir + '_' + str(required_size) + '_subsample'
 34 |         if os.path.exists(dest_subsample_dir + '/') is False:
 35 |             os.mkdir(dest_subsample_dir + '/')
 36 |         os.mkdir(dest_subsample_dir + '/cover/')
 37 | 
 38 |     source_img_list = glob(source_dir + '/*')
 39 |     for filename in source_img_list:
 40 |         img = misc.imread(filename)
 41 |         if img is None:
 42 |             raise OSError('Error: could not load image')
 43 |         if 'resize' in required_operation:
 44 |             img_resize = misc.imresize(img, size, interp='bicubic')
 45 |             save_dir = dest_resize_dir + '/cover/' + filename.split("/")[-1]
 46 |             misc.imsave(save_dir, img_resize)
 47 |         if 'crop' in required_operation:
 48 |             ROI_idx = (img.shape[0] - required_size) // 2
 49 |             img_crop = img[ROI_idx:ROI_idx+required_size, ROI_idx:ROI_idx+required_size]
 50 |             save_dir = dest_crop_dir + '/cover/' + filename.split("/")[-1]
 51 |             misc.imsave(save_dir, img_crop)
 52 |         if 'subsample' in required_operation:
 53 |             SUB_idx = img.shape[0] // required_size
 54 |             img_subsample = img[0:img.shape[0]:SUB_idx, 0:img.shape[1]:SUB_idx]
 55 |             save_dir = dest_subsample_dir + '/cover/' + filename.split("/")[-1]
 56 |             misc.imsave(save_dir, img_subsample)
 57 |     print('data transfer succeed!')
 58 | 
 59 | # *数据集增广主函数
 60 | def data_aug(source_dir, dest_dir, ratio=0.5):
 61 |     """
 62 |     将source_dir中的图像增广至dest_dir中
 63 |     包含rotate和flip操作
 64 |     """
 65 |     dest_dir = dest_dir + '/' + source_dir.split("/")[-2] + '_aug'
 66 |     if os.path.exists(dest_dir + '/') is False:
 67 |         os.mkdir(dest_dir + '/')
 68 |     os.mkdir(dest_dir + '/cover/')
 69 | 
 70 |     dest_dir = dest_dir + '/cover'
 71 | 
 72 |     source_img_list = glob(source_dir + '/*')
 73 |     for filename in source_img_list:
 74 |         img = misc.imread(filename)
 75 |         if img is None:
 76 |             raise OSError('Error: could not load image')
 77 |         filename_split = (filename.split("/")[-1])
 78 |         save_dir = dest_dir + '/' + filename_split
 79 |         misc.imsave(save_dir, img)
 80 | 
 81 |         rot = random.randint(1, 3)
 82 |         rand_op = rand()
 83 |         rand_flip = rand()
 84 |         if rand_op < ratio:
 85 |             img_rot = misc.imrotate(img, rot*90, interp='bicubic')
 86 |             save_dir = dest_dir + '/' + filename_split.split('.')[0] + '_rot.' + filename_split.split('.')[1]
 87 |             misc.imsave(save_dir, img_rot)
 88 |         else:
 89 |             if rand_flip < ratio:
 90 |                 img_flip = np.flipud(img)
 91 |             else:
 92 |                 img_flip = np.fliplr(img)
 93 |             save_dir = dest_dir + '/' + filename_split.split('.')[0] + '_flip.' + filename_split.split('.')[1]
 94 |             misc.imsave(save_dir, img_flip)
 95 |     print('data augment succeed!')
 96 | 
 97 | 
 98 | # *数据集分割主函数
 99 | def data_split(source_dir, dest_dir,
100 |                batch_size,
101 |                train_percent=0.6,
102 |                valid_percent=0.2,
103 |                test_percent=0.2):
104 |     """
105 |     根据传入的source_dir中cover/stego图像路径，根据各percent参数
106 |     在dest_dir路径中分割成train/valid/test数据集
107 |     抽取方式是随机的
108 |     """
109 |     # *判断输入百分比是否合法
110 |     if (train_percent + valid_percent + test_percent) > 1:
111 |         raise ValueError('sum of train valid test percentage larger than 1')
112 | 
113 |     if os.path.exists(dest_dir + '/') is False:
114 |         os.mkdir(dest_dir + '/')
115 |     if os.path.exists(source_dir + '/') is False:
116 |         raise OSError('source direction not exist')
117 | 
118 |     source_cover_dir = source_dir + '/cover'
119 |     source_stego_dir = source_dir + '/stego'
120 | 
121 |     # *清理非对应文件
122 |     file_clean(source_cover_dir, source_stego_dir)
123 | 
124 |     # *在dest_dir路径下创建train/valid/test路径
125 |     dest_train_dir, dest_valid_dir, dest_test_dir = file_dir_mk_trainvalidtest_dir(dest_dir)
126 | 
127 |     # *对source_dir中的文件顺序进行shuffle
128 |     source_cover_list = []
129 |     for filename in os.listdir(source_cover_dir + '/'):
130 |         source_cover_list.append(filename)
131 |     shuffle(source_cover_list)
132 | 
133 |     # *计算train/valid/test数据集容量
134 |     half_batch_size = batch_size // 2
135 |     train_ds_capacity = ( int( len(source_cover_list)*train_percent ) // half_batch_size ) * half_batch_size
136 |     valid_ds_capacity = ( int( len(source_cover_list)*valid_percent ) // half_batch_size ) * half_batch_size
137 |     test_ds_capacity  = ( int( len(source_cover_list)*test_percent  ) // half_batch_size ) * half_batch_size
138 | 
139 |     for fileidx in range(train_ds_capacity):
140 |         srcfile_cover = source_cover_dir + '/' + source_cover_list[fileidx]
141 |         dstfile_cover = dest_train_dir + '/cover/' + source_cover_list[fileidx]
142 |         shutil.copyfile(srcfile_cover, dstfile_cover)
143 |         srcfile_stego = source_stego_dir + '/' + source_cover_list[fileidx]
144 |         dstfile_stego = dest_train_dir + '/stego/' + source_cover_list[fileidx]
145 |         shutil.copyfile(srcfile_stego, dstfile_stego)
146 |     for fileidx in range(train_ds_capacity, train_ds_capacity + valid_ds_capacity):
147 |         srcfile_cover = source_cover_dir + '/' + source_cover_list[fileidx]
148 |         dstfile_cover = dest_valid_dir + '/cover/' + source_cover_list[fileidx]
149 |         shutil.copyfile(srcfile_cover, dstfile_cover)
150 |         srcfile_stego = source_stego_dir + '/' + source_cover_list[fileidx]
151 |         dstfile_stego = dest_valid_dir + '/stego/' + source_cover_list[fileidx]
152 |         shutil.copyfile(srcfile_stego, dstfile_stego)
153 |     for fileidx in range(train_ds_capacity + valid_ds_capacity,
154 |                           train_ds_capacity + valid_ds_capacity + test_ds_capacity):
155 |         srcfile_cover = source_cover_dir + '/' + source_cover_list[fileidx]
156 |         dstfile_cover = dest_test_dir + '/cover/' + source_cover_list[fileidx]
157 |         shutil.copyfile(srcfile_cover, dstfile_cover)
158 |         srcfile_stego = source_stego_dir + '/' + source_cover_list[fileidx]
159 |         dstfile_stego = dest_test_dir + '/stego/' + source_cover_list[fileidx]
160 |         shutil.copyfile(srcfile_stego, dstfile_stego)
161 |     print('data split succeed!')
162 | 
163 | def file_clean(cover_dir, stego_dir):
164 |     """
165 |     对cover和stego里的文件进行清理，将只存在于单个文件夹的文件、后缀名不匹配的文件删除。
166 |     """
167 |     cover_dir = cover_dir + '/'
168 |     stego_dir = stego_dir + '/'
169 |     cover_list = []
170 |     stego_list = []
171 |     for root, dirs, files in os.walk(cover_dir):
172 |         for filenames in files:
173 |             cover_list.append(filenames)
174 |     for root, dirs, files in os.walk(stego_dir):
175 |         for filenames in files:
176 |             stego_list.append(filenames)
177 |     diff_cover_list = set(cover_list).difference(set(stego_list))
178 |     diff_stego_list = set(stego_list).difference(set(cover_list))
179 |     print('Start file cleaning...')
180 |     print('About to delete: ', len(diff_cover_list), 'files in ', cover_dir)
181 |     for filenames in diff_cover_list:
182 |         os.remove(cover_dir + filenames)
183 |     print('About to delete: ', len(diff_stego_list), 'files in ', stego_dir)
184 |     for filenames in diff_stego_list:
185 |         os.remove(stego_dir + filenames)
186 | 
187 | def file_dir_mk_trainvalidtest_dir(dest_dir):
188 |     """
189 |     在dest_dir路径下创建train/valid/test路径
190 |     """
191 |     if os.path.exists(dest_dir + '/train/') is False:
192 |         os.mkdir(dest_dir + '/train/')
193 |     if os.path.exists(dest_dir + '/train/cover/') is False:
194 |         os.mkdir(dest_dir + '/train/cover/')
195 |     if os.path.exists(dest_dir + '/train/stego/') is False:
196 |         os.mkdir(dest_dir + '/train/stego/')
197 |     if os.path.exists(dest_dir + '/valid/') is False:
198 |         os.mkdir(dest_dir + '/valid/')
199 |     if os.path.exists(dest_dir + '/valid/cover/') is False:
200 |         os.mkdir(dest_dir + '/valid/cover/')
201 |     if os.path.exists(dest_dir + '/valid/stego/') is False:
202 |         os.mkdir(dest_dir + '/valid/stego/')
203 |     if os.path.exists(dest_dir + '/test/') is False:
204 |         os.mkdir(dest_dir + '/test/')
205 |     if os.path.exists(dest_dir + '/test/cover/') is False:
206 |         os.mkdir(dest_dir + '/test/cover/')
207 |     if os.path.exists(dest_dir + '/test/stego/') is False:
208 |         os.mkdir(dest_dir + '/test/stego/')
209 |     if os.path.exists(dest_dir + '/log/') is False:
210 |         os.mkdir(dest_dir + '/log/')
211 |     return dest_dir + '/train', dest_dir + '/valid', dest_dir + '/test'
212 | 


--------------------------------------------------------------------------------
/Implement/testfiles/command.sh:
--------------------------------------------------------------------------------
1 | #train
2 | #python /home/carlchang/YeNetTensorflow/Implement/main.py /home/carlchang/YeNetTensorflow/Experiment/TryCaenorstStructure/train/cover /home/carlchang/YeNetTensorflow/Experiment/TryCaenorstStructure/train/stego /home/carlchang/YeNetTensorflow/Experiment/TryCaenorstStructure/valid/cover /home/carlchang/YeNetTensorflow/Experiment/TryCaenorstStructure/valid/stego --log-path="/home/carlchang/YeNetTensorflow/Experiment/TryCaenorstStructure/log" --use-batch-norm --lr 4e-1 --max-epochs=300 --log-interval=24 --gpu="0,1,2,3"
3 | 
4 | #test
5 | #python /home/carlchang/YeNetTensorflow/Implement/main.py /home/carlchang/YeNetTensorflow/Experiment/TryCaenorstStructure/test/cover /home/carlchang/YeNetTensorflow/Experiment/TryCaenorstStructure/test/stego --log-path="/home/carlchang/YeNetTensorflow/Experiment/TryCaenorstStructure/log" --gpu="0,1,2,3"
6 | 
7 | #data_split
8 | python /home/carlchang/YeNetTensorflow/Implement/main.py /home/carlchang/YeNetTensorflow/Data/SUNI_0.4_15000 /home/carlchang/YeNetTensorflow/Experiment/SUNI_0.4_15000_No_2 --train-percent=0.6 --valid-percent=0.2 --test-percent=0.2 --gpu=" "
9 | 


--------------------------------------------------------------------------------
/Implement/testfiles/test_data_split.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | import shutil
  3 | from random import shuffle
  4 | 
  5 | # *数据集分割主函数
  6 | def data_split(source_dir, dest_dir,
  7 |                batch_size,
  8 |                train_percent=0.6,
  9 |                valid_percent=0.2,
 10 |                test_percent=0.2):
 11 |     """
 12 |     根据传入的source_dir中cover/stego图像路径，根据各percent参数
 13 |     在dest_dir路径中分割成train/valid/test数据集
 14 |     抽取方式是随机的
 15 |     """
 16 |     # *判断输入百分比是否合法
 17 |     if (train_percent + valid_percent + test_percent) > 1:
 18 |         raise ValueError('sum of train valid test percentage larger than 1')
 19 | 
 20 |     if os.path.exists(dest_dir + '/') is False:
 21 |         os.mkdir(dest_dir + '/')
 22 |     if os.path.exists(source_dir + '/') is False:
 23 |         raise OSError('source direction not exist')
 24 | 
 25 |     source_cover_dir = source_dir + '/cover'
 26 |     source_stego_dir = source_dir + '/stego'
 27 | 
 28 |     # *清理非对应文件
 29 |     file_clean(source_cover_dir, source_stego_dir)
 30 | 
 31 |     # *在dest_dir路径下创建train/valid/test路径
 32 |     dest_train_dir, dest_valid_dir, dest_test_dir = file_dir_mk_trainvalidtest_dir(dest_dir)
 33 | 
 34 |     # *对source_dir中的文件顺序进行shuffle
 35 |     source_cover_list = []
 36 |     for filename in os.listdir(source_cover_dir + '/'):
 37 |         source_cover_list.append(filename)
 38 |     shuffle(source_cover_list)
 39 | 
 40 |     # *计算train/valid/test数据集容量
 41 |     half_batch_size = batch_size // 2
 42 |     train_ds_capacity = ( int( len(source_cover_list)*train_percent ) // half_batch_size ) * half_batch_size
 43 |     valid_ds_capacity = ( int( len(source_cover_list)*valid_percent ) // half_batch_size ) * half_batch_size
 44 |     test_ds_capacity  = ( int( len(source_cover_list)*test_percent  ) // half_batch_size ) * half_batch_size
 45 | 
 46 |     for fileidx in range(train_ds_capacity):
 47 |         srcfile_cover = source_cover_dir + '/' + source_cover_list[fileidx]
 48 |         dstfile_cover = dest_train_dir + '/cover/' + source_cover_list[fileidx]
 49 |         shutil.copyfile(srcfile_cover, dstfile_cover)
 50 |         srcfile_stego = source_stego_dir + '/' + source_cover_list[fileidx]
 51 |         dstfile_stego = dest_train_dir + '/stego/' + source_cover_list[fileidx]
 52 |         shutil.copyfile(srcfile_stego, dstfile_stego)
 53 |     for fileidx in range(train_ds_capacity, train_ds_capacity + valid_ds_capacity):
 54 |         srcfile_cover = source_cover_dir + '/' + source_cover_list[fileidx]
 55 |         dstfile_cover = dest_valid_dir + '/cover/' + source_cover_list[fileidx]
 56 |         shutil.copyfile(srcfile_cover, dstfile_cover)
 57 |         srcfile_stego = source_stego_dir + '/' + source_cover_list[fileidx]
 58 |         dstfile_stego = dest_valid_dir + '/stego/' + source_cover_list[fileidx]
 59 |         shutil.copyfile(srcfile_stego, dstfile_stego)
 60 |     for fileidx in range(train_ds_capacity + valid_ds_capacity,
 61 |                           train_ds_capacity + valid_ds_capacity + test_ds_capacity):
 62 |         srcfile_cover = source_cover_dir + '/' + source_cover_list[fileidx]
 63 |         dstfile_cover = dest_test_dir + '/cover/' + source_cover_list[fileidx]
 64 |         shutil.copyfile(srcfile_cover, dstfile_cover)
 65 |         srcfile_stego = source_stego_dir + '/' + source_cover_list[fileidx]
 66 |         dstfile_stego = dest_test_dir + '/stego/' + source_cover_list[fileidx]
 67 |         shutil.copyfile(srcfile_stego, dstfile_stego)
 68 | 
 69 | def file_dir_mk_trainvalidtest_dir(dest_dir):
 70 |     """
 71 |     在dest_dir路径下创建train/valid/test路径
 72 |     """
 73 |     if os.path.exists(dest_dir + '/train/') is False:
 74 |         os.mkdir(dest_dir + '/train/')
 75 |     if os.path.exists(dest_dir + '/train/cover/') is False:
 76 |         os.mkdir(dest_dir + '/train/cover/')
 77 |     if os.path.exists(dest_dir + '/train/stego/') is False:
 78 |         os.mkdir(dest_dir + '/train/stego/')
 79 |     if os.path.exists(dest_dir + '/valid/') is False:
 80 |         os.mkdir(dest_dir + '/valid/')
 81 |     if os.path.exists(dest_dir + '/valid/cover/') is False:
 82 |         os.mkdir(dest_dir + '/valid/cover/')
 83 |     if os.path.exists(dest_dir + '/valid/stego/') is False:
 84 |         os.mkdir(dest_dir + '/valid/stego/')
 85 |     if os.path.exists(dest_dir + '/test/') is False:
 86 |         os.mkdir(dest_dir + '/test/')
 87 |     if os.path.exists(dest_dir + '/test/cover/') is False:
 88 |         os.mkdir(dest_dir + '/test/cover/')
 89 |     if os.path.exists(dest_dir + '/test/stego/') is False:
 90 |         os.mkdir(dest_dir + '/test/stego/')
 91 |     if os.path.exists(dest_dir + '/log/') is False:
 92 |         os.mkdir(dest_dir + '/log/')
 93 |     return dest_dir + '/train', dest_dir + '/valid', dest_dir + '/test'
 94 | 
 95 | def file_clean(cover_dir, stego_dir):
 96 |     """
 97 |     对cover和stego里的文件进行清理，将只存在于单个文件夹的文件、后缀名不匹配的文件删除。
 98 |     """
 99 |     cover_dir = cover_dir + '/'
100 |     stego_dir = stego_dir + '/'
101 |     cover_list = []
102 |     stego_list = []
103 |     for root, dirs, files in os.walk(cover_dir):
104 |         for filenames in files:
105 |             cover_list.append(filenames)
106 |     for root, dirs, files in os.walk(stego_dir):
107 |         for filenames in files:
108 |             stego_list.append(filenames)
109 |     diff_cover_list = set(cover_list).difference(set(stego_list))
110 |     diff_stego_list = set(stego_list).difference(set(cover_list))
111 |     print('About to delete: ', len(diff_cover_list), 'files in ', cover_dir, 'Continue?')
112 |     os.system('pause')
113 |     for filenames in diff_cover_list:
114 |         os.remove(cover_dir + filenames)
115 |     print('About to delete: ', len(diff_stego_list), 'files in ', stego_dir, 'Continue?')
116 |     os.system('pause')
117 |     for filenames in diff_stego_list:
118 |         os.remove(stego_dir + filenames)
119 |     print('file_clean process has completed.')
120 | 
121 | if __name__ == '__main__':
122 |     source_dir = 'E:\@ChangShihyoung\TensorFlow-YeNet\Data\SUNI_13_0.4'
123 |     dest_dir = 'E:\@ChangShihyoung\TensorFlow-YeNet\Experiment\SUNI_13_0.4_No_1'
124 |     data_split(source_dir, dest_dir,
125 |                4,
126 |                train_percent=0.6,
127 |                valid_percent=0.2,
128 |                test_percent=0.2)


--------------------------------------------------------------------------------
/Implement/testfiles/utils_test.py:
--------------------------------------------------------------------------------
  1 | import tensorflow as tf
  2 | import numpy as np
  3 | from scipy import misc, io
  4 | import time
  5 | from glob import glob
  6 | from generator import *
  7 | 
  8 | # *包含loss与acc变量及操作的average_summary类
  9 | class average_summary(object):
 10 |     def __init__(self, variable, name, num_iterations):
 11 |         # sum_variable：内在累加器，用于累加每次的loss/acc
 12 |         self.sum_variable = tf.get_variable(name, shape=[],
 13 |                                             initializer=tf.constant_initializer(0.),
 14 |                                             dtype='float32',
 15 |                                             trainable=False,
 16 |                                             collections=[tf.GraphKeys.LOCAL_VARIABLES])
 17 |         # 每个batch调用一次increment_op，累加每次的loss/acc
 18 |         with tf.control_dependencies([variable]):
 19 |             self.increment_op = tf.assign_add(self.sum_variable, variable)
 20 |         # 当increment_op操作调用了num_iterations次之后，可进行下列操作
 21 |         self.mean_variable = self.sum_variable / float(num_iterations)  # 求平均的loss和acc
 22 |         self.summary = tf.summary.scalar(name, self.mean_variable)  # 将loss和acc存入tf全局图
 23 |         with tf.control_dependencies([self.summary]):
 24 |             self.reset_variable_op = tf.assign(self.sum_variable, 0)  # 当summary完成后，可进行reset
 25 |     # 外部调用，将loss/acc存入tf全局图
 26 |     def add_summary(self, sess, writer, step):
 27 |         s, _ = sess.run([self.summary, self.reset_variable_op])
 28 |         writer.add_summary(s, step)
 29 | 
 30 | # *用于挂载Net的结构，包含__build_model和__build_loss的操作
 31 | class Model(object):
 32 |     def __init__(self, is_training=None, data_format='NCHW'):
 33 |         self.data_format = data_format
 34 |         if is_training is None:
 35 |             self.is_training = tf.get_variable('is_training', dtype=tf.bool,
 36 |                                                initializer=tf.constant_initializer(True),
 37 |                                                trainable=False)
 38 |         else:
 39 |             self.is_training = is_training
 40 | 
 41 |     def _build_model(self, inputs):
 42 |         raise NotImplementedError('Here is your model definition')
 43 | 
 44 |     def _build_losses(self, labels):
 45 |         self.labels = tf.cast(labels, tf.int64)
 46 |         with tf.variable_scope('loss'):
 47 |             oh = tf.one_hot(self.labels, 2)  # 这里定义了2分类的输出
 48 |             # *除softmax cross entropy之外，还可更换其他函数
 49 |             self.loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(
 50 |                                        labels=oh, logits=self.outputs))
 51 |         with tf.variable_scope('accuracy'):
 52 |             am = tf.argmax(self.outputs, 1)
 53 |             equal = tf.equal(am, self.labels)
 54 |             self.accuracy = tf.reduce_mean(tf.cast(equal, tf.float32))
 55 |         return self.loss, self.accuracy
 56 | 
 57 | # *训练主函数
 58 | def train(model_class, use_batch_norm, use_shuf_pair,
 59 |           train_cover_dir, train_stego_dir,
 60 |           valid_cover_dir, valid_stego_dir,
 61 |           batch_size, train_ds_size, valid_ds_size,
 62 |           log_interval, max_epochs, lr,
 63 |           log_path, load_path=None):
 64 |     # *清除默认图的堆栈，设置全局图为默认图
 65 |     tf.reset_default_graph()
 66 | 
 67 |     # *is_training用于判断训练处于train或者valid状态
 68 |     is_training = tf.get_variable('is_training', dtype=tf.bool,
 69 |                                   initializer=True, trainable=False)
 70 | 
 71 |     # *定义train_op操作和valid_op操作，将is_training和batch_size设置为对应的状态
 72 |     disable_training_op = tf.assign(is_training, False)
 73 |     enable_training_op = tf.assign(is_training, True)
 74 | 
 75 |     # *模型初始化
 76 |     # 设置占位符
 77 |     temp_cover_list = glob(train_cover_dir + '/*')
 78 |     temp_img = misc.imread(temp_cover_list[0])
 79 |     temp_img_shape = temp_img.shape
 80 |     img_batch = tf.placeholder(tf.float32,
 81 |                                [batch_size, temp_img_shape[0], temp_img_shape[1], 1],
 82 |                                name='input_image_batch')
 83 |     label_batch = tf.placeholder(tf.int32, [batch_size, ], name="input_label_batch")
 84 |     # 使用占位符初始化模型
 85 |     model = model_class(is_training, 'NCHW', with_bn=use_batch_norm, tlu_threshold=3)
 86 |     model._build_model(img_batch)
 87 |     loss, accuracy = model._build_losses(label_batch)
 88 | 
 89 |     # *设置需要最小化的loss函数
 90 |     regularization_losses = tf.get_collection(
 91 |                           tf.GraphKeys.REGULARIZATION_LOSSES)
 92 |     regularized_loss = tf.add_n([loss] + regularization_losses)
 93 |     # 定义train中使用的基于loss/acc的类（运行次数：log_interval）
 94 |     train_loss_s = average_summary(loss, 'train_loss', log_interval)
 95 |     train_accuracy_s = average_summary(accuracy, 'train_accuracy', log_interval)
 96 |     # 定义valid中使用的基于loss/acc的类（运行次数：valid_ds_size / valid_batch_size）
 97 |     valid_loss_s = average_summary(loss, 'valid_loss',
 98 |                                    float(valid_ds_size) / float(batch_size))
 99 |     valid_accuracy_s = average_summary(accuracy, 'valid_accuracy',
100 |                                        float(valid_ds_size) / float(batch_size))
101 | 
102 |     # *全局变量global_step，从0开始进行计数
103 |     global_step = tf.Variable(0, trainable=False)
104 |     # *定义核心optimizer
105 |     # 定义learning_rate的decay操作
106 |     init_learning_rate = lr
107 |     decay_steps, decay_rate = 2000, 0.95
108 |     learning_rate = learning_rate_decay(init_learning_rate=init_learning_rate,
109 |                                         decay_method="exponential",
110 |                                         global_step=global_step,
111 |                                         decay_steps=decay_steps,
112 |                                         decay_rate=decay_rate)
113 |     optimizer = tf.train.AdadeltaOptimizer(learning_rate)
114 | 
115 |     # *定义train及valid过程中需要用到的操作
116 |     # 核心操作：最小化loss
117 |     minimize_op = optimizer.minimize(loss=regularized_loss, global_step=global_step)
118 |     # 训练操作（每个iteration都要用）：最小化loss；train_loss累加；train_acc累加
119 |     train_op = tf.group(minimize_op, train_loss_s.increment_op,
120 |                         train_accuracy_s.increment_op)
121 |     # 验证操作（一个epoch结束后，每个valid中的iteration都要用）：valid_loss累加；valid_acc累加
122 |     valid_op = tf.group(valid_loss_s.increment_op,
123 |                         valid_accuracy_s.increment_op)
124 |     # 初始化操作：初始化所有的全局变量和局部变量
125 |     init_op = tf.group(tf.global_variables_initializer(),
126 |                        tf.local_variables_initializer())
127 | 
128 |     # *定义模型保存变量，最大存储max_to_keep个模型
129 |     saver = tf.train.Saver(max_to_keep=max_epochs+20)
130 |     global_valid_accuracy = 0  # 全局valid_acc最大值
131 | 
132 |     # *会话开始
133 |     with tf.Session() as sess:
134 |         # 初始化所有的全局变量和局部变量
135 |         sess.run(init_op)
136 |         # 重载模型
137 |         if load_path is not None:
138 |             loader = tf.train.Saver(reshape=True)
139 |             loader.restore(sess, load_path)
140 |         # 定义模型及参数保存位置
141 |         writer = tf.summary.FileWriter(log_path + '/LogFile/', sess.graph)
142 | 
143 |         # 初始化train/valid的loss和acc变量
144 |         sess.run([valid_loss_s.reset_variable_op,
145 |                   valid_accuracy_s.reset_variable_op,
146 |                   train_loss_s.reset_variable_op,
147 |                   train_accuracy_s.reset_variable_op])
148 | 
149 |         # *训练开始：train/valid
150 |         print('Start training...')
151 |         global_train_batch = 0  # 全局batch计数
152 |         for epoch in range(max_epochs):
153 |             start_time = time.time()
154 |             train_img_list, train_label_list = get_files(train_cover_dir,
155 |                                                          train_stego_dir,
156 |                                                          use_shuf_pair=use_shuf_pair)
157 |             valid_img_list, valid_label_list = get_files(valid_cover_dir,
158 |                                                          valid_stego_dir,
159 |                                                          use_shuf_pair=use_shuf_pair)
160 | 
161 |             # *训练开始：train
162 |             sess.run(enable_training_op)  # 转换为train训练状态
163 |             local_train_batch = 0  # 局部batch计数
164 |             for train_img_minibatch_list, train_label_minibatch_list in \
165 |                     get_minibatches(train_img_list, train_label_list, batch_size):
166 |                 # minibatch数据读取
167 |                 train_img_batch = get_minibatches_content_img(train_img_minibatch_list,
168 |                                                               temp_img_shape[0],
169 |                                                               temp_img_shape[1])
170 | 
171 |                 # train操作及指标显示
172 |                 sess.run(train_op, feed_dict={img_batch: train_img_batch,
173 |                                               label_batch: train_label_minibatch_list})
174 | 
175 |                 global_train_batch += 1
176 |                 local_train_batch += 1
177 | 
178 |                 # 每log_interval个batch后，对train_loss/acc进行存储
179 |                 # 这是由于train_loss/acc的average_summary以log_interval为基准定义
180 |                 if global_train_batch % log_interval == 0:
181 |                     # 注意：loginterval决定了每20输出一次，而不是每个batch存储loss/acc一次
182 |                     # train_loss/acc显示
183 |                     local_train_loss = train_loss_s.mean_variable
184 |                     local_train_accuracy = train_accuracy_s.mean_variable
185 |                     local_train_loss_value = local_train_loss.eval(session=sess)
186 |                     local_train_accuracy_value = local_train_accuracy.eval(session=sess)
187 |                     print('-TRAIN- epoch: %d batch: %d | train_loss: %f train_acc: %f'
188 |                           % (epoch, local_train_batch, local_train_loss_value, local_train_accuracy_value))
189 |                     # train_loss/acc存储
190 |                     train_loss_s.add_summary(sess, writer, global_train_batch)
191 |                     train_accuracy_s.add_summary(sess, writer, global_train_batch)
192 | 
193 |                 # 对最后20个模型进行存储
194 |                 if ((train_ds_size // batch_size) * max_epochs - global_train_batch) < 20:
195 |                     saver.save(sess, log_path + '/Model_' + str(epoch) + '.ckpt')
196 |                     print('---EPOCH:%d LAST:%d--- model has been saved'
197 |                           % (epoch, (train_ds_size // batch_size) * max_epochs - global_train_batch + 1))
198 | 
199 |             # *训练开始：validation
200 |             sess.run(disable_training_op)
201 |             local_valid_loss, local_valid_accuracy = 0, 0  # 本epoch中valid_loss和valid_acc值
202 |             for valid_img_minibatch_list, valid_label_minibatch_list in \
203 |                     get_minibatches(valid_img_list, valid_label_list, batch_size):
204 |                 # minibatch数据读取
205 |                 valid_img_batch = get_minibatches_content_img(valid_img_minibatch_list,
206 |                                                               temp_img_shape[0],
207 |                                                               temp_img_shape[1])
208 | 
209 |                 # valid操作及指标显示
210 |                 sess.run(valid_op, feed_dict={img_batch: valid_img_batch,
211 |                                               label_batch: valid_label_minibatch_list})
212 | 
213 |             # 每个epoch中所有batch运行完后，对valid_loss/acc进行显示和存储
214 |             # 这是由于valid_loss/acc的average_summary以(valid_ds_size/batch_size)为基准定义
215 |             # valid_loss/acc显示
216 |             local_valid_loss = valid_loss_s.mean_variable
217 |             local_valid_accuracy = valid_accuracy_s.mean_variable
218 |             local_valid_loss_value = local_valid_loss.eval(session=sess)
219 |             local_valid_accuracy_value = local_valid_accuracy.eval(session=sess)
220 |             print('-VALID- epoch: %d | valid_loss: %f valid_acc: %f'
221 |                   % (epoch, local_valid_loss_value, local_valid_accuracy_value))
222 |             # valid_loss/acc存储
223 |             valid_loss_s.add_summary(sess, writer, global_train_batch)
224 |             valid_accuracy_s.add_summary(sess, writer, global_train_batch)
225 | 
226 |             # *模型保存：如果valid_acc大于全局valid_acc，则保存
227 |             if local_valid_accuracy_value > global_valid_accuracy:
228 |                 global_valid_accuracy = local_valid_accuracy_value
229 |                 saver.save(sess, log_path + '/Model_' + str(epoch) + '.ckpt')
230 |                 print('---EPOCH:%d--- model has been saved' % (epoch))
231 | 
232 |             # *本epoch中train及valid过程均完毕，记录时间
233 |             end_time = time.time()
234 |             print('--EPOCH:%d-- runtime: %.2fs ' % (epoch, end_time - start_time),
235 |                   ' learning rate: ', sess.run(learning_rate), '\n')
236 | 
237 | # *测试主函数，查找最佳模型
238 | def test_dataset_findbest(model_class, use_batch_norm, use_shuf_pair,
239 |                           test_cover_dir, test_stego_dir, max_epochs,
240 |                           batch_size, ds_size, log_path):
241 |     tf.reset_default_graph()
242 | 
243 |     # *模型初始化
244 |     # 设置占位符
245 |     temp_cover_list = glob(test_cover_dir + '/*')
246 |     temp_img = misc.imread(temp_cover_list[0])
247 |     temp_img_shape = temp_img.shape
248 |     img_batch = tf.placeholder(tf.float32,
249 |                                [batch_size, temp_img_shape[0], temp_img_shape[1], 1],
250 |                                name='input_image_batch')
251 |     label_batch = tf.placeholder(tf.int32, [batch_size, ], name="input_label_batch")
252 |     # 使用占位符初始化模型
253 |     model = model_class(is_training=False, data_format='NCHW',
254 |                         with_bn=use_batch_norm, tlu_threshold=3)
255 |     model._build_model(img_batch)
256 |     loss, accuracy = model._build_losses(label_batch)
257 | 
258 |     # *设置需要计算的loss函数，test_loss/acc与valid_loss/acc的功用类似
259 |     # 定义valid中使用的基于loss/acc的类（运行次数：valid_ds_size / valid_batch_size）
260 |     test_loss_s = average_summary(loss, 'test_loss',
261 |                                    float(ds_size) / float(batch_size))
262 |     test_accuracy_s = average_summary(accuracy, 'test_accuracy',
263 |                                        float(ds_size) / float(batch_size))
264 |     # 验证操作（一个epoch结束后，每个valid中的iteration都要用）：valid_loss累加；valid_acc累加
265 |     test_op = tf.group(test_loss_s.increment_op,
266 |                        test_accuracy_s.increment_op)
267 | 
268 |     # *全局变量global_step，从0开始进行计数
269 |     global_step = tf.Variable(0, trainable=False)
270 | 
271 |     # 初始化操作：初始化所有的全局变量和局部变量
272 |     init_op = tf.group(tf.global_variables_initializer(),
273 |                        tf.local_variables_initializer())
274 | 
275 |     # *定义模型保存变量，最大存储max_to_keep个模型
276 |     saver = tf.train.Saver(max_to_keep=max_epochs)
277 | 
278 |     # *记录每次test后得到的loss和acc
279 |     test_loss_arr = []
280 |     test_accuracy_arr = []
281 | 
282 |     # *对load_data_path_s列表中的所有模型进行test操作
283 |     print('Start testing...')
284 |     # 在log路径下搜寻所有可加载文件
285 |     load_model_path_s = sorted(glob(log_path + '/*.data*'))
286 |     for load_model_path in load_model_path_s:
287 |         start_time = time.time()
288 |         # *会话开始
289 |         with tf.Session() as sess:
290 |             # 初始化所有的全局变量和局部变量
291 |             sess.run(init_op)
292 |             # 重载模型
293 |             saver.restore(sess, load_model_path)
294 |             # 初始化test的loss和acc变量
295 |             sess.run([test_loss_s.reset_variable_op,
296 |                       test_accuracy_s.reset_variable_op])
297 |             # 加载test路径下的img及label列表
298 |             test_img_list, test_label_list = get_files(test_cover_dir,
299 |                                                        test_stego_dir,
300 |                                                        use_shuf_pair=use_shuf_pair)
301 |             # *对当前load_data_path的模型进行test操作
302 |             for test_img_minibatch_list, test_label_minibatch_list in \
303 |                     get_minibatches(test_img_list, test_label_list, batch_size):
304 |                 # minibatch数据读取
305 |                 test_img_batch = get_minibatches_content_img(test_img_minibatch_list,
306 |                                                              temp_img_shape[0],
307 |                                                              temp_img_shape[1])
308 |                 # 对每次minibatch中test后得到的loss和acc进行累加
309 |                 sess.run(test_op, feed_dict={img_batch: test_img_batch,
310 |                                              label_batch: test_label_minibatch_list})
311 |             # *记录当前load_data_path模型test操作后得到的loss和acc
312 |             test_mean_loss, test_mean_accuracy = sess.run([test_loss_s.mean_variable,
313 |                                                            test_accuracy_s.mean_variable])
314 |             test_loss_arr.append(test_mean_loss)
315 |             test_accuracy_arr.append(test_mean_accuracy)
316 |             end_time = time.time()
317 |             print(load_model_path.split("/")[-1])
318 |             print('-TEST- test_loss: %f test_acc: %f | runtime: %.2fs \n'
319 |                   % (test_loss_arr[-1], test_accuracy_arr[-1], end_time - start_time))
320 | 
321 |     # *寻找最佳test_acc对应的模型索引
322 |     load_best_model_idx = np.argmax(test_accuracy_arr)
323 |     print('-BEST TEST- best_path: ', load_model_path_s[load_best_model_idx])
324 |     print('-BEST TEST- best_loss: %f best_acc: %f \n'
325 |           % (test_loss_arr[load_best_model_idx], test_accuracy_arr[load_best_model_idx]))
326 | 
327 |     return load_model_path_s[load_best_model_idx]
328 | 
329 | 
330 | # *学习率下降函数，包含各类学习率下降方法
331 | def learning_rate_decay(init_learning_rate, global_step, decay_steps, decay_rate,
332 |                         decay_method="exponential", staircase=False,
333 |                         end_learning_rate=0.0001, power=1.0, cycle=False,):
334 |     """
335 |     传入初始learning_rate，根据参数及选项运用不同decay策略更新learning_rate
336 |         learning_rate : 初始的learning rate
337 |         global_step : 全局的step，与 decay_step 和 decay_rate一起决定了 learning rate的变化
338 |         staircase : 如果为 True global_step/decay_step 向下取整
339 |         end_learning_rate，power，cycle：只在polynomial_decay方法中使用
340 |     """
341 |     if decay_method == 'constant':
342 |         decayed_learning_rate = init_learning_rate
343 |     elif decay_method == 'exponential':
344 |         decayed_learning_rate = tf.train.exponential_decay(init_learning_rate, global_step, decay_steps, decay_rate, staircase)
345 |     elif decay_method == 'inverse_time':
346 |         decayed_learning_rate = tf.train.inverse_time_decay(init_learning_rate, global_step, decay_steps, decay_rate, staircase)
347 |     elif decay_method == 'natural_exp':
348 |         decayed_learning_rate = tf.train.natural_exp_decay(init_learning_rate, global_step, decay_steps, decay_rate, staircase)
349 |     elif decay_method == 'polynomial':
350 |         decayed_learning_rate = tf.train.polynomial_decay(init_learning_rate, global_step, decay_steps, decay_rate, end_learning_rate, power, cycle)
351 |     else:
352 |         decayed_learning_rate = init_learning_rate
353 | 
354 |     return decayed_learning_rate
355 | 
356 | 
357 | 
358 | 
359 | def find_best(model_class, valid_gen, test_gen, valid_batch_size, \
360 |               test_batch_size, valid_ds_size, test_ds_size, load_paths):
361 |     tf.reset_default_graph()
362 |     valid_runner = GeneratorRunner(valid_gen, valid_batch_size * 30)
363 |     img_batch, label_batch = valid_runner.get_batched_inputs(valid_batch_size)
364 |     model = model_class(False, 'NCHW')
365 |     model._build_model(img_batch)
366 |     loss, accuracy = model._build_losses(label_batch)
367 |     loss_summary = average_summary(loss, 'loss',  \
368 |                                           float(valid_ds_size) \
369 |                                           / float(valid_batch_size))
370 |     accuracy_summary = average_summary(accuracy, 'accuracy',  \
371 |                                           float(valid_ds_size) \
372 |                                           / float(valid_batch_size))
373 |     increment_op = tf.group(loss_summary.increment_op, \
374 |                             accuracy_summary.increment_op)
375 |     global_step = tf.get_variable('global_step', dtype=tf.int32, shape=[], \
376 |                                   initializer=tf.constant_initializer(0), \
377 |                                   trainable=False)
378 |     init_op = tf.group(tf.global_variables_initializer(), \
379 |                        tf.local_variables_initializer())
380 |     saver = tf.train.Saver(max_to_keep=10000)
381 |     accuracy_arr = []
382 |     loss_arr = []
383 |     print("validation")
384 |     for load_path in load_paths:
385 |         with tf.Session() as sess:
386 |             sess.run(init_op)
387 |             saver.restore(sess, load_path)  # load_path = './model/checkpoint/model.ckpt'
388 |             valid_runner.start_threads(sess, 1)
389 |             _time = time.time()
390 |             for j in range(0, valid_ds_size, valid_batch_size):
391 |                 sess.run(increment_op)
392 |             mean_loss, mean_accuracy = sess.run([loss_summary.mean_variable ,\
393 |                                             accuracy_summary.mean_variable])
394 |             accuracy_arr.append(mean_accuracy)
395 |             loss_arr.append(mean_loss)
396 |             print(load_path)
397 |             print("Accuracy:", accuracy_arr[-1], "| Loss:", loss_arr[-1], \
398 |                     "in", time.time() - _time, "seconds.")
399 |     argmax = np.argmax(accuracy_arr)
400 |     print("best savestate:", load_paths[argmax], "with", \
401 |             accuracy_arr[argmax], "accuracy and", loss_arr[argmax], \
402 |             "loss on validation")
403 |     print("test:")
404 |     test_dataset(model_class, test_gen, test_batch_size, test_ds_size, \
405 |                  load_paths[argmax])
406 |     return argmax, accuracy_arr, loss_arr
407 | """按照train方式改动
408 | """


--------------------------------------------------------------------------------
/Implement/utils.py:
--------------------------------------------------------------------------------
  1 | import tensorflow as tf
  2 | import numpy as np
  3 | from scipy import misc, io
  4 | import time
  5 | from glob import glob
  6 | from generator import *
  7 | 
  8 | # *包含loss与acc变量及操作的average_summary类
  9 | class average_summary(object):
 10 |     def __init__(self, variable, name, num_iterations):
 11 |         # sum_variable：内在累加器，用于累加每次的loss/acc
 12 |         self.sum_variable = tf.get_variable(name, shape=[],
 13 |                                             initializer=tf.constant_initializer(0.),
 14 |                                             dtype='float32',
 15 |                                             trainable=False,
 16 |                                             collections=[tf.GraphKeys.LOCAL_VARIABLES])
 17 |         # 每个batch调用一次increment_op，累加每次的loss/acc
 18 |         with tf.control_dependencies([variable]):
 19 |             self.increment_op = tf.assign_add(self.sum_variable, variable)
 20 |         # 当increment_op操作调用了num_iterations次之后，可进行下列操作
 21 |         self.mean_variable = self.sum_variable / float(num_iterations)  # 求平均的loss和acc
 22 |         self.summary = tf.summary.scalar(name, self.mean_variable)  # 将loss和acc存入tf全局图
 23 |         with tf.control_dependencies([self.summary]):
 24 |             self.reset_variable_op = tf.assign(self.sum_variable, 0)  # 当summary完成后，可进行reset
 25 |     # 外部调用，将loss/acc存入tf全局图
 26 |     def add_summary(self, sess, writer, step):
 27 |         s, _ = sess.run([self.summary, self.reset_variable_op])
 28 |         writer.add_summary(s, step)
 29 | 
 30 | # *用于挂载Net的结构，包含__build_model和__build_loss的操作
 31 | class Model(object):
 32 |     def __init__(self, is_training=None, data_format='NCHW'):
 33 |         self.data_format = data_format
 34 |         if is_training is None:
 35 |             self.is_training = tf.get_variable('is_training', dtype=tf.bool,
 36 |                                                initializer=tf.constant_initializer(True),
 37 |                                                trainable=False)
 38 |         else:
 39 |             self.is_training = is_training
 40 | 
 41 |     def _build_model(self, inputs):
 42 |         raise NotImplementedError('Here is your model definition')
 43 | 
 44 |     def _build_losses(self, labels):
 45 |         self.labels = tf.cast(labels, tf.int64)
 46 |         with tf.variable_scope('loss'):
 47 |             oh = tf.one_hot(self.labels, 2)  # 这里定义了2分类的输出
 48 |             # *除softmax cross entropy之外，还可更换其他函数
 49 |             self.loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(
 50 |                                        labels=oh, logits=self.outputs))
 51 |         with tf.variable_scope('accuracy'):
 52 |             am = tf.argmax(self.outputs, 1)
 53 |             equal = tf.equal(am, self.labels)
 54 |             self.accuracy = tf.reduce_mean(tf.cast(equal, tf.float32))
 55 |         return self.loss, self.accuracy
 56 | 
 57 | # *训练主函数
 58 | def train(model_class, use_batch_norm, use_shuf_pair,
 59 |           train_cover_dir, train_stego_dir,
 60 |           valid_cover_dir, valid_stego_dir,
 61 |           batch_size, train_ds_size, valid_ds_size,
 62 |           log_interval, max_epochs, lr,
 63 |           log_path, load_path=None):
 64 |     # *清除默认图的堆栈，设置全局图为默认图
 65 |     tf.reset_default_graph()
 66 | 
 67 |     # *is_training用于判断训练处于train或者valid状态
 68 |     is_training = tf.get_variable('is_training', dtype=tf.bool,
 69 |                                   initializer=True, trainable=False)
 70 | 
 71 |     # *定义train_op操作和valid_op操作，将is_training和batch_size设置为对应的状态
 72 |     disable_training_op = tf.assign(is_training, False)
 73 |     enable_training_op = tf.assign(is_training, True)
 74 | 
 75 |     # *模型初始化
 76 |     # 设置占位符
 77 |     temp_cover_list = glob(train_cover_dir + '/*')
 78 |     temp_img = misc.imread(temp_cover_list[0])
 79 |     temp_img_shape = temp_img.shape
 80 |     img_batch = tf.placeholder(tf.float32,
 81 |                                [batch_size, temp_img_shape[0], temp_img_shape[1], 1],
 82 |                                name='input_image_batch')
 83 |     label_batch = tf.placeholder(tf.int32, [batch_size, ], name="input_label_batch")
 84 |     # 使用占位符初始化模型
 85 |     model = model_class(is_training=is_training, data_format='NCHW',
 86 |                         with_bn=use_batch_norm, tlu_threshold=3)
 87 |     model._build_model(img_batch)
 88 |     loss, accuracy = model._build_losses(label_batch)
 89 | 
 90 |     # *设置需要最小化的loss函数
 91 |     regularization_losses = tf.get_collection(
 92 |                           tf.GraphKeys.REGULARIZATION_LOSSES)
 93 |     regularized_loss = tf.add_n([loss] + regularization_losses)
 94 |     # 定义train中使用的基于loss/acc的类（运行次数：log_interval）
 95 |     train_loss_s = average_summary(loss, 'train_loss', log_interval)
 96 |     train_accuracy_s = average_summary(accuracy, 'train_accuracy', log_interval)
 97 |     # 定义valid中使用的基于loss/acc的类（运行次数：valid_ds_size / valid_batch_size）
 98 |     valid_loss_s = average_summary(loss, 'valid_loss',
 99 |                                    float(valid_ds_size) / float(batch_size))
100 |     valid_accuracy_s = average_summary(accuracy, 'valid_accuracy',
101 |                                        float(valid_ds_size) / float(batch_size))
102 | 
103 |     # *全局变量global_step，从0开始进行计数
104 |     global_step = tf.Variable(0, trainable=False)
105 |     # *定义核心optimizer
106 |     # 定义learning_rate的decay操作
107 |     init_learning_rate = lr
108 |     decay_steps, decay_rate = 2000, 0.95
109 |     learning_rate = learning_rate_decay(init_learning_rate=init_learning_rate,
110 |                                         decay_method="exponential",
111 |                                         global_step=global_step,
112 |                                         decay_steps=decay_steps,
113 |                                         decay_rate=decay_rate)
114 |     optimizer = tf.train.AdadeltaOptimizer(learning_rate)
115 | 
116 |     # *定义train及valid过程中需要用到的操作
117 |     # 核心操作：最小化loss
118 |     minimize_op = optimizer.minimize(loss=regularized_loss, global_step=global_step)
119 |     # 训练操作（每个iteration都要用）：最小化loss；train_loss累加；train_acc累加
120 |     train_op = tf.group(minimize_op, train_loss_s.increment_op,
121 |                         train_accuracy_s.increment_op)
122 |     # 验证操作（一个epoch结束后，每个valid中的iteration都要用）：valid_loss累加；valid_acc累加
123 |     valid_op = tf.group(valid_loss_s.increment_op,
124 |                         valid_accuracy_s.increment_op)
125 |     # 初始化操作：初始化所有的全局变量和局部变量
126 |     init_op = tf.group(tf.global_variables_initializer(),
127 |                        tf.local_variables_initializer())
128 | 
129 |     # *定义模型保存变量，最大存储max_to_keep个模型
130 |     saver = tf.train.Saver(max_to_keep=max_epochs)
131 |     global_valid_accuracy = 0  # 全局valid_acc最大值
132 | 
133 |     # *会话开始
134 |     with tf.Session() as sess:
135 |         # 初始化所有的全局变量和局部变量
136 |         sess.run(init_op)
137 |         # 重载模型
138 |         if load_path is not None:
139 |             loader = tf.train.Saver(reshape=True)
140 |             loader.restore(sess, load_path)
141 |         # 定义模型及参数保存位置
142 |         writer = tf.summary.FileWriter(log_path + '/LogFile/', sess.graph)
143 | 
144 |         # 初始化train/valid的loss和acc变量
145 |         sess.run([valid_loss_s.reset_variable_op,
146 |                   valid_accuracy_s.reset_variable_op,
147 |                   train_loss_s.reset_variable_op,
148 |                   train_accuracy_s.reset_variable_op])
149 | 
150 |         # *训练开始：train/valid
151 |         print('Start training...')
152 |         global_train_batch = 0  # 全局batch计数
153 |         for epoch in range(max_epochs):
154 |             start_time = time.time()
155 |             # 加载test路径下的img及label列表
156 |             train_img_list, train_label_list = get_files(train_cover_dir,
157 |                                                          train_stego_dir,
158 |                                                          use_shuf_pair=use_shuf_pair)
159 |             # 加载valid路径下的img及label列表
160 |             valid_img_list, valid_label_list = get_files(valid_cover_dir,
161 |                                                          valid_stego_dir,
162 |                                                          use_shuf_pair=use_shuf_pair)
163 | 
164 |             # *训练开始：train
165 |             sess.run(enable_training_op)  # 转换为train训练状态
166 |             local_train_batch = 0  # 局部batch计数
167 |             for train_img_minibatch_list, train_label_minibatch_list in \
168 |                     get_minibatches(train_img_list, train_label_list, batch_size):
169 |                 # minibatch数据读取
170 |                 train_img_batch = get_minibatches_content_img(train_img_minibatch_list,
171 |                                                               temp_img_shape[0],
172 |                                                               temp_img_shape[1])
173 | 
174 |                 # train操作及指标显示
175 |                 sess.run(train_op, feed_dict={img_batch: train_img_batch,
176 |                                               label_batch: train_label_minibatch_list})
177 | 
178 |                 global_train_batch += 1
179 |                 local_train_batch += 1
180 | 
181 |                 # 每log_interval个batch后，对train_loss/acc进行存储
182 |                 # 这是由于train_loss/acc的average_summary以log_interval为基准定义
183 |                 if global_train_batch % log_interval == 0:
184 |                     # 注意：loginterval决定了每20输出一次，而不是每个batch存储loss/acc一次
185 |                     # train_loss/acc显示
186 |                     local_train_loss = train_loss_s.mean_variable
187 |                     local_train_accuracy = train_accuracy_s.mean_variable
188 |                     local_train_loss_value = local_train_loss.eval(session=sess)
189 |                     local_train_accuracy_value = local_train_accuracy.eval(session=sess)
190 |                     print('-TRAIN- epoch: %d batch: %d | train_loss: %f train_acc: %f'
191 |                           % (epoch, local_train_batch, local_train_loss_value, local_train_accuracy_value))
192 |                     # train_loss/acc存储
193 |                     train_loss_s.add_summary(sess, writer, global_train_batch)
194 |                     train_accuracy_s.add_summary(sess, writer, global_train_batch)
195 | 
196 |             # *训练开始：validation
197 |             sess.run(disable_training_op)
198 |             local_valid_loss, local_valid_accuracy = 0, 0  # 本epoch中valid_loss和valid_acc值
199 |             for valid_img_minibatch_list, valid_label_minibatch_list in \
200 |                     get_minibatches(valid_img_list, valid_label_list, batch_size):
201 |                 # minibatch数据读取
202 |                 valid_img_batch = get_minibatches_content_img(valid_img_minibatch_list,
203 |                                                               temp_img_shape[0],
204 |                                                               temp_img_shape[1])
205 | 
206 |                 # valid操作及指标显示
207 |                 sess.run(valid_op, feed_dict={img_batch: valid_img_batch,
208 |                                               label_batch: valid_label_minibatch_list})
209 | 
210 |             # 每个epoch中所有batch运行完后，对valid_loss/acc进行显示和存储
211 |             # 这是由于valid_loss/acc的average_summary以(valid_ds_size/batch_size)为基准定义
212 |             # valid_loss/acc显示
213 |             local_valid_loss = valid_loss_s.mean_variable
214 |             local_valid_accuracy = valid_accuracy_s.mean_variable
215 |             local_valid_loss_value = local_valid_loss.eval(session=sess)
216 |             local_valid_accuracy_value = local_valid_accuracy.eval(session=sess)
217 |             print('-VALID- epoch: %d | valid_loss: %f valid_acc: %f'
218 |                   % (epoch, local_valid_loss_value, local_valid_accuracy_value))
219 |             # valid_loss/acc存储
220 |             valid_loss_s.add_summary(sess, writer, global_train_batch)
221 |             valid_accuracy_s.add_summary(sess, writer, global_train_batch)
222 | 
223 |             # *模型保存：如果valid_acc大于全局valid_acc，则保存
224 |             if local_valid_accuracy_value > global_valid_accuracy or (max_epochs - epoch) < 5:
225 |                 global_valid_accuracy = local_valid_accuracy_value
226 |                 saver.save(sess, log_path + '/Model_' + str(epoch) + '.ckpt')
227 |                 print('---EPOCH:%d--- model has been saved' % epoch)
228 | 
229 |             # *本epoch中train及valid过程均完毕，记录时间
230 |             end_time = time.time()
231 |             print('--EPOCH:%d-- runtime: %.2fs ' % (epoch, end_time - start_time),
232 |                   ' learning rate: ', sess.run(learning_rate), '\n')
233 | 
234 | # *测试主函数，查找最佳模型
235 | def test_dataset_findbest(model_class, use_shuf_pair,
236 |                           test_cover_dir, test_stego_dir, max_epochs,
237 |                           batch_size, ds_size, log_path):
238 |     tf.reset_default_graph()
239 | 
240 |     # *模型初始化
241 |     # 设置占位符
242 |     temp_cover_list = glob(test_cover_dir + '/*')
243 |     temp_img = misc.imread(temp_cover_list[0])
244 |     temp_img_shape = temp_img.shape
245 |     img_batch = tf.placeholder(tf.float32,
246 |                                [batch_size, temp_img_shape[0], temp_img_shape[1], 1],
247 |                                name='input_image_batch')
248 |     label_batch = tf.placeholder(tf.int32, [batch_size, ], name="input_label_batch")
249 |     # 使用占位符初始化模型
250 |     model = model_class(is_training=False, data_format='NCHW', with_bn=True, tlu_threshold=3)
251 |     model._build_model(img_batch)
252 |     loss, accuracy = model._build_losses(label_batch)
253 | 
254 |     # *设置需要计算的loss函数，test_loss/acc与valid_loss/acc的功用类似
255 |     # 定义valid中使用的基于loss/acc的类（运行次数：valid_ds_size / valid_batch_size）
256 |     test_loss_s = average_summary(loss, 'test_loss',
257 |                                   float(ds_size) / float(batch_size))
258 |     test_accuracy_s = average_summary(accuracy, 'test_accuracy',
259 |                                       float(ds_size) / float(batch_size))
260 |     # 验证操作（一个epoch结束后，每个valid中的iteration都要用）：valid_loss累加；valid_acc累加
261 |     test_op = tf.group(test_loss_s.increment_op,
262 |                        test_accuracy_s.increment_op)
263 | 
264 |     # 初始化操作：初始化所有的全局变量和局部变量
265 |     init_op = tf.group(tf.global_variables_initializer(),
266 |                        tf.local_variables_initializer())
267 | 
268 |     # *定义模型保存变量，最大存储max_to_keep个模型
269 |     saver = tf.train.Saver()
270 | 
271 |     # *记录每次test后得到的loss和acc
272 |     test_loss_arr = []
273 |     test_accuracy_arr = []
274 | 
275 |     # *对load_data_path_s列表中的所有模型进行test操作
276 |     print('Start testing...')
277 |     # 在log路径下搜寻所有可加载文件
278 |     load_model_path_s = glob(log_path + '/*.data*')
279 |     for load_model_path in load_model_path_s:
280 |         start_time = time.time()
281 |         # *会话开始
282 |         with tf.Session() as sess:
283 |             # 初始化所有的全局变量和局部变量
284 |             sess.run(init_op)
285 |             # 重载模型，去掉结尾的.data-000...
286 |             trunc_str = '.data-'
287 |             load_model_path_trunc = load_model_path[0:load_model_path.find(trunc_str)]
288 |             saver.restore(sess, load_model_path_trunc)
289 |             # 初始化test的loss和acc变量
290 |             sess.run([test_loss_s.reset_variable_op,
291 |                       test_accuracy_s.reset_variable_op])
292 |             # 加载test路径下的img及label列表
293 |             test_img_list, test_label_list = get_files(test_cover_dir,
294 |                                                        test_stego_dir,
295 |                                                        use_shuf_pair=use_shuf_pair)
296 |             # *对当前load_data_path的模型进行test操作
297 |             for test_img_minibatch_list, test_label_minibatch_list in \
298 |                     get_minibatches(test_img_list, test_label_list, batch_size):
299 |                 # minibatch数据读取
300 |                 test_img_batch = get_minibatches_content_img(test_img_minibatch_list,
301 |                                                              temp_img_shape[0],
302 |                                                              temp_img_shape[1])
303 |                 # 对每次minibatch中test后得到的loss和acc进行累加
304 |                 sess.run(test_op, feed_dict={img_batch: test_img_batch,
305 |                                              label_batch: test_label_minibatch_list})
306 |             # *记录当前load_data_path模型test操作后得到的loss和acc
307 |             test_mean_loss, test_mean_accuracy = sess.run([test_loss_s.mean_variable,
308 |                                                            test_accuracy_s.mean_variable])
309 |             test_loss_arr.append(test_mean_loss)
310 |             test_accuracy_arr.append(test_mean_accuracy)
311 |             end_time = time.time()
312 |             print(load_model_path.split("/")[-1])
313 |             print('-TEST- test_loss: %f test_acc: %f | runtime: %.2fs \n'
314 |                   % (test_loss_arr[-1], test_accuracy_arr[-1], end_time - start_time))
315 | 
316 |     # *寻找最佳test_acc对应的模型索引
317 |     load_best_model_idx = np.argmax(test_accuracy_arr)
318 |     print('-BEST TEST- best_path: ', load_model_path_s[load_best_model_idx])
319 |     print('-BEST TEST- best_loss: %f best_acc: %f \n'
320 |           % (test_loss_arr[load_best_model_idx], test_accuracy_arr[load_best_model_idx]))
321 | 
322 |     return load_model_path_s[load_best_model_idx]
323 | 
324 | 
325 | # *学习率下降函数，包含各类学习率下降方法
326 | def learning_rate_decay(init_learning_rate, global_step, decay_steps, decay_rate,
327 |                         decay_method="exponential", staircase=False,
328 |                         end_learning_rate=0.0001, power=1.0, cycle=False,):
329 |     """
330 |     传入初始learning_rate，根据参数及选项运用不同decay策略更新learning_rate
331 |         learning_rate : 初始的learning rate
332 |         global_step : 全局的step，与 decay_step 和 decay_rate一起决定了 learning rate的变化
333 |         staircase : 如果为 True global_step/decay_step 向下取整
334 |         end_learning_rate，power，cycle：只在polynomial_decay方法中使用
335 |     """
336 |     if decay_method == 'constant':
337 |         decayed_learning_rate = init_learning_rate
338 |     elif decay_method == 'exponential':
339 |         decayed_learning_rate = tf.train.exponential_decay(init_learning_rate, global_step,
340 |                                                            decay_steps, decay_rate, staircase)
341 |     elif decay_method == 'inverse_time':
342 |         decayed_learning_rate = tf.train.inverse_time_decay(init_learning_rate, global_step,
343 |                                                             decay_steps, decay_rate, staircase)
344 |     elif decay_method == 'natural_exp':
345 |         decayed_learning_rate = tf.train.natural_exp_decay(init_learning_rate, global_step,
346 |                                                            decay_steps, decay_rate, staircase)
347 |     elif decay_method == 'polynomial':
348 |         decayed_learning_rate = tf.train.polynomial_decay(init_learning_rate, global_step,
349 |                                                           decay_steps, decay_rate,
350 |                                                           end_learning_rate, power, cycle)
351 |     else:
352 |         decayed_learning_rate = init_learning_rate
353 | 
354 |     return decayed_learning_rate
355 | 
356 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # TensorFlow-YeNet
 2 | Implementation of "Deep Learning Hierarchical Representation for Image Steganalysis" by TensorFlow
 3 | 
 4 | ## Usage  
 5 | Example commands(*.sh) can be found in the root directory  
 6 | 
 7 | ## Publication  
 8 | Ye, Jian, J. Ni, and Y. Yi.  
 9 | "Deep Learning Hierarchical Representations for Image Steganalysis."  
10 | IEEE Transactions on Information Forensics & Security 12.11(2017):2545-2557.  
11 | [**publication page**](http://ieeexplore.ieee.org/document/7937836/)  
12 | 


--------------------------------------------------------------------------------
/command_BOSS.sh:
--------------------------------------------------------------------------------
 1 | ####data_transfer
 2 | #python /home/carlchang/YeNetTensorflow/Implement/main.py /home/carlchang/YeNetTensorflow/Data/BOSS /home/carlchang/YeNetTensorflow/DataTransfer --required-size 256 --required-operation="resize,crop,subsample"
 3 | ####data_aug
 4 | #python /home/carlchang/YeNetTensorflow/Implement/main.py /home/carlchang/YeNetTensorflow/DataTransfer/BOSS_256_resize/cover /home/carlchang/YeNetTensorflow/DataAug --ratio-rot=0.5
 5 | #python /home/carlchang/YeNetTensorflow/Implement/main.py /home/carlchang/YeNetTensorflow/DataTransfer/BOSS_256_crop/cover /home/carlchang/YeNetTensorflow/DataAug --ratio-rot=0.5
 6 | #python /home/carlchang/YeNetTensorflow/Implement/main.py /home/carlchang/YeNetTensorflow/DataTransfer/BOSS_256_subsample/cover /home/carlchang/YeNetTensorflow/DataAug --ratio-rot=0.5
 7 | ####data_split
 8 | #python /home/carlchang/YeNetTensorflow/Implement/main.py /home/carlchang/YeNetTensorflow/Data/SUNI_0.4_15000 /home/carlchang/YeNetTensorflow/Experiment/SUNI_0.4_15000_No_2 --train-percent=0.6 --valid-percent=0.2 --test-percent=0.2 --gpu=" "
 9 | ####train
10 | #python /home/carlchang/YeNetTensorflow/Implement/main.py /home/carlchang/YeNetTensorflow/Experiment/SUNI_0.4_15000_No_2/train/cover /home/carlchang/YeNetTensorflow/Experiment/SUNI_0.4_15000_No_2/train/stego /home/carlchang/YeNetTensorflow/Experiment/SUNI_0.4_15000_No_2/valid/cover /home/carlchang/YeNetTensorflow/Experiment/SUNI_0.4_15000_No_2/valid/stego --log-path="/home/carlchang/YeNetTensorflow/Experiment/SUNI_0.4_15000_No_2/log" --use-batch-norm --lr 4e-1 --max-epochs=200 --log-interval=20 --gpu="2,3"
11 | ####test
12 | #python /home/carlchang/YeNetTensorflow/Implement/main.py /home/carlchang/YeNetTensorflow/Experiment/SUNI_0.4_15000_No_2/test/cover /home/carlchang/YeNetTensorflow/Experiment/SUNI_0.4_15000_No_2/test/stego --log-path="/home/carlchang/YeNetTensorflow/Experiment/SUNI_0.4_15000_No_2/log" --gpu="2,3"
13 | 


--------------------------------------------------------------------------------
/command_BOSSTEST.sh:
--------------------------------------------------------------------------------
 1 | #data_transfer
 2 | #python /home/carlchang/YeNetTensorflow/Implement/main.py /home/carlchang/YeNetTensorflow/Data/BOSSTEST /home/carlchang/YeNetTensorflow/DataTransfer --required-size 256 --required-operation="resize,crop,subsample"
 3 | 
 4 | #data_aug
 5 | #python /home/carlchang/YeNetTensorflow/Implement/main.py /home/carlchang/YeNetTensorflow/DataTransfer/BOSSTEST_256_resize/cover /home/carlchang/YeNetTensorflow/DataAug --ratio-rot=0.5
 6 | 
 7 | #python /home/carlchang/YeNetTensorflow/Implement/main.py /home/carlchang/YeNetTensorflow/DataTransfer/BOSSTEST_256_crop/cover /home/carlchang/YeNetTensorflow/DataAug --ratio-rot=0.5
 8 | 
 9 | python /home/carlchang/YeNetTensorflow/Implement/main.py /home/carlchang/YeNetTensorflow/DataTransfer/BOSSTEST_256_subsample/cover /home/carlchang/YeNetTensorflow/DataAug --ratio-rot=0.5
10 | 
11 | #train
12 | #python /home/carlchang/YeNetTensorflow/Implement/main.py /home/carlchang/YeNetTensorflow/Experiment/SUNI_0.4_15000_No_2/train/cover /home/carlchang/YeNetTensorflow/Experiment/SUNI_0.4_15000_No_2/train/stego /home/carlchang/YeNetTensorflow/Experiment/SUNI_0.4_15000_No_2/valid/cover /home/carlchang/YeNetTensorflow/Experiment/SUNI_0.4_15000_No_2/valid/stego --log-path="/home/carlchang/YeNetTensorflow/Experiment/SUNI_0.4_15000_No_2/log" --use-batch-norm --lr 4e-1 --max-epochs=200 --log-interval=20 --gpu="2,3"
13 | 
14 | #test
15 | #python /home/carlchang/YeNetTensorflow/Implement/main.py /home/carlchang/YeNetTensorflow/Experiment/SUNI_0.4_15000_No_2/test/cover /home/carlchang/YeNetTensorflow/Experiment/SUNI_0.4_15000_No_2/test/stego --log-path="/home/carlchang/YeNetTensorflow/Experiment/SUNI_0.4_15000_No_2/log" --gpu="2,3"
16 | 
17 | #data_split
18 | #python /home/carlchang/YeNetTensorflow/Implement/main.py /home/carlchang/YeNetTensorflow/Data/SUNI_0.4_15000 /home/carlchang/YeNetTensorflow/Experiment/SUNI_0.4_15000_No_2 --train-percent=0.6 --valid-percent=0.2 --test-percent=0.2 --gpu=" "
19 | 


--------------------------------------------------------------------------------
/command_SUNI_0.4_15000_No_1.sh:
--------------------------------------------------------------------------------
1 | #train
2 | #python /home/carlchang/YeNetTensorflow/Implement/main.py /home/carlchang/YeNetTensorflow/Experiment/SUNI_0.4_15000_No_1/train/cover /home/carlchang/YeNetTensorflow/Experiment/SUNI_0.4_15000_No_1/train/stego /home/carlchang/YeNetTensorflow/Experiment/SUNI_0.4_15000_No_1/valid/cover /home/carlchang/YeNetTensorflow/Experiment/SUNI_0.4_15000_No_1/valid/stego --log-path="/home/carlchang/YeNetTensorflow/Experiment/SUNI_0.4_15000_No_1/log" --use-batch-norm --lr 4e-1 --max-epochs=200 --log-interval=20 --gpu="0,1"
3 | 
4 | #test
5 | python /home/carlchang/YeNetTensorflow/Implement/main.py /home/carlchang/YeNetTensorflow/Experiment/SUNI_0.4_15000_No_1/test/cover /home/carlchang/YeNetTensorflow/Experiment/SUNI_0.4_15000_No_1/test/stego --log-path="/home/carlchang/YeNetTensorflow/Experiment/SUNI_0.4_15000_No_1/log" --gpu="0,1"
6 | 
7 | #data_split
8 | #python /home/carlchang/YeNetTensorflow/Implement/main.py /home/carlchang/YeNetTensorflow/Data/SUNI_0.4_15000 /home/carlchang/YeNetTensorflow/Experiment/SUNI_0.4_15000_No_2 --train-percent=0.6 --valid-percent=0.2 --test-percent=0.2 --gpu=" "
9 | 


--------------------------------------------------------------------------------
/command_SUNI_0.4_15000_No_2.sh:
--------------------------------------------------------------------------------
1 | #train
2 | #python /home/carlchang/YeNetTensorflow/Implement/main.py /home/carlchang/YeNetTensorflow/Experiment/SUNI_0.4_15000_No_2/train/cover /home/carlchang/YeNetTensorflow/Experiment/SUNI_0.4_15000_No_2/train/stego /home/carlchang/YeNetTensorflow/Experiment/SUNI_0.4_15000_No_2/valid/cover /home/carlchang/YeNetTensorflow/Experiment/SUNI_0.4_15000_No_2/valid/stego --log-path="/home/carlchang/YeNetTensorflow/Experiment/SUNI_0.4_15000_No_2/log" --use-batch-norm --lr 4e-1 --max-epochs=200 --log-interval=20 --gpu="2,3"
3 | 
4 | #test
5 | python /home/carlchang/YeNetTensorflow/Implement/main.py /home/carlchang/YeNetTensorflow/Experiment/SUNI_0.4_15000_No_2/test/cover /home/carlchang/YeNetTensorflow/Experiment/SUNI_0.4_15000_No_2/test/stego --log-path="/home/carlchang/YeNetTensorflow/Experiment/SUNI_0.4_15000_No_2/log" --gpu="2,3"
6 | 
7 | #data_split
8 | #python /home/carlchang/YeNetTensorflow/Implement/main.py /home/carlchang/YeNetTensorflow/Data/SUNI_0.4_15000 /home/carlchang/YeNetTensorflow/Experiment/SUNI_0.4_15000_No_2 --train-percent=0.6 --valid-percent=0.2 --test-percent=0.2 --gpu=" "
9 | 


--------------------------------------------------------------------------------