JapanKanji
2267 строк · 138.3 Кб
1{2"cells": [3{4"cell_type": "code",5"execution_count": 1,6"metadata": {},7"outputs": [],8"source": [9"import datetime\n",10"import sys, os\n",11"\n",12"import cv2 as cv2\n",13"import numpy as np\n",14"import pandas as pd\n",15"import matplotlib.pyplot as plt\n",16"import skimage.transform"17]18},19{20"cell_type": "code",21"execution_count": 2,22"metadata": {},23"outputs": [],24"source": [25"dirData = '../Data'\n",26"dataTrain = os.path.join(dirData,'train_images')\n",27"dataTest = os.path.join(dirData,'test_images')\n",28"dirTrain = dataTrain\n",29"dirTest = dataTest\n",30"\n",31"dataSave = '../Work'\n",32"dirSave = dataSave\n",33"dirLoad = dirSave\n",34"\n",35"dirPython = '../Python'\n",36"dirModels = '../Model'\n",37"dirResul = '../Result'\n",38"dirLogs = '../Logs'"39]40},41{42"cell_type": "code",43"execution_count": 3,44"metadata": {},45"outputs": [],46"source": [47"#sys.path.append(dirPython)"48]49},50{51"cell_type": "code",52"execution_count": 4,53"metadata": {},54"outputs": [55{56"data": {57"text/plain": [58"(3881,\n",59" 4150,\n",60" ['100241706_00004_2.jpg',\n",61" '100241706_00005_1.jpg',\n",62" '100241706_00005_2.jpg',\n",63" '100241706_00006_1.jpg',\n",64" '100241706_00007_2.jpg',\n",65" '100241706_00008_1.jpg',\n",66" '100241706_00008_2.jpg',\n",67" '100241706_00009_1.jpg'],\n",68" ['test_00145af3.jpg',\n",69" 'test_001c37e2.jpg',\n",70" 'test_003aa33a.jpg',\n",71" 'test_00665e33.jpg',\n",72" 'test_006964dc.jpg',\n",73" 'test_0082d2cd.jpg',\n",74" 'test_0086f578.jpg',\n",75" 'test_008bc9f0.jpg'])"76]77},78"execution_count": 4,79"metadata": {},80"output_type": "execute_result"81}82],83"source": [84"ftrain = os.listdir(dataTrain)\n",85"ftest = os.listdir(dataTest)\n",86"ftrain, ftest = sorted(ftrain), sorted(ftest)\n",87"len(ftrain), len(ftest), ftrain[:8], ftest[:8]"88]89},90{91"cell_type": "code",92"execution_count": null,93"metadata": {},94"outputs": [],95"source": []96},97{98"cell_type": "code",99"execution_count": 5,100"metadata": {},101"outputs": [102{103"data": {104"text/html": [105"<div>\n",106"<style scoped>\n",107" .dataframe tbody tr th:only-of-type {\n",108" vertical-align: middle;\n",109" }\n",110"\n",111" .dataframe tbody tr th {\n",112" vertical-align: top;\n",113" }\n",114"\n",115" .dataframe thead th {\n",116" text-align: right;\n",117" }\n",118"</style>\n",119"<table border=\"1\" class=\"dataframe\">\n",120" <thead>\n",121" <tr style=\"text-align: right;\">\n",122" <th></th>\n",123" <th>image_id</th>\n",124" <th>labels</th>\n",125" </tr>\n",126" </thead>\n",127" <tbody>\n",128" <tr>\n",129" <th>0</th>\n",130" <td>100241706_00004_2</td>\n",131" <td>U+306F 1231 3465 133 53 U+304C 275 1652 84 69 ...</td>\n",132" </tr>\n",133" <tr>\n",134" <th>1</th>\n",135" <td>100241706_00005_1</td>\n",136" <td>U+306F 1087 2018 103 65 U+304B 1456 1832 40 73...</td>\n",137" </tr>\n",138" <tr>\n",139" <th>2</th>\n",140" <td>100241706_00005_2</td>\n",141" <td>U+306F 572 1376 125 57 U+306E 1551 2080 69 68 ...</td>\n",142" </tr>\n",143" <tr>\n",144" <th>3</th>\n",145" <td>100241706_00006_1</td>\n",146" <td>U+3082 1455 3009 65 44 U+516B 1654 1528 141 75...</td>\n",147" </tr>\n",148" <tr>\n",149" <th>4</th>\n",150" <td>100241706_00007_2</td>\n",151" <td>U+309D 1201 2949 27 33 U+309D 1196 1539 27 36 ...</td>\n",152" </tr>\n",153" <tr>\n",154" <th>5</th>\n",155" <td>100241706_00008_1</td>\n",156" <td>U+25B2 1056 929 96 39 U+309D 379 1098 21 43 U+...</td>\n",157" </tr>\n",158" <tr>\n",159" <th>6</th>\n",160" <td>100241706_00008_2</td>\n",161" <td>U+25B2 1648 955 95 44 U+25B2 1887 947 96 45 U+...</td>\n",162" </tr>\n",163" <tr>\n",164" <th>7</th>\n",165" <td>100241706_00009_1</td>\n",166" <td>U+3078 1551 2071 104 41 U+3078 323 1473 135 43...</td>\n",167" </tr>\n",168" <tr>\n",169" <th>8</th>\n",170" <td>100241706_00009_2</td>\n",171" <td>U+309D 1452 1423 20 37 U+3078 690 2535 121 41 ...</td>\n",172" </tr>\n",173" <tr>\n",174" <th>9</th>\n",175" <td>100241706_00010_1</td>\n",176" <td>U+3078 587 1127 100 40 U+3064 1103 1480 60 45 ...</td>\n",177" </tr>\n",178" </tbody>\n",179"</table>\n",180"</div>"181],182"text/plain": [183" image_id labels\n",184"0 100241706_00004_2 U+306F 1231 3465 133 53 U+304C 275 1652 84 69 ...\n",185"1 100241706_00005_1 U+306F 1087 2018 103 65 U+304B 1456 1832 40 73...\n",186"2 100241706_00005_2 U+306F 572 1376 125 57 U+306E 1551 2080 69 68 ...\n",187"3 100241706_00006_1 U+3082 1455 3009 65 44 U+516B 1654 1528 141 75...\n",188"4 100241706_00007_2 U+309D 1201 2949 27 33 U+309D 1196 1539 27 36 ...\n",189"5 100241706_00008_1 U+25B2 1056 929 96 39 U+309D 379 1098 21 43 U+...\n",190"6 100241706_00008_2 U+25B2 1648 955 95 44 U+25B2 1887 947 96 45 U+...\n",191"7 100241706_00009_1 U+3078 1551 2071 104 41 U+3078 323 1473 135 43...\n",192"8 100241706_00009_2 U+309D 1452 1423 20 37 U+3078 690 2535 121 41 ...\n",193"9 100241706_00010_1 U+3078 587 1127 100 40 U+3064 1103 1480 60 45 ..."194]195},196"execution_count": 5,197"metadata": {},198"output_type": "execute_result"199}200],201"source": [202"trainY = pd.read_csv('../Data/train.csv')\n",203"trainY.head(10)"204]205},206{207"cell_type": "code",208"execution_count": null,209"metadata": {},210"outputs": [],211"source": []212},213{214"cell_type": "code",215"execution_count": null,216"metadata": {},217"outputs": [],218"source": []219},220{221"cell_type": "code",222"execution_count": 6,223"metadata": {},224"outputs": [225{226"data": {227"text/html": [228"<div>\n",229"<style scoped>\n",230" .dataframe tbody tr th:only-of-type {\n",231" vertical-align: middle;\n",232" }\n",233"\n",234" .dataframe tbody tr th {\n",235" vertical-align: top;\n",236" }\n",237"\n",238" .dataframe thead th {\n",239" text-align: right;\n",240" }\n",241"</style>\n",242"<table border=\"1\" class=\"dataframe\">\n",243" <thead>\n",244" <tr style=\"text-align: right;\">\n",245" <th></th>\n",246" <th>symb</th>\n",247" <th>x</th>\n",248" <th>y</th>\n",249" <th>w</th>\n",250" <th>h</th>\n",251" </tr>\n",252" </thead>\n",253" <tbody>\n",254" <tr>\n",255" <th>0</th>\n",256" <td>U+306F</td>\n",257" <td>1231</td>\n",258" <td>3465</td>\n",259" <td>133</td>\n",260" <td>53</td>\n",261" </tr>\n",262" <tr>\n",263" <th>1</th>\n",264" <td>U+304C</td>\n",265" <td>275</td>\n",266" <td>1652</td>\n",267" <td>84</td>\n",268" <td>69</td>\n",269" </tr>\n",270" <tr>\n",271" <th>2</th>\n",272" <td>U+3044</td>\n",273" <td>1495</td>\n",274" <td>1218</td>\n",275" <td>143</td>\n",276" <td>69</td>\n",277" </tr>\n",278" <tr>\n",279" <th>3</th>\n",280" <td>U+3051</td>\n",281" <td>220</td>\n",282" <td>3331</td>\n",283" <td>53</td>\n",284" <td>91</td>\n",285" </tr>\n",286" <tr>\n",287" <th>4</th>\n",288" <td>U+306B</td>\n",289" <td>911</td>\n",290" <td>1452</td>\n",291" <td>61</td>\n",292" <td>92</td>\n",293" </tr>\n",294" </tbody>\n",295"</table>\n",296"</div>"297],298"text/plain": [299" symb x y w h\n",300"0 U+306F 1231 3465 133 53\n",301"1 U+304C 275 1652 84 69\n",302"2 U+3044 1495 1218 143 69\n",303"3 U+3051 220 3331 53 91\n",304"4 U+306B 911 1452 61 92"305]306},307"execution_count": 6,308"metadata": {},309"output_type": "execute_result"310}311],312"source": [313"#\n",314"# heights & weights\n",315"#\n",316"aa=[np.array(l.split()).reshape((-1,5)) for l in trainY.dropna().labels]\n",317"bb=np.vstack(aa)\n",318"\n",319"dfClasses = pd.DataFrame()\n",320"dfClasses['symb'] = bb[:,0]\n",321"dfClasses['x'] = bb[:,1].astype(np.int16)\n",322"dfClasses['y'] = bb[:,2].astype(np.int16)\n",323"dfClasses['w'] = bb[:,3].astype(np.int16)\n",324"dfClasses['h'] = bb[:,4].astype(np.int16)\n",325"\n",326"dfClasses.head()"327]328},329{330"cell_type": "code",331"execution_count": 7,332"metadata": {},333"outputs": [334{335"data": {336"text/html": [337"<div>\n",338"<style scoped>\n",339" .dataframe tbody tr th:only-of-type {\n",340" vertical-align: middle;\n",341" }\n",342"\n",343" .dataframe tbody tr th {\n",344" vertical-align: top;\n",345" }\n",346"\n",347" .dataframe thead th {\n",348" text-align: right;\n",349" }\n",350"</style>\n",351"<table border=\"1\" class=\"dataframe\">\n",352" <thead>\n",353" <tr style=\"text-align: right;\">\n",354" <th></th>\n",355" <th>symb</th>\n",356" <th>hcount</th>\n",357" <th>hmean</th>\n",358" <th>hstd</th>\n",359" <th>wcount</th>\n",360" <th>wmean</th>\n",361" <th>wstd</th>\n",362" </tr>\n",363" </thead>\n",364" <tbody>\n",365" <tr>\n",366" <th>80</th>\n",367" <td>U+306B</td>\n",368" <td>24685</td>\n",369" <td>81.266964</td>\n",370" <td>23.367150</td>\n",371" <td>24685</td>\n",372" <td>66.787766</td>\n",373" <td>24.607299</td>\n",374" </tr>\n",375" <tr>\n",376" <th>83</th>\n",377" <td>U+306E</td>\n",378" <td>24136</td>\n",379" <td>79.463913</td>\n",380" <td>23.876515</td>\n",381" <td>24136</td>\n",382" <td>82.174428</td>\n",383" <td>23.512733</td>\n",384" </tr>\n",385" <tr>\n",386" <th>60</th>\n",387" <td>U+3057</td>\n",388" <td>22209</td>\n",389" <td>124.199514</td>\n",390" <td>50.427857</td>\n",391" <td>22209</td>\n",392" <td>33.656761</td>\n",393" <td>27.332906</td>\n",394" </tr>\n",395" <tr>\n",396" <th>75</th>\n",397" <td>U+3066</td>\n",398" <td>20569</td>\n",399" <td>95.881278</td>\n",400" <td>24.440175</td>\n",401" <td>20569</td>\n",402" <td>67.325247</td>\n",403" <td>21.920820</td>\n",404" </tr>\n",405" <tr>\n",406" <th>77</th>\n",407" <td>U+3068</td>\n",408" <td>16588</td>\n",409" <td>83.424463</td>\n",410" <td>21.888026</td>\n",411" <td>16588</td>\n",412" <td>43.707499</td>\n",413" <td>13.900656</td>\n",414" </tr>\n",415" </tbody>\n",416"</table>\n",417"</div>"418],419"text/plain": [420" symb hcount hmean hstd wcount wmean wstd\n",421"80 U+306B 24685 81.266964 23.367150 24685 66.787766 24.607299\n",422"83 U+306E 24136 79.463913 23.876515 24136 82.174428 23.512733\n",423"60 U+3057 22209 124.199514 50.427857 22209 33.656761 27.332906\n",424"75 U+3066 20569 95.881278 24.440175 20569 67.325247 21.920820\n",425"77 U+3068 16588 83.424463 21.888026 16588 43.707499 13.900656"426]427},428"execution_count": 7,429"metadata": {},430"output_type": "execute_result"431}432],433"source": [434"dfCount = dfClasses[['symb','h','w']].groupby(['symb']).agg(['count','mean','std'])\n",435"dfCount = dfCount.reset_index()\n",436"dfCount.columns = ['symb','hcount','hmean','hstd','wcount','wmean','wstd']\n",437"dfCount = dfCount.fillna(0)\n",438"dfCount.sort_values(['hcount'], ascending=False).head()"439]440},441{442"cell_type": "code",443"execution_count": null,444"metadata": {},445"outputs": [],446"source": []447},448{449"cell_type": "code",450"execution_count": 8,451"metadata": {},452"outputs": [453{454"name": "stdout",455"output_type": "stream",456"text": [457"(4212,)\n"458]459},460{461"data": {462"text/plain": [463"array(['U+306B', 'U+306E', 'U+3057', 'U+3066', 'U+3068', 'U+3092',\n",464" 'U+306F', 'U+304B', 'U+308A', 'U+306A', 'U+3082', 'U+3044',\n",465" 'U+308B', 'U+3089', 'U+305F', 'U+304F', 'U+3078', 'U+307E',\n",466" 'U+304D', 'U+308C'], dtype=object)"467]468},469"execution_count": 8,470"metadata": {},471"output_type": "execute_result"472}473],474"source": [475"classes_all = dfCount.sort_values('hcount',ascending=False)[['symb']].values.squeeze()\n",476"print(classes_all.shape)\n",477"classes_all[:20]"478]479},480{481"cell_type": "code",482"execution_count": 9,483"metadata": {},484"outputs": [485{486"data": {487"text/plain": [488"4212"489]490},491"execution_count": 9,492"metadata": {},493"output_type": "execute_result"494}495],496"source": [497"classes = classes_all[0:500]\n",498"classes = classes_all\n",499"len(classes)"500]501},502{503"cell_type": "code",504"execution_count": null,505"metadata": {},506"outputs": [],507"source": []508},509{510"cell_type": "code",511"execution_count": 10,512"metadata": {},513"outputs": [],514"source": [515"shape_net = np.array((1024, 512+256, 1))\n",516"shape_net = np.array((1024+512, 512+512, 1))\n",517"\n",518"n_anchors = 4\n",519"\n",520"dirSaveX = os.path.join(dirSave,'{shape[0]}x{shape[1]}x{shape[2]}'.format(shape=shape_net)); \n",521"dirLoadX = dirSaveX\n",522"\n",523"batch_size= 8"524]525},526{527"cell_type": "code",528"execution_count": null,529"metadata": {},530"outputs": [],531"source": []532},533{534"cell_type": "code",535"execution_count": 11,536"metadata": {},537"outputs": [],538"source": [539"anchors_net = np.load(os.path.join(dirSaveX,'anchors_net.npy'))"540]541},542{543"cell_type": "code",544"execution_count": null,545"metadata": {},546"outputs": [],547"source": []548},549{550"cell_type": "code",551"execution_count": 12,552"metadata": {},553"outputs": [554{555"data": {556"text/plain": [557"array([[ 12.87340051, 14.71878874],\n",558" [ 29.01291339, 62.38006796],\n",559" [ 64.06123873, 59.79107683],\n",560" [ 89.22370175, 115.99161836]])"561]562},563"execution_count": 12,564"metadata": {},565"output_type": "execute_result"566}567],568"source": [569"anchors_net"570]571},572{573"cell_type": "code",574"execution_count": null,575"metadata": {},576"outputs": [],577"source": []578},579{580"cell_type": "code",581"execution_count": 13,582"metadata": {},583"outputs": [],584"source": [585"def xTrainCreate (nameFiles, shape_net, dirFiles=dirTrain, \n",586" bwOK=True, norm=True, stats=False) :\n",587" \n",588" dd = [1,] if bwOK else [3,]\n",589" bw = 0 if bwOK else -1\n",590" \n",591" zxtrain = np.zeros([len(nameFiles),]+list(shape_net), dtype=np.float32)\n",592" \n",593" scale_all = []\n",594" shape_in_all = []\n",595"\n",596" for ii,image_id in enumerate(nameFiles) :\n",597" img = cv2.imread(os.path.join(dirFiles,image_id+'.jpg'),bw)\n",598" shape_in = img.shape[:2]\n",599" scale = min(np.array(shape_net[:2])/np.array(shape_in[:2]));\n",600"\n",601" newX,newY = shape_in[1]*scale, shape_in[0]*scale\n",602" newimg = cv2.resize(img,(int(newX),int(newY)))\n",603"\n",604" \n",605" if stats :\n",606" if ii==0 : means, stds = [], []\n",607" means.append(newimg.mean())\n",608" stds.append(newimg.std())\n",609"\n",610" newimg = newimg.astype(np.float64)\n",611" newimg = newimg-newimg.mean()\n",612" #newimg = newimg/127.0\n",613" newimg = newimg/max(abs(newimg.min()),abs(newimg.max()))\n",614"\n",615" ##newimg = newimg/newimg.std()\n",616"\n",617" ###newimg = np.clip(newimg,-1.0,1.0) ####### shift mean on +0.15\n",618" \n",619" if bwOK : newimg = newimg.reshape(newimg.shape+(1,))\n",620" zxtrain[ii,:int(newY),:int(newX)] = newimg\n",621" scale_all.append(scale)\n",622" shape_in_all.append(shape_in)\n",623" \n",624" scale_all = np.array(scale_all)\n",625" shape_in_all = np.array(shape_in_all)\n",626" \n",627" if stats : return(zxtrain,scale_all,shape_in_all,np.array(means),np.array(stds))\n",628"\n",629" return(zxtrain,scale_all,shape_in_all)"630]631},632{633"cell_type": "code",634"execution_count": null,635"metadata": {},636"outputs": [],637"source": []638},639{640"cell_type": "code",641"execution_count": null,642"metadata": {},643"outputs": [],644"source": []645},646{647"cell_type": "code",648"execution_count": 14,649"metadata": {},650"outputs": [651{652"name": "stderr",653"output_type": "stream",654"text": [655"Using TensorFlow backend.\n"656]657}658],659"source": [660"from keras.models import Input, Model\n",661"from keras.layers import Convolution2D, MaxPooling2D, UpSampling2D, Conv2D, Concatenate, Activation, Dropout,Add\n",662"from keras.layers import Conv2DTranspose, SpatialDropout2D, Dense, Reshape, Flatten, AveragePooling2D\n",663"from keras.layers.normalization import BatchNormalization\n",664"from keras.callbacks import ModelCheckpoint, ReduceLROnPlateau, EarlyStopping, TensorBoard\n",665"import keras\n",666"import keras.backend as K "667]668},669{670"cell_type": "code",671"execution_count": 15,672"metadata": {},673"outputs": [],674"source": [675"import tensorflow as tf"676]677},678{679"cell_type": "code",680"execution_count": 16,681"metadata": {},682"outputs": [683{684"data": {685"text/plain": [686"'2.2.4'"687]688},689"execution_count": 16,690"metadata": {},691"output_type": "execute_result"692}693],694"source": [695"keras.__version__"696]697},698{699"cell_type": "code",700"execution_count": null,701"metadata": {},702"outputs": [],703"source": []704},705{706"cell_type": "code",707"execution_count": null,708"metadata": {},709"outputs": [],710"source": []711},712{713"cell_type": "code",714"execution_count": null,715"metadata": {},716"outputs": [],717"source": []718},719{720"cell_type": "code",721"execution_count": null,722"metadata": {},723"outputs": [],724"source": []725},726{727"cell_type": "code",728"execution_count": 17,729"metadata": {},730"outputs": [],731"source": [732"from keras.models import load_model\n",733"\n",734"def modelLoad (filemodel, customs={}, **kwarg) :\n",735" model10 = load_model(filemodel,compile=False,custom_objects=customs)\n",736" return(model10)\n",737"\n",738"\n",739"model10 = modelLoad(os.path.join(dirModels,'best_mySoloV3Tinyx4212x1536x1024x1xIT1.hdf5'));"740]741},742{743"cell_type": "code",744"execution_count": null,745"metadata": {},746"outputs": [],747"source": []748},749{750"cell_type": "code",751"execution_count": 18,752"metadata": {},753"outputs": [754{755"data": {756"text/plain": [757"((1536, 1024, 1), (47, 31, 4, 4217))"758]759},760"execution_count": 18,761"metadata": {},762"output_type": "execute_result"763}764],765"source": [766"shape_out = model10.get_layer(index=-1).output_shape[1:];\n",767"model10.get_layer(index=0).output_shape[1:], shape_out"768]769},770{771"cell_type": "code",772"execution_count": 19,773"metadata": {},774"outputs": [],775"source": [776"shape_net = np.array(model10.get_layer(index=0).output_shape[1:])\n",777"shape_out = np.array(model10.get_layer(index=-1).output_shape[1:])\n",778"grid_net = shape_net[0:2]/shape_out[0:2]"779]780},781{782"cell_type": "code",783"execution_count": null,784"metadata": {},785"outputs": [],786"source": []787},788{789"cell_type": "code",790"execution_count": 20,791"metadata": {},792"outputs": [],793"source": [794"try : del xtrain, ptrain\n",795"except : abc = 1\n",796"try : del xtest, ptest\n",797"except : abc = 1"798]799},800{801"cell_type": "code",802"execution_count": null,803"metadata": {},804"outputs": [],805"source": []806},807{808"cell_type": "code",809"execution_count": 21,810"metadata": {},811"outputs": [812{813"name": "stdout",814"output_type": "stream",815"text": [816"2019-08-25 00:38:45.112419\n",817"2019-08-25 00:45:28.595624\n"818]819},820{821"data": {822"text/plain": [823"((4150, 1536, 1024, 1), (4150,), (4150, 2))"824]825},826"execution_count": 21,827"metadata": {},828"output_type": "execute_result"829}830],831"source": [832"try : del xtest\n",833"except : abc = 1\n",834" \n",835"print(datetime.datetime.now())\n",836" \n",837"testFiles = pd.read_csv('../Data/sample_submission.csv')\n",838"testFiles = testFiles.image_id.values.tolist()\n",839"xtest, scale_test, shape_in_test, test_means, test_stds = xTrainCreate(testFiles, shape_net, dirFiles=dirTest,\n",840" norm =True,\n",841" stats=True,\n",842" bwOK=True) \n",843"\n",844"print(datetime.datetime.now())\n",845"\n",846"xtest.shape, scale_test.shape, shape_in_test.shape "847]848},849{850"cell_type": "code",851"execution_count": 22,852"metadata": {},853"outputs": [854{855"name": "stdout",856"output_type": "stream",857"text": [858"2019-08-25 00:45:28.601486\n",859"2019-08-25 00:49:45.862401\n"860]861}862],863"source": [864"if 0 :\n",865" print(datetime.datetime.now())\n",866" testFiles\n",867" np.save('../Work/xtest_files.npy',testFiles)\n",868" np.save('../Work/xtest_scale.npy',scale_test)\n",869" np.save('../Work/xtest_shape_in.npy',shape_in_test)\n",870" np.save('../Work/xtest.npy',xtest)\n",871" print(datetime.datetime.now())"872]873},874{875"cell_type": "code",876"execution_count": 21,877"metadata": {},878"outputs": [879{880"name": "stdout",881"output_type": "stream",882"text": [883"2019-08-25 02:27:20.312774\n",884"2019-08-25 02:31:41.453936\n"885]886}887],888"source": [889"if 1 :\n",890" try : del xtest\n",891" except : abc = 1\n",892"\n",893" print(datetime.datetime.now())\n",894" testFiles = np.load('../Work/xtest_files.npy')\n",895" scale_test = np.load('../Work/xtest_scale.npy')\n",896" shape_in_test = np.load('../Work/xtest_shape_in.npy')\n",897" xtest = np.load('../Work/xtest.npy')\n",898" print(datetime.datetime.now())"899]900},901{902"cell_type": "code",903"execution_count": 22,904"metadata": {},905"outputs": [906{907"data": {908"text/plain": [909"array([[ 12.87340051, 14.71878874],\n",910" [ 29.01291339, 62.38006796],\n",911" [ 64.06123873, 59.79107683],\n",912" [ 89.22370175, 115.99161836]])"913]914},915"execution_count": 22,916"metadata": {},917"output_type": "execute_result"918}919],920"source": [921"anchors_net = np.load(os.path.join(dirSaveX,'anchors_net.npy')); anchors_net"922]923},924{925"cell_type": "code",926"execution_count": 23,927"metadata": {},928"outputs": [929{930"data": {931"text/plain": [932"array(['U+306B', 'U+306E', 'U+3057', 'U+3066', 'U+3068', 'U+3092',\n",933" 'U+306F', 'U+304B', 'U+308A', 'U+306A', 'U+3082', 'U+3044',\n",934" 'U+308B', 'U+3089', 'U+305F', 'U+304F', 'U+3078', 'U+307E',\n",935" 'U+304D', 'U+308C', 'U+3055', 'U+3075', 'U+3064', 'U+3093',\n",936" 'U+304C', 'U+3046', 'U+3059', 'U+3042', 'U+3084', 'U+304A',\n",937" 'U+3053', 'U+3088', 'U+3072', 'U+3051', 'U+3070', 'U+305B',\n",938" 'U+305D', 'U+309D', 'U+3081', 'U+3060', 'U+4E00', 'U+3067',\n",939" 'U+3069', 'U+307F', 'U+30A2', 'U+306D', 'U+4EBA', 'U+3031',\n",940" 'U+308F', 'U+3061', 'U+30FB', 'U+4E8B', 'U+5165', 'U+308D',\n",941" 'U+305A', 'U+51FA', 'U+3079', 'U+4E91', 'U+3058', 'U+5B50',\n",942" 'U+53C8', 'U+307B', 'U+306C', 'U+898B', 'U+3086', 'U+7269',\n",943" 'U+5927', 'U+6B64', 'U+3080', 'U+4E0A', 'U+65E5', 'U+3054',\n",944" 'U+5176', 'U+4E09', 'U+3056', 'U+65B9', 'U+4E2D', 'U+5C0F',\n",945" 'U+4E5F', 'U+4F55', 'U+25CB', 'U+4E8C', 'U+5973', 'U+5019',\n",946" 'U+5FA1', 'U+56FD', 'U+5341', 'U+3073', 'U+4ECA', 'U+30CF',\n",947" 'U+6642', 'U+662F', 'U+3065', 'U+300C', 'U+6C34', 'U+5408',\n",948" 'U+624B', 'U+30C8', 'U+6240', 'U+4E94'], dtype=object)"949]950},951"execution_count": 23,952"metadata": {},953"output_type": "execute_result"954}955],956"source": [957"classes[:100]"958]959},960{961"cell_type": "code",962"execution_count": 26,963"metadata": {},964"outputs": [965{966"data": {967"image/png": "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\n",968"text/plain": [969"<Figure size 1080x864 with 4 Axes>"970]971},972"metadata": {973"needs_background": "light"974},975"output_type": "display_data"976}977],978"source": [979"plt.figure(figsize=(15,12))\n",980"plt.subplot (2,2,1); plt.hist(test_means,bins=100); plt.title('means')\n",981"plt.subplot (2,2,2); plt.hist(test_stds, bins=100); plt.title('stds')\n",982"plt.subplot (2,2,3); plt.hist(scale_test,bins=100); plt.title('scale')\n",983"plt.subplot (224); plt.scatter(shape_in_test[:,0],shape_in_test[:,1],); plt.title('shapes')\n",984"plt.show()"985]986},987{988"cell_type": "code",989"execution_count": 24,990"metadata": {},991"outputs": [992{993"data": {994"image/png": "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\n",995"text/plain": [996"<Figure size 432x288 with 1 Axes>"997]998},999"metadata": {1000"needs_background": "light"1001},1002"output_type": "display_data"1003},1004{1005"data": {1006"image/png": "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\n",1007"text/plain": [1008"<Figure size 432x288 with 1 Axes>"1009]1010},1011"metadata": {1012"needs_background": "light"1013},1014"output_type": "display_data"1015}1016],1017"source": [1018"plt.hist(xtest.mean(axis=(1,2,3)),bins=100)\n",1019"plt.show()\n",1020"plt.hist(xtest.std(axis=(1,2,3)),bins=100)\n",1021"plt.show()"1022]1023},1024{1025"cell_type": "code",1026"execution_count": null,1027"metadata": {},1028"outputs": [],1029"source": []1030},1031{1032"cell_type": "code",1033"execution_count": 25,1034"metadata": {},1035"outputs": [],1036"source": [1037"def s(x) : return(1.0/(1.0+np.exp(np.clip(-x,-10000,50))))\n",1038"def softmax(x, axis=-1):\n",1039" y = np.exp(x - np.max(x, axis, keepdims=True))\n",1040" return y / np.sum(y, axis, keepdims=True)"1041]1042},1043{1044"cell_type": "code",1045"execution_count": 26,1046"metadata": {1047"scrolled": false1048},1049"outputs": [],1050"source": [1051"def drawPred1 (img1, pred1, anchors, grid_net, shape_net, threshold=0.5, \n",1052" iiNumber=-1, f1=-1,\n",1053" sigmoidOK=False, show=True, printOK=False) :\n",1054" \n",1055" if show : plt.figure(figsize=(10,15))\n",1056" plt.imshow(img1.squeeze())\n",1057" \n",1058" iCount, rCount = 0, 0\n",1059" \n",1060" ecolor = ['r','g','b','w']\n",1061"\n",1062" for rr, a1 in enumerate(pred1) :\n",1063" for cc, a2 in enumerate(a1) :\n",1064" for aa, pr in enumerate(a2) :\n",1065" if s(pr[0])>=threshold :\n",1066" iCount += 1\n",1067" if printOK : print(iCount, '.. ', rr, cc, aa, '\\t', np.round(pr[0:5],4))\n",1068" lx4 = pr[1:5].copy()\n",1069" if sigmoidOK : lx4[0:2] = s(lx4[0:2])\n",1070" \n",1071" #print('lx4 ',np.round(lx4,2))\n",1072" \n",1073" lx4[0:2] = np.round((lx4[0:2]+(cc,rr))*(grid_net[1],grid_net[0])) # x, y\n",1074" pclass = -1\n",1075" if len(pr)>5 :\n",1076" aacc = s(pr[5:])\n",1077" iclass = aacc.argmax()\n",1078" pclass = aacc[iclass]\n",1079" marker = 'o' if pclass>0.5 else 's'\n",1080" color = 'r' if pclass>0.5 else 'b'\n",1081" if color=='r' : rCount = rCount+1\n",1082" if len(pr)<=5 :\n",1083" marker = 'o'\n",1084" color = 'r'\n",1085" \n",1086" plt.scatter(lx4[0],lx4[1], color=color, marker=marker)\n",1087" \n",1088" lx4[2:4] = np.exp(lx4[2:4])*anchors[aa] # w,h\n",1089" \n",1090" tl, dr = np.floor(lx4[0:2]-lx4[2:4]/2), np.ceil(lx4[0:2]+lx4[2:4]/2)\n",1091" \n",1092" tl[0] = np.clip(tl[0],0,shape_net[1])\n",1093" tl[1] = np.clip(tl[1],0,shape_net[0])\n",1094" dr[0] = np.clip(dr[0],0,shape_net[1])\n",1095" dr[1] = np.clip(dr[1],0,shape_net[0])\n",1096" \n",1097" border = [tl,[tl[0],dr[1]],dr,[dr[0],tl[1]]]\n",1098" line = plt.Polygon(border, closed=True, fill=None, edgecolor=ecolor[aa]) #'r')\n",1099" plt.gca().add_line(line)\n",1100"\n",1101" \n",1102" plt.title(str(iCount)+' '+str(rCount)+\n",1103" (' ('+str(iiNumber)+')' if iiNumber>=0 else '')+(' ('+str(f1)+')' if f1>=0 else ''))\n",1104" \n",1105" if show :\n",1106" plt.show()\n",1107" plt.close()\n",1108" print(iCount)\n",1109" \n",1110" return\n",1111"\n",1112"if 0 :\n",1113" ii = 2000\n",1114" ii = 500\n",1115" ii = 1574\n",1116" ii = 3278\n",1117" ii = 0\n",1118"\n",1119" pdraw = model10.predict(xtest[:100],batch_size=batch_size)\n",1120"\n",1121" for ii in range(90,len(pdraw)) :\n",1122" drawPred1 (xtest[ii], pdraw[ii], anchors_net, grid_net, shape_net, \n",1123" printOK=False, threshold=0.5, sigmoidOK=True)"1124]1125},1126{1127"cell_type": "code",1128"execution_count": 27,1129"metadata": {},1130"outputs": [],1131"source": [1132"def drawSub1 (imgFile, sub, showOK=True) :\n",1133" img = cv2.imread(imgFile,-1)\n",1134"\n",1135" aa = np.array(sub.split()).reshape((-1,3))\n",1136" aaxy = aa[:,1:3].astype(np.int32)\n",1137" if False :\n",1138" plt.hist(aaxy[:,0],bins=150); plt.show()\n",1139" plt.hist(aaxy[:,1],bins=350); plt.show()\n",1140" \n",1141" plt.figure(figsize=(15,20))\n",1142"\n",1143" plt.imshow(img.squeeze())\n",1144" plt.scatter(aaxy[:,0],aaxy[:,1], c='r')\n",1145" plt.title('l={:d}'.format(len(aaxy)))\n",1146" if showOK : plt.show()\n",1147" return\n",1148"\n",1149"#subs = pd.read_csv(os.path.join(dirResult,'boba-030.csv'))\n",1150"\n",1151"#plt.figure(figsize=(15,20))\n",1152"ii = 3000\n",1153"#imgFile = os.path.join(dirTest,subs.image_id[ii]+'.jpg')\n",1154"#drawSub1(imgFile,subs.fillna('').labels[ii])\n",1155"#drawSub1(imgFile,results[0][ii])"1156]1157},1158{1159"cell_type": "code",1160"execution_count": 57,1161"metadata": {},1162"outputs": [],1163"source": [1164"def s(x) : return(1.0/(1.0+np.exp(np.clip(-x,-10000,50))))\n",1165"def softmax(x, axis=-1):\n",1166" y = np.exp(x - np.max(x, axis, keepdims=True))\n",1167" return y / np.sum(y, axis, keepdims=True)\n",1168"\n",1169"def BBxyTLDR (lx4_, rr,cc, anchor_net, scale, grid_net, shape_in=None) :\n",1170" \n",1171" lx4 = lx4_.copy()\n",1172" \n",1173" lx4[0:2] = s(lx4[0:2])\n",1174" \n",1175" lx4[0] = (lx4[0]+cc)*grid_net[1] # center x \n",1176" lx4[1] = (lx4[1]+rr)*grid_net[0] # center y\n",1177" \n",1178" lx4[2:4] = anchor_net*np.exp(lx4[2:4]) # size x, y\n",1179" \n",1180" tl = np.round((lx4[0:2]-lx4[2:4]/2)/scale,0) # top-left x,y point\n",1181" dr = np.round((lx4[0:2]+lx4[2:4]/2)/scale,0) # down-right x,y point\n",1182"\n",1183" if shape_in is not None:\n",1184" tl = np.clip(tl,0,(shape_in[1],shape_in[0]))\n",1185" dr = np.clip(dr,0,(shape_in[1],shape_in[0]))\n",1186" \n",1187" return(tl.astype(np.int32),dr.astype(np.int32))\n",1188"\n",1189"\n",1190"def BBxySizeHalf (lx4_, rr,cc, anchor_net, scale, grid_net) :\n",1191" \n",1192" lx4 = lx4_.copy()\n",1193" \n",1194" lx4[0:2] = s(lx4[0:2])\n",1195" \n",1196" lx4[0] = (lx4[0]+cc)*grid_net[1] # center x \n",1197" lx4[1] = (lx4[1]+rr)*grid_net[0] # center y\n",1198" \n",1199" lx4[2:4] = anchor_net*np.exp(lx4[2:4]) # size x, y\n",1200" \n",1201" lx4 = np.round(lx4/scale,0)\n",1202" \n",1203" return(lx4[0:4].astype(np.int32))\n",1204"\n",1205"def BBxyHalf (lx2_, rr,cc, scale, grid_net) :\n",1206" \n",1207" lx4 = lx2_.copy()\n",1208" \n",1209" lx4[0:2] = s(lx4[0:2])\n",1210" \n",1211" lx4[0] = (lx4[0]+cc)*grid_net[1] # center x \n",1212" lx4[1] = (lx4[1]+rr)*grid_net[0] # center y\n",1213" \n",1214" lx4 = np.round(lx4/scale)\n",1215" \n",1216" return(lx4[0:2].astype(np.int32))\n",1217"\n",1218"\n",1219"def formSub (pSub, scale_all, shape_in_all, classes, anchors_net, grid_net, classesOK=True, **kwargs) :\n",1220" labels = []\n",1221" for ii, pSub1 in enumerate(pSub) :\n",1222" \n",1223" if classesOK :\n",1224" pSub1 = nms(pSub1, scale_all[ii], shape_in_all[ii], anchors_net, grid_net, \n",1225" threshold2=0.5, debug=False)\n",1226"\n",1227" label1 = formSub1(pSub1, scale_all[ii], shape_in_all[ii], classes, grid_net, \n",1228" classesOK=classesOK, **kwargs)\n",1229" labels.append(label1)\n",1230" \n",1231" return(labels)\n",1232" \n",1233"def formSubx4(pSub, scale_all, shape_in_all, classes, anchors_net, grid_net, delta, classesOK=True, **kwargs) :\n",1234" \n",1235" labels = []\n",1236" for ii, pSub1 in enumerate(pSub) :\n",1237" \n",1238" label1 = formSub1x4(pSub1, scale_all[ii], shape_in_all[ii], \n",1239" classes, grid_net, anchors_net, delta[ii],\n",1240" classesOK=classesOK, **kwargs)\n",1241" \n",1242" #label1 = NMSx4(label1, noClass=False)\n",1243" \n",1244" labels.append(label1)\n",1245" \n",1246" return(labels)\n",1247" \n",1248"def formSub1(pSub1, scale, shape_in, classes, grid_net,\n",1249" threshold=0.5, threshold2=0.5, classesOK=True, sigmoidOK=True, softmaxOK=False,\n",1250" **kwargs) :\n",1251" \n",1252" label1 = ''\n",1253" for ir,rr in enumerate(pSub1) :\n",1254" for ic,cc in enumerate(rr) :\n",1255" for aa in cc :\n",1256" #print(aa.shape, s(aa[0]),len(threshold))\n",1257" \n",1258" paa = s(aa[0]) if sigmoidOK else aa[0].copy()\n",1259" if (paa>=threshold) :\n",1260" \n",1261" lx4 = BBxyHalf(aa[1:3],ir,ic,scale,grid_net) \n",1262" \n",1263" lx4 = np.clip(lx4,0,(shape_in[1],shape_in[0]))\n",1264" \n",1265" class1 = -1\n",1266" try : class1 = softmax(aa[5:]).argmax() if sigmoidOK else aa[5:].argmax()\n",1267" except : class1 = -1\n",1268" if class1>=0 :\n",1269" pclass = s(aa[5+class1]) if sigmoidOK else aa[5+class1].copy()\n",1270" if pclass<threshold2 : class1=-1\n",1271" #print(class1, pclass)\n",1272" if classesOK :\n",1273" if class1>=0 :\n",1274" label1 = label1+(classes[class1] if class1>=0 else '+X0000')\n",1275" label1 = label1+' '+str(int(lx4[0]))+' '+str(int(lx4[1]))+' '\n",1276" else :\n",1277" label1 = label1+(classes[class1] if class1>=0 else '+X0000')\n",1278" label1 = label1+' '+str(int(lx4[0]))+' '+str(int(lx4[1]))+' '\n",1279" label1 = label1.strip()\n",1280" return(label1)\n",1281"\n",1282"def formSubY(pSub1, scale, shape_in, classes, \n",1283" threshold=0.5, threshold2=0.5, classesOK=True, sigmoidOK=False,\n",1284" **kwargs) :\n",1285" label1 = ''\n",1286" for ir,rr in enumerate(pSub1) :\n",1287" for ic,cc in enumerate(rr) :\n",1288" for aa in cc :\n",1289" #print(aa.shape, s(aa[0]),len(threshold))\n",1290" \n",1291" paa = s(aa[0]) if sigmoidOK else aa[0].copy()\n",1292" if (paa>=threshold) :\n",1293" try : class1 = s(aa[5:]).argmax() if sigmoidOK else aa[5:].argmax()\n",1294" except : class1 = -1\n",1295" lx4 = s(aa[1:3].copy()) if sigmoidOK else aa[1:3].copy()\n",1296" lx4[0] = lx4[0]*shape_net[1]/scale\n",1297" lx4[1] = lx4[1]*shape_net[0]/scale\n",1298" \n",1299" lx4 = np.clip(lx4,0,(shape_in[1],shape_in[0]))\n",1300" \n",1301" #lx4 = np.round(lx4)[ir]\n",1302" if class1>=0 :\n",1303" pclass = s(aa[5+class1]) if sigmoidOK else aa[5+class1]\n",1304" if pclass<threshold2 : class1=-1\n",1305" #print(class1, pclass)\n",1306" if classesOK :\n",1307" if class1>=0 :\n",1308" label1 = label1+(classes[class1] if class1>=0 else '+X0000')\n",1309" label1 = label1+' '+str(int(lx4[0]))+' '+str(int(lx4[1]))+' '\n",1310" else :\n",1311" label1 = label1+(classes[class1] if class1>=0 else '+X0000')\n",1312" label1 = label1+' '+str(int(lx4[0]))+' '+str(int(lx4[1]))+' '\n",1313" label1 = label1.strip()\n",1314" return(label1)\n",1315"#labels = formSub(ptest, scale_test, threshold=0.5)\n",1316"\n",1317"def formSub1x4 ( pSub1, scale, shape_in, classes, grid_net, anchors_net, delta1,\n",1318" threshold=0.5, threshold2=0.5, classesOK=True, sigmoidOK=True, debug=False,\n",1319" **kwargs) :\n",1320" label1 = ''\n",1321" iCount = 0\n",1322" for ir,rr in enumerate(pSub1) :\n",1323" for ic,cc in enumerate(rr) :\n",1324" for ia,aa in enumerate(cc) :\n",1325" #print(aa.shape, s(aa[0]), threshold)\n",1326" \n",1327" paa = s(aa[0]) if sigmoidOK else aa[0].copy()\n",1328" if (paa>=threshold) :\n",1329" \n",1330" iCount = iCount + 1\n",1331" lx4 = BBxySizeHalf(aa[1:5],ir,ic, anchors_net[ia], scale, grid_net)\n",1332" \n",1333" lx4[0:2] = np.clip(lx4[0:2]+delta1[::-1]/scale,0,shape_in[::-1])\n",1334" \n",1335" class1 = -1\n",1336" try : class1 = softmax(aa[5:]).argmax() if sigmoidOK else aa[5:].argmax()\n",1337" except : class1 = -1\n",1338" if class1>=0 :\n",1339" pclass = s(aa[5+class1]) if sigmoidOK else aa[5+class1].copy()\n",1340" if pclass<threshold2 : class1=-1\n",1341" #print(class1, pclass)\n",1342" if classesOK :\n",1343" if class1>=0 :\n",1344" label1 = label1+(classes[class1] if class1>=0 else '+X0000')\n",1345" #label1 = label1+' '+str(int(lx4[0]))+' '+str(int(lx4[1]))+' '\n",1346" label1 = label1+' {l[0]:d} {l[1]:d} {l[2]:d} {l[3]:d} '.format(l=lx4)\n",1347" else :\n",1348" label1 = label1+(classes[class1] if class1>=0 else '+X0000')\n",1349" #label1 = label1+' '+str(int(lx4[0]))+' '+str(int(lx4[1]))+' '\n",1350" label1 = label1+' {l[0]:d} {l[1]:d} {l[2]:d} {l[3]:d} '.format(l=lx4)\n",1351" #print(aa.shape, s(aa[0]),len(threshold))\n",1352" \n",1353" label1 = label1.strip()\n",1354" \n",1355" if debug : return(label1, iCount)\n",1356" return(label1)\n",1357"#labels = formSub(ptest, scale_test, threshold=0.5)\n",1358"\n",1359"def nms(pSub1, scale, shape_in, anchors_net, grid_net, threshold=0.5, threshold2=0.5, debug=False, printOK=False) :\n",1360" \n",1361" bb1, code = [], 0\n",1362" for ir,rr in enumerate(pSub1) :\n",1363" for ic,cc in enumerate(rr) :\n",1364" for ia,aa in enumerate(cc) :\n",1365" paa = s(aa[0].copy())\n",1366" if (paa>=threshold) :\n",1367" \n",1368" tl,dr = BBxyTLDR(aa[1:5],ir,ic,anchors_net[ia],scale,grid_net,shape_in=shape_in)\n",1369" \n",1370" class1 = -1\n",1371" try : class1 = softmax(aa[5:]).argmax()\n",1372" except : class1 = -1\n",1373" \n",1374" #print(class1, pclass)\n",1375" if class1>=0 :\n",1376" bb1.append([class1,tl[0],tl[1],dr[0],dr[1],ir,ic,ia,1])\n",1377" else :\n",1378" print(class1)\n",1379" \n",1380" #print(len(bb1))\n",1381" bb1 = np.array(bb1);\n",1382" #print(bb1.shape)\n",1383" if len(bb1)>0 :\n",1384" bb1=bb1[bb1[:,0].argsort(),:]\n",1385" for ii in range(len(bb1)) :\n",1386" if bb1[ii,8]>0 :\n",1387" for jj in range(ii+1,len(bb1)) :\n",1388" if bb1[ii,0]!=bb1[jj,0] : break\n",1389" ttll = np.maximum(bb1[ii,1:3],bb1[jj,1:3])\n",1390" ddrr = np.minimum(bb1[ii,3:5],bb1[jj,3:5])\n",1391" if np.min(ddrr-ttll)<0 : break\n",1392" iou1 = (ddrr-ttll)[0]*(ddrr-ttll)[1]\n",1393" iou = iou1/((bb1[ii,3]-bb1[ii,1])*(bb1[ii,4]-bb1[ii,2])+\n",1394" (bb1[jj,3]-bb1[jj,1])*(bb1[jj,4]-bb1[jj,2])-iou1)\n",1395" if printOK :\n",1396" print('---',np.round(bb1[ii,1:5],0),np.round(bb1[jj,1:5],0))\n",1397" print(' ',iou, iou1)\n",1398" if iou>=threshold2 : bb1[jj,8] = 0\n",1399" for jj in range(len(bb1)) :\n",1400" if bb1[jj,8]<=0 :\n",1401" pSub1[int(bb1[jj,5]),int(bb1[jj,6]),int(bb1[jj,7]),0]=-1000 # sigmoid=0\n",1402" code = code+1\n",1403" \n",1404" if debug : return(pSub1,code,bb1)\n",1405" return pSub1\n",1406"\n",1407"def notIOUx12 (tldr1, tldr2, threshold=0.5, printOK=False) :\n",1408" \n",1409" ttll = np.maximum(tldr1[0:2],tldr2[0:2])\n",1410" ddrr = np.minimum(tldr1[2:4],tldr2[2:4])\n",1411"\n",1412" if printOK and False:\n",1413" print('notIOUx12 1',tldr1,tldr2, np.min(ddrr-ttll))\n",1414"\n",1415" if np.min(ddrr-ttll)<=0 : return(True)\n",1416"\n",1417" iou12= (ddrr-ttll)[0]*(ddrr-ttll)[1]\n",1418" size1= (tldr1[2]-tldr1[0])*(tldr1[3]-tldr1[1])\n",1419" size2= (tldr2[2]-tldr2[0])*(tldr2[3]-tldr2[1])\n",1420"\n",1421" if printOK :\n",1422" print('notIOUx12 2',\n",1423" tldr1,tldr2,'\\t' ,\n",1424" iou12, size1, size2, \n",1425" round(iou12/(size2-iou12),4),\n",1426" round(iou12/(size1+size2-iou12),4))\n",1427" \n",1428" if iou12==size2 : return(False)\n",1429" elif (iou12/(size2-iou12))>=threshold : return(False)\n",1430" else :\n",1431" iou = iou12/(size1+size2-iou12)\n",1432" if iou>=threshold : return(False)\n",1433" \n",1434" return(True)\n",1435" \n",1436"\n",1437"def NMSx4(pSub1x4, threshold=0.5, noClass=False, debug=False, printOK=False) :\n",1438" \n",1439" count = 0\n",1440" label1 = ''\n",1441" bb1 = np.array(pSub1x4.split()).reshape((-1,5))\n",1442" uni = bb1[:,0]\n",1443" tldr = bb1[:,1:5].astype(np.int32)\n",1444" mark = np.ones(len(uni)).astype(bool)\n",1445" \n",1446" if noClass : \n",1447" uni = np.ones(len(uni))\n",1448" \n",1449" size = -(tldr[:,2]*tldr[:,3])\n",1450" sort1= size.argsort()\n",1451" uni = uni [sort1]\n",1452" tldr = tldr[sort1,:]\n",1453" \n",1454" if printOK :\n",1455" print(len(tldr))\n",1456" \n",1457" if False :\n",1458" mark = (np.abs(tldr[:,2:]-tldr[:,2:].mean(axis=0))<=2.0*tldr[:,2:].std(axis=0))\n",1459" mark = np.logical_and(mark[:,0],mark[:,1])\n",1460" \n",1461" temp = tldr.astype(np.int32)\n",1462" tldr[:,0:2] = np.floor(temp[:,0:2]-(temp[:,2:4]/2)).astype(np.int32)\n",1463" tldr[:,2:4] = np.ceil (temp[:,0:2]+(temp[:,2:4]/2)).astype(np.int32)\n",1464" \n",1465" if not noClass :\n",1466" sort2 = uni[:].argsort()\n",1467" tldr=tldr[sort2,:]\n",1468" mark=mark[sort2]\n",1469" uni =uni [sort2]\n",1470" \n",1471" if len(uni)==0 :\n",1472" if debug : return(label1,count)\n",1473" return label1\n",1474" \n",1475" for ii in range(len(mark)) :\n",1476" if mark[ii] :\n",1477" for jj in range(ii+1,len(mark)) :\n",1478" if mark[jj] :\n",1479" mark[jj] = notIOUx12(tldr[ii], tldr[jj], threshold=threshold) #, printOK=True)\n",1480" \n",1481" tldr[:,2:4] = tldr[:,2:4]-tldr[:,0:2]\n",1482" tldr[:,0:2] = np.floor(tldr[:,0:2]+tldr[:,2:4]//2).astype(np.int32)\n",1483" \n",1484" for ii in range(len(mark)) :\n",1485" if mark[ii] :\n",1486" label1 = label1 + '{uni} {b[0]:d} {b[1]:d} {b[2]:d} {b[3]:d} '.format(uni=uni[ii], b=tldr[ii])\n",1487" count = count+1\n",1488" \n",1489" label1 = label1.strip()\n",1490" if debug : return(label1,count)\n",1491" return label1"1492]1493},1494{1495"cell_type": "code",1496"execution_count": null,1497"metadata": {},1498"outputs": [],1499"source": []1500},1501{1502"cell_type": "code",1503"execution_count": 29,1504"metadata": {},1505"outputs": [],1506"source": [1507"try : del ptrain\n",1508"except : abc = 1"1509]1510},1511{1512"cell_type": "code",1513"execution_count": 30,1514"metadata": {},1515"outputs": [],1516"source": [1517"from keras.models import load_model\n",1518"\n",1519"def modelLoad (filemodel, customs={}, **kwarg) :\n",1520" model10 = load_model(filemodel,compile=False,custom_objects=customs)\n",1521" return(model10)\n",1522"#model10 = modelLoad('../Temp/best4501.hdf5',customs={'yloss':yloss})\n",1523"#model10 = modelLoad('../Temp/best4500.hdf5',customs={'yloss':yloss}) "1524]1525},1526{1527"cell_type": "code",1528"execution_count": 31,1529"metadata": {},1530"outputs": [1531{1532"data": {1533"text/plain": [1534"(24.31640625, 6527385600, (4150, 1536, 1024, 1))"1535]1536},1537"execution_count": 31,1538"metadata": {},1539"output_type": "execute_result"1540}1541],1542"source": [1543"xtest.nbytes/(1024*1024*1024), xtest.size, xtest.shape"1544]1545},1546{1547"cell_type": "code",1548"execution_count": null,1549"metadata": {},1550"outputs": [],1551"source": []1552},1553{1554"cell_type": "code",1555"execution_count": 32,1556"metadata": {},1557"outputs": [],1558"source": [1559"def yloss (y_true_, y_pred_, sigmoidOK=True, debug=False) :\n",1560" \n",1561" loss = 0.0\n",1562" return loss\n"1563]1564},1565{1566"cell_type": "code",1567"execution_count": 60,1568"metadata": {},1569"outputs": [],1570"source": [1571"def doResult(doList, classes_all, xtest, scale_test, shape_test, anchors_net, grid_net,\n",1572" batch_size, stepClasses=4212,\n",1573" stepLabels=300,\n",1574" debug=False) :\n",1575" pResult = []\n",1576" for i1, fileModel in doList :\n",1577" print(datetime.datetime.now(), i1, fileModel)\n",1578" classes = classes_all[i1:i1+stepClasses]\n",1579" model10 = modelLoad(fileModel,customs={'yloss':yloss});\n",1580" pResult1 = []\n",1581" for i2 in range(0,len(xtest),stepLabels) :\n",1582" \n",1583" print(datetime.datetime.now(), i2)\n",1584" ptest = model10.predict(xtest[i2:i2+stepLabels],batch_size=batch_size)\n",1585" try :\n",1586" pResult1 = pResult1 + formSubx4 ( ptest, \n",1587" scale_test[i2:i2+stepLabels], \n",1588" shape_test[i2:i2+stepLabels], \n",1589" classes, anchors_net, grid_net,\n",1590" [[0,0]]*len(ptest),\n",1591" threshold=0.5, threshold2=0.5, classeOK=True)\n",1592" #except : print('except')\n",1593" finally : del ptest\n",1594" pResult.append(pResult1)\n",1595" if debug : return(pResult, ptest)\n",1596" return(pResult)"1597]1598},1599{1600"cell_type": "code",1601"execution_count": null,1602"metadata": {},1603"outputs": [],1604"source": []1605},1606{1607"cell_type": "code",1608"execution_count": null,1609"metadata": {},1610"outputs": [],1611"source": []1612},1613{1614"cell_type": "code",1615"execution_count": 61,1616"metadata": {},1617"outputs": [],1618"source": [1619"doList = [[0, '../Temp/best_0000x0500xB.hdf5'],\n",1620" [500, '../Temp/best_0500x1000xB.hdf5'],\n",1621" [1000,'../Temp/best_1000x1500xB.hdf5'],\n",1622" [1500,'../Temp/best_1500x2000xB.hdf5'],]\n",1623"\n",1624"#doList = [[0, os.path.join(dirModels,'best_mySoloV3Tinyx4212x1024x768x1xCT1.hdf5')],] # 0.240 45\n",1625"#doList = [[0, os.path.join(dirModels,'best_mySoloV3Tinyx4212x1024x768x1xDT1.hdf5')],] # 0.298 46\n",1626"#doList = [[0, os.path.join(dirModels,'best_mySoloV3Tinyx4212x1024x768x1xET1.hdf5')],] # 0.285 47\n",1627"#doList = [[0, os.path.join(dirModels,'best_mySoloV3Tinyx4212x1536x1024x1xFT1.hdf5')],] # 0.534 48\n",1628"doList = [[0, os.path.join(dirModels,'best_mySoloV3Tinyx4212x1536x1024x1xIT1.hdf5')],] # "1629]1630},1631{1632"cell_type": "code",1633"execution_count": 62,1634"metadata": {},1635"outputs": [1636{1637"name": "stdout",1638"output_type": "stream",1639"text": [1640"2019-08-25 03:46:27.179053 0 ../Model/best_mySoloV3Tinyx4212x1536x1024x1xIT1.hdf5\n",1641"2019-08-25 03:46:28.896054 0\n",1642"2019-08-25 03:47:15.008905 200\n",1643"2019-08-25 03:48:00.691797 400\n",1644"2019-08-25 03:48:46.473637 600\n",1645"2019-08-25 03:49:32.575474 800\n",1646"2019-08-25 03:50:18.342592 1000\n",1647"2019-08-25 03:51:04.232963 1200\n",1648"2019-08-25 03:51:49.948427 1400\n",1649"2019-08-25 03:52:35.791002 1600\n",1650"2019-08-25 03:53:21.665751 1800\n",1651"2019-08-25 03:54:07.469856 2000\n",1652"2019-08-25 03:54:53.282785 2200\n",1653"2019-08-25 03:55:39.201672 2400\n",1654"2019-08-25 03:56:25.270055 2600\n",1655"2019-08-25 03:57:11.184845 2800\n",1656"2019-08-25 03:57:56.836516 3000\n",1657"2019-08-25 03:58:42.661675 3200\n",1658"2019-08-25 03:59:28.558759 3400\n",1659"2019-08-25 04:00:14.452388 3600\n",1660"2019-08-25 04:01:00.382525 3800\n",1661"2019-08-25 04:01:46.075949 4000\n",1662"2019-08-25 04:02:20.616588\n"1663]1664}1665],1666"source": [1667"batch_size = 6\n",1668"results5 = doResult(doList,classes_all,xtest,scale_test,shape_in_test, \n",1669" anchors_net, grid_net, \n",1670" batch_size,\n",1671" stepLabels=200)\n",1672"\n",1673"#results, ptest = doResult(doList,classes_all,xtest,scale_test,shape_in_test, batch_size, debug=True)\n",1674"print(datetime.datetime.now())"1675]1676},1677{1678"cell_type": "code",1679"execution_count": 63,1680"metadata": {},1681"outputs": [],1682"source": [1683"results = []\n",1684"for r1 in results5 :\n",1685" result = []\n",1686" for r2 in r1 :\n",1687" result.append(' '.join([' '.join(l.tolist()) for l in np.array(r2.split()).reshape((-1,5))[:,:3]]))\n",1688" results.append(result)"1689]1690},1691{1692"cell_type": "code",1693"execution_count": 64,1694"metadata": {},1695"outputs": [1696{1697"data": {1698"text/plain": [1699"(1, 4150)"1700]1701},1702"execution_count": 64,1703"metadata": {},1704"output_type": "execute_result"1705}1706],1707"source": [1708"len(results),len(results[0])"1709]1710},1711{1712"cell_type": "code",1713"execution_count": null,1714"metadata": {},1715"outputs": [],1716"source": []1717},1718{1719"cell_type": "code",1720"execution_count": 65,1721"metadata": {1722"scrolled": false1723},1724"outputs": [1725{1726"data": {1727"text/plain": [1728"'U+6B64 278 537 U+306E 434 561 U+3042 624 526 U+3064 814 525 U+304B 1181 551 U+5927 1364 539 U+82B1 1533 546 U+3068 1712 538 U+4F1D 1900 532 U+3068 2063 525 U+3057 633 617 U+706B 998 634 U+3057 1898 651 U+3082 2060 631 U+3053 287 695 U+5C71 1533 682 U+309E 1738 683 U+307C 2068 716 U+3092 451 766 U+3066 625 737 U+306F 794 731 U+305F 985 759 U+306E 1351 774 U+3069 1735 755 U+3092 1887 769 U+3053 637 857 U+3089 794 849 U+305F 983 831 U+3057 1166 849 U+3044 1721 842 U+308A 2055 828 U+5C11 289 898 U+305F 460 933 U+3081 988 913 U+53E4 1351 886 U+306E 1506 913 U+305D 1897 886 U+308A 2055 895 U+3057 639 977 U+3066 792 973 U+304F 986 966 U+3092 1164 968 U+3075 1723 953 U+304C 1910 979 U+3066 281 1025 U+3082 1164 1081 U+4EBA 1718 1079 U+308A 2055 1064 U+3051 453 1118 U+3089 622 1104 U+305F 799 1153 U+6C60 1524 1128 U+3061 2050 1119 U+305F 282 1188 U+3078 622 1213 U+3055 982 1196 U+3066 1156 1198 U+3046 1334 1173 U+3082 1713 1204 U+61F8 1895 1222 U+304B 448 1249 U+304D 619 1293 U+3064 793 1254 U+51FA 1162 1301 U+4F55 1333 1286 U+306B 1526 1263 U+3072 287 1324 U+3072 982 1311 U+8D8A 1165 1329 U+3070 1535 1362 U+307C 1718 1338 U+306E 1887 1354 U+59CB 2048 1340 U+3070 289 1427 U+305D 604 1392 U+3051 983 1422 U+3066 1335 1414 U+3064 1702 1434 U+306A 1882 1440 U+3092 2049 1442 U+3089 601 1498 U+306B 813 1475 U+65E5 1163 1464 U+4E95 1518 1494 U+308A 1702 1483 U+3068 1885 1512 U+308A 290 1551 U+306E 428 1541 U+305F 814 1572 U+308C 981 1539 U+306B 1157 1556 U+5927 1341 1579 U+3057 2047 1558 U+3075 429 1646 U+3064 610 1622 U+3044 1161 1636 U+3057 1711 1640 U+3084 435 1725 U+3051 612 1728 U+3066 800 1711 U+3066 810 1706 U+3068 1159 1725 U+4E8B 1332 1720 U+3068 1891 1684 U+3082 2044 1698 U+3069 996 1768 U+306E 1507 1772 U+3079 2049 1809 U+3046 435 1858 U+308A 798 1833 U+306A 1150 1845 U+3064 284 1919 U+306F 791 1945 U+307F 1149 1934 U+3092 1328 1898 U+3082 1888 1927 U+3066 2046 1927 U+3070 619 1971 U+304F 971 1984 U+307F 1143 1989 U+3092 1512 1991 U+306B 275 2086 U+304C 449 2080 U+3079 619 2093 U+3044 1141 2052 U+304D 793 2141 U+306A 967 2118 U+305F 1138 2113 U+304F 1328 2127 U+304B 1521 2138 U+3057 1877 2142 U+4E09 2047 2151 U+3059 615 2207 U+3057 1147 2235 U+3089 1335 2230 U+308A 1521 2226 U+308B 1882 2231 U+4E09 2045 2207 U+307F 262 2273 U+3066 782 2281 U+65E5 2046 2280 U+308D 264 2390 U+3057 978 2334 U+3066 1134 2377 U+305B 1330 2332 U+3051 1516 2331 U+3057 1880 2352 U+4EBA 2041 2371 U+3066 427 2407 U+308A 609 2435 U+4E0B 1150 2428 U+3089 1333 2450 U+3089 1521 2429 U+3092 270 2519 U+306B 966 2476 U+304D 1511 2533 U+3092 1870 2477 U+306E 2045 2480 U+306B 611 2553 U+308C 978 2561 U+7F6E 1150 2544 U+308C 1334 2565 U+3069 1868 2581 U+307E 2043 2567 U+3092 435 2657 U+306E 798 2641 U+305F 1146 2664 U+3070 1337 2631 U+3093 1527 2661 U+3081 1868 2678 U+308A 794 2741 U+305D 973 2694 U+308A 1342 2704 U+3061 1524 2748 U+5869 246 2810 U+3072 615 2780 U+305A 979 2803 U+524D 1340 2806 U+3059 1877 2808 U+307F 432 2862 U+4EBA 790 2871 U+306C 2034 2845 U+308B 263 2937 U+3044 428 2938 U+3066 611 2914 U+3092 786 2949 U+8A08 985 2921 U+306E 1146 2935 U+307B 1334 2922 U+3066 1514 2925 U+4E5F 1872 2947 U+4E8B 2047 3003'"1729]1730},1731"execution_count": 65,1732"metadata": {},1733"output_type": "execute_result"1734}1735],1736"source": [1737"results[0][35]"1738]1739},1740{1741"cell_type": "code",1742"execution_count": 66,1743"metadata": {},1744"outputs": [],1745"source": [1746"if 0 :\n",1747" print(ptest.shape)\n",1748" aa = s(ptest[...,0])\n",1749" plt.figure(figsize=(15,10))\n",1750" plt.hist(aa[aa>=0.1].ravel(),bins=100)\n",1751" plt.show()"1752]1753},1754{1755"cell_type": "code",1756"execution_count": null,1757"metadata": {},1758"outputs": [],1759"source": []1760},1761{1762"cell_type": "code",1763"execution_count": 67,1764"metadata": {},1765"outputs": [],1766"source": [1767"sizing = np.array([len(ll) for ll in results[0]])"1768]1769},1770{1771"cell_type": "code",1772"execution_count": 68,1773"metadata": {},1774"outputs": [1775{1776"data": {1777"image/png": "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\n",1778"text/plain": [1779"<Figure size 432x288 with 1 Axes>"1780]1781},1782"metadata": {1783"needs_background": "light"1784},1785"output_type": "display_data"1786}1787],1788"source": [1789"plt.plot(sizing[sizing.argsort()]); plt.show()"1790]1791},1792{1793"cell_type": "code",1794"execution_count": null,1795"metadata": {},1796"outputs": [],1797"source": []1798},1799{1800"cell_type": "code",1801"execution_count": 69,1802"metadata": {},1803"outputs": [],1804"source": [1805"#labels = [results[0][ii]+' '+results[1][ii]+' '+results[2][ii]+' '+results[3][ii] for ii in range(len(results[0]))]\n",1806"labels = results[0]"1807]1808},1809{1810"cell_type": "code",1811"execution_count": 70,1812"metadata": {},1813"outputs": [1814{1815"data": {1816"text/plain": [1817"(4150,\n",1818" 'U+3072 108 607 U+77ED 242 612 U+306F 414 612 U+3064 561 595 U+304D 744 619 U+3042 927 631 U+3070 1106 620 U+3069 1267 601 U+3044 1426 595 U+304D 1590 642 U+3053 1742 618 U+306B 1894 635 U+306B 1905 635 U+3068 105 706 U+308C 573 694 U+3066 740 705 U+3082 1257 714 U+3089 1436 667 U+306B 255 729 U+7528 410 738 U+307E 911 733 U+3053 1087 763 U+306B 1253 736 U+305B 1425 757 U+308A 1593 756 U+3068 1891 736 U+53C8 103 854 U+307F 251 846 U+308A 574 829 U+306F 748 826 U+3053 908 843 U+3066 1422 855 U+3089 1888 817 U+6240 413 900 U+3067 762 930 U+305F 909 913 U+3066 1235 892 U+306B 1584 892 U+306F 1890 910 U+516D 102 944 U+5FF5 242 942 U+3078 412 991 U+4E8C 1429 971 U+306F 1586 966 U+308C 1882 987 U+9053 101 1048 U+7D44 248 1068 U+3068 411 1040 U+3061 572 1063 U+3078 908 1031 U+3079 1078 1047 U+306A 1254 1035 U+304B 1424 1035 U+306F 1587 1030 U+53F3 740 1088 U+7533 908 1127 U+3093 1414 1089 U+308B 1585 1120 U+306B 1743 1099 U+3066 1889 1101 U+3057 249 1182 U+7533 414 1209 U+304F 567 1172 U+304D 746 1207 U+3065 1080 1174 U+306E 1408 1203 U+308B 1583 1209 U+3064 1736 1211 U+306E 1890 1213 U+305F 101 1286 U+8A9E 562 1289 U+3055 903 1244 U+304F 1086 1291 U+304B 1578 1232 U+3064 1736 1262 U+3066 250 1312 U+3068 399 1328 U+898B 1383 1327 U+898B 1405 1335 U+306B 1573 1309 U+304B 104 1394 U+305D 255 1383 U+306B 562 1406 U+304B 724 1433 U+3089 908 1427 U+3075 895 1385 U+3068 1077 1403 U+3084 1409 1422 U+307E 1573 1404 U+3066 1723 1378 U+308A 1899 1393 U+3058 111 1496 U+306E 246 1459 U+5165 561 1510 U+308A 1233 1513 U+3055 1570 1507 U+3061 1722 1504 U+3068 1890 1495 U+5FA1 253 1552 U+307C 400 1564 U+306A 743 1554 U+3072 905 1556 U+3068 98 1612 U+3065 255 1651 U+305D 558 1615 U+3075 1056 1601 U+304A 1236 1623 U+3093 1399 1624 U+308A 1578 1624 U+3068 1714 1619 U+3068 88 1702 U+3065 250 1672 U+306B 389 1687 U+3044 907 1723 U+305E 1073 1689 U+3060 250 1769 U+3066 385 1802 U+56FD 717 1792 U+304F 1401 1783 U+305F 1568 1768 U+307E 1707 1754 U+3072 1865 1766 U+305D 86 1828 U+3044 240 1852 U+3051 548 1841 U+308A 892 1831 U+3068 1057 1816 U+304A 1232 1865 U+308B 1568 1870 U+306E 1863 1844 U+5185 379 1927 U+3075 545 1938 U+306B 717 1902 U+309D 1063 1927 U+3092 245 1963 U+304B 894 1972 U+3066 1232 1980 U+6240 1558 1990 U+308D 1706 1975 U+5F62 1859 1985 U+3052 82 2039 U+3081 375 2056 U+3089 558 2033 U+3050 898 2047 U+3072 1059 2030 U+3068 79 2126 U+3075 209 2151 U+3055 379 2140 U+306C 545 2123 U+306F 713 2131 U+3046 892 2152 U+5F8C 1232 2124 U+3031 1406 2125 U+306B 1561 2104 U+307F 1711 2111 U+3048 77 2191 U+3081 381 2227 U+3046 890 2193 U+305B 1550 2199 U+306F 1862 2179 U+3055 76 2286 U+3057 232 2253 U+6D6E 537 2252 U+306A 713 2270 U+3058 905 2258 U+3075 1041 2271 U+307E 1218 2287 U+3093 1554 2287 U+308F 1710 2266 U+308A 1863 2290 U+306C 351 2331 U+4E16 525 2365 U+3084 888 2343 U+3089 1046 2345 U+3057 1724 2375 U+304D 709 2436 U+3060 1223 2417 U+3066 1545 2412 U+3082 1859 2421 U+309D 225 2480 U+304B 1211 2514 U+3057 1394 2476 U+3044 1545 2518 U+3078 57 2554 U+3066 210 2580 U+304F 546 2568 U+3084 713 2544 U+3057 1067 2559 U+309D 1222 2579 U+716E 1698 2546 U+306E 1856 2541 U+5F8C 351 2621 U+304B 1051 2660 U+3092 1557 2624 U+306B 1859 2635 U+3031 559 2685 U+3093 712 2714 U+7533 882 2717 U+304C 1051 2719 U+308B 1218 2682 U+306A 1374 2688 U+306F 1560 2713 U+306B 1698 2689 U+7533 62 2770 U+3064 205 2787 U+4E00 1037 2789 U+3042 1203 2789 U+308B 1365 2771 U+3058 1564 2807 U+3080 1692 2795 U+3042 1850 2761 U+3088 351 2850 U+3068 547 2828 U+3068 713 2834 U+6CE3 1035 2879 U+308C 1368 2870 U+3080 1692 2858 U+308B 1865 2855 U+3055 54 2910 U+304B 215 2936 U+3075 537 2934 U+309D 701 2917 U+306A 862 2956 U+3092 1214 2910 U+306E 1542 2923 U+309D 1860 2919 U+3031 375 2988 U+3072 707 3029 U+308F 1210 2982 U+306E 1373 2989 U+3055 1543 3023 U+3057 1705 2966 U+3075 60 3051 U+3093 1217 3040 U+304E 1378 3047 U+306E 1687 3043 U+306E 1851 3052')"1819]1820},1821"execution_count": 70,1822"metadata": {},1823"output_type": "execute_result"1824}1825],1826"source": [1827"len(labels), labels[0]"1828]1829},1830{1831"cell_type": "code",1832"execution_count": null,1833"metadata": {},1834"outputs": [],1835"source": []1836},1837{1838"cell_type": "code",1839"execution_count": null,1840"metadata": {},1841"outputs": [],1842"source": []1843},1844{1845"cell_type": "code",1846"execution_count": null,1847"metadata": {},1848"outputs": [],1849"source": []1850},1851{1852"cell_type": "code",1853"execution_count": null,1854"metadata": {},1855"outputs": [],1856"source": []1857},1858{1859"cell_type": "code",1860"execution_count": null,1861"metadata": {},1862"outputs": [],1863"source": []1864},1865{1866"cell_type": "code",1867"execution_count": null,1868"metadata": {},1869"outputs": [],1870"source": []1871},1872{1873"cell_type": "code",1874"execution_count": 71,1875"metadata": {},1876"outputs": [],1877"source": [1878"dfTest = pd.DataFrame()\n",1879"dfTest['image_id'] = testFiles\n",1880"dfTest['labels'] = labels"1881]1882},1883{1884"cell_type": "code",1885"execution_count": 72,1886"metadata": {},1887"outputs": [1888{1889"data": {1890"text/html": [1891"<div>\n",1892"<style scoped>\n",1893" .dataframe tbody tr th:only-of-type {\n",1894" vertical-align: middle;\n",1895" }\n",1896"\n",1897" .dataframe tbody tr th {\n",1898" vertical-align: top;\n",1899" }\n",1900"\n",1901" .dataframe thead th {\n",1902" text-align: right;\n",1903" }\n",1904"</style>\n",1905"<table border=\"1\" class=\"dataframe\">\n",1906" <thead>\n",1907" <tr style=\"text-align: right;\">\n",1908" <th></th>\n",1909" <th>image_id</th>\n",1910" <th>labels</th>\n",1911" </tr>\n",1912" </thead>\n",1913" <tbody>\n",1914" <tr>\n",1915" <th>0</th>\n",1916" <td>test_00145af3</td>\n",1917" <td>U+3072 108 607 U+77ED 242 612 U+306F 414 612 U...</td>\n",1918" </tr>\n",1919" <tr>\n",1920" <th>1</th>\n",1921" <td>test_001c37e2</td>\n",1922" <td>U+3082 370 773 U+306E 517 767 U+3070 700 793 U...</td>\n",1923" </tr>\n",1924" <tr>\n",1925" <th>2</th>\n",1926" <td>test_003aa33a</td>\n",1927" <td>U+308C 190 792 U+3092 502 771 U+3057 840 791 U...</td>\n",1928" </tr>\n",1929" <tr>\n",1930" <th>3</th>\n",1931" <td>test_00665e33</td>\n",1932" <td>U+3066 220 544 U+3057 455 544 U+306E 650 543 U...</td>\n",1933" </tr>\n",1934" <tr>\n",1935" <th>4</th>\n",1936" <td>test_006964dc</td>\n",1937" <td>U+3060 157 612 U+68A7 300 609 U+3059 455 594 U...</td>\n",1938" </tr>\n",1939" </tbody>\n",1940"</table>\n",1941"</div>"1942],1943"text/plain": [1944" image_id labels\n",1945"0 test_00145af3 U+3072 108 607 U+77ED 242 612 U+306F 414 612 U...\n",1946"1 test_001c37e2 U+3082 370 773 U+306E 517 767 U+3070 700 793 U...\n",1947"2 test_003aa33a U+308C 190 792 U+3092 502 771 U+3057 840 791 U...\n",1948"3 test_00665e33 U+3066 220 544 U+3057 455 544 U+306E 650 543 U...\n",1949"4 test_006964dc U+3060 157 612 U+68A7 300 609 U+3059 455 594 U..."1950]1951},1952"execution_count": 72,1953"metadata": {},1954"output_type": "execute_result"1955}1956],1957"source": [1958"dfTest.head()"1959]1960},1961{1962"cell_type": "code",1963"execution_count": 73,1964"metadata": {},1965"outputs": [],1966"source": [1967"dirResult = '../Result'\n",1968"dfTest.to_csv(os.path.join(dirResult,'boba-053.csv'), header=True, index=False)"1969]1970},1971{1972"cell_type": "code",1973"execution_count": 74,1974"metadata": {},1975"outputs": [1976{1977"data": {1978"text/plain": [1979"4150"1980]1981},1982"execution_count": 74,1983"metadata": {},1984"output_type": "execute_result"1985}1986],1987"source": [1988"len(dfTest)"1989]1990},1991{1992"cell_type": "code",1993"execution_count": null,1994"metadata": {},1995"outputs": [],1996"source": []1997},1998{1999"cell_type": "code",2000"execution_count": null,2001"metadata": {},2002"outputs": [],2003"source": []2004},2005{2006"cell_type": "code",2007"execution_count": 54,2008"metadata": {},2009"outputs": [],2010"source": [2011"form44 = pd.read_csv(os.path.join(dirResult,'boba-044.csv'))"2012]2013},2014{2015"cell_type": "code",2016"execution_count": 55,2017"metadata": {},2018"outputs": [2019{2020"data": {2021"text/html": [2022"<div>\n",2023"<style scoped>\n",2024" .dataframe tbody tr th:only-of-type {\n",2025" vertical-align: middle;\n",2026" }\n",2027"\n",2028" .dataframe tbody tr th {\n",2029" vertical-align: top;\n",2030" }\n",2031"\n",2032" .dataframe thead th {\n",2033" text-align: right;\n",2034" }\n",2035"</style>\n",2036"<table border=\"1\" class=\"dataframe\">\n",2037" <thead>\n",2038" <tr style=\"text-align: right;\">\n",2039" <th></th>\n",2040" <th>image_id</th>\n",2041" <th>labels</th>\n",2042" </tr>\n",2043" </thead>\n",2044" <tbody>\n",2045" <tr>\n",2046" <th>0</th>\n",2047" <td>test_00145af3</td>\n",2048" <td>U+3072 95 598 U+306F 406 635 U+3064 568 577 U+...</td>\n",2049" </tr>\n",2050" <tr>\n",2051" <th>1</th>\n",2052" <td>test_001c37e2</td>\n",2053" <td>U+4E0A 218 796 U+3068 384 792 U+306E 518 785 U...</td>\n",2054" </tr>\n",2055" <tr>\n",2056" <th>2</th>\n",2057" <td>test_003aa33a</td>\n",2058" <td>U+3068 184 786 U+308A 345 777 U+306A 516 759 U...</td>\n",2059" </tr>\n",2060" <tr>\n",2061" <th>3</th>\n",2062" <td>test_00665e33</td>\n",2063" <td>U+3082 220 565 U+304B 220 573 U+306F 469 556 U...</td>\n",2064" </tr>\n",2065" <tr>\n",2066" <th>4</th>\n",2067" <td>test_006964dc</td>\n",2068" <td>U+7389 167 592 U+6B64 309 619 U+3084 635 577 U...</td>\n",2069" </tr>\n",2070" </tbody>\n",2071"</table>\n",2072"</div>"2073],2074"text/plain": [2075" image_id labels\n",2076"0 test_00145af3 U+3072 95 598 U+306F 406 635 U+3064 568 577 U+...\n",2077"1 test_001c37e2 U+4E0A 218 796 U+3068 384 792 U+306E 518 785 U...\n",2078"2 test_003aa33a U+3068 184 786 U+308A 345 777 U+306A 516 759 U...\n",2079"3 test_00665e33 U+3082 220 565 U+304B 220 573 U+306F 469 556 U...\n",2080"4 test_006964dc U+7389 167 592 U+6B64 309 619 U+3084 635 577 U..."2081]2082},2083"execution_count": 55,2084"metadata": {},2085"output_type": "execute_result"2086}2087],2088"source": [2089"form44.head()"2090]2091},2092{2093"cell_type": "code",2094"execution_count": 56,2095"metadata": {},2096"outputs": [],2097"source": [2098"form42 = pd.read_csv(os.path.join(dirResult,'boba-042.csv'))"2099]2100},2101{2102"cell_type": "code",2103"execution_count": 57,2104"metadata": {},2105"outputs": [2106{2107"data": {2108"text/html": [2109"<div>\n",2110"<style scoped>\n",2111" .dataframe tbody tr th:only-of-type {\n",2112" vertical-align: middle;\n",2113" }\n",2114"\n",2115" .dataframe tbody tr th {\n",2116" vertical-align: top;\n",2117" }\n",2118"\n",2119" .dataframe thead th {\n",2120" text-align: right;\n",2121" }\n",2122"</style>\n",2123"<table border=\"1\" class=\"dataframe\">\n",2124" <thead>\n",2125" <tr style=\"text-align: right;\">\n",2126" <th></th>\n",2127" <th>image_id</th>\n",2128" <th>labels</th>\n",2129" </tr>\n",2130" </thead>\n",2131" <tbody>\n",2132" <tr>\n",2133" <th>0</th>\n",2134" <td>test_00145af3</td>\n",2135" <td>U+3072 100 627 U+306F 412 619 U+3055 752 594 U...</td>\n",2136" </tr>\n",2137" <tr>\n",2138" <th>1</th>\n",2139" <td>test_001c37e2</td>\n",2140" <td>U+751F 215 789 U+3068 382 789 U+306E 525 784 U...</td>\n",2141" </tr>\n",2142" <tr>\n",2143" <th>2</th>\n",2144" <td>test_003aa33a</td>\n",2145" <td>U+76EE 199 788 U+3082 352 787 U+5225 653 779 U...</td>\n",2146" </tr>\n",2147" <tr>\n",2148" <th>3</th>\n",2149" <td>test_00665e33</td>\n",2150" <td>U+3057 351 563 U+3068 502 584 U+5927 637 553 U...</td>\n",2151" </tr>\n",2152" <tr>\n",2153" <th>4</th>\n",2154" <td>test_006964dc</td>\n",2155" <td>U+51FA 162 619 U+3068 456 597 U+3084 628 567 U...</td>\n",2156" </tr>\n",2157" </tbody>\n",2158"</table>\n",2159"</div>"2160],2161"text/plain": [2162" image_id labels\n",2163"0 test_00145af3 U+3072 100 627 U+306F 412 619 U+3055 752 594 U...\n",2164"1 test_001c37e2 U+751F 215 789 U+3068 382 789 U+306E 525 784 U...\n",2165"2 test_003aa33a U+76EE 199 788 U+3082 352 787 U+5225 653 779 U...\n",2166"3 test_00665e33 U+3057 351 563 U+3068 502 584 U+5927 637 553 U...\n",2167"4 test_006964dc U+51FA 162 619 U+3068 456 597 U+3084 628 567 U..."2168]2169},2170"execution_count": 57,2171"metadata": {},2172"output_type": "execute_result"2173}2174],2175"source": [2176"form42.head()"2177]2178},2179{2180"cell_type": "code",2181"execution_count": 86,2182"metadata": {},2183"outputs": [2184{2185"data": {2186"image/png": "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\n",2187"text/plain": [2188"<Figure size 432x288 with 1 Axes>"2189]2190},2191"metadata": {2192"needs_background": "light"2193},2194"output_type": "display_data"2195}2196],2197"source": [2198"labels = [form42.labels[ii] for ii in range(len(form42))]\n",2199"plt.hist([len(str(l1))-len(str(l2)) for l1,l2 in zip(form42.labels,form44.labels)],bins=50); \n",2200"plt.show()"2201]2202},2203{2204"cell_type": "code",2205"execution_count": 73,2206"metadata": {},2207"outputs": [2208{2209"data": {2210"text/plain": [2211"(image_id object\n",2212" labels object\n",2213" dtype: object, 4150)"2214]2215},2216"execution_count": 73,2217"metadata": {},2218"output_type": "execute_result"2219}2220],2221"source": [2222"form42.dtypes, len(form42)"2223]2224},2225{2226"cell_type": "code",2227"execution_count": 80,2228"metadata": {},2229"outputs": [2230{2231"data": {2232"text/plain": [2233"4038"2234]2235},2236"execution_count": 80,2237"metadata": {},2238"output_type": "execute_result"2239}2240],2241"source": [2242"len(labels[0])"2243]2244}2245],2246"metadata": {2247"kernelspec": {2248"display_name": "Python 3",2249"language": "python",2250"name": "python3"2251},2252"language_info": {2253"codemirror_mode": {2254"name": "ipython",2255"version": 32256},2257"file_extension": ".py",2258"mimetype": "text/x-python",2259"name": "python",2260"nbconvert_exporter": "python",2261"pygments_lexer": "ipython3",2262"version": "3.6.6"2263}2264},2265"nbformat": 4,2266"nbformat_minor": 22267}2268