हम सड़क गुणवत्ता द्वारा रूसी शहरों की रेटिंग बनाते हैं

एक बार फिर, अपने गृहनगर के आसपास एक कार चलाकर और दूसरे गड्ढे के आसपास जाते हुए, मैंने सोचा: क्या हमारे देश में हर जगह ऐसी "अच्छी" सड़कें मौजूद हैं और मैंने फैसला किया है कि हमें अपने देश की सड़कों की गुणवत्ता के साथ निष्पक्ष रूप से स्थिति का आकलन करना चाहिए।

कार्य औपचारिकता

रूस में, सड़कों की गुणवत्ता के लिए आवश्यकताओं को GOST R 50597-2017 "सड़कों और सड़कों में वर्णित किया गया है। सड़क सुरक्षा सुनिश्चित करने की शर्तों के तहत स्वीकार्य परिचालन राज्य के लिए आवश्यकताएँ। नियंत्रण के तरीके। " यह दस्तावेज़ कैरिजवे, रोडसाइड, डिवाइडिंग स्ट्रिप्स, फुटपाथ, पैदल यात्री मार्ग, आदि को कवर करने के लिए आवश्यकताओं को परिभाषित करता है, और क्षति के प्रकारों को भी निर्धारित करता है।

चूंकि सड़कों के सभी मापदंडों को निर्धारित करने का कार्य काफी व्यापक है, इसलिए मैंने इसे अपने लिए संकीर्ण करने का निर्णय लिया और केवल सड़क मार्ग के कवरेज में दोषों के निर्धारण की समस्या पर ध्यान केंद्रित किया। GOST R 50597-2017 सड़क मार्ग की कोटिंग में निम्नलिखित दोषों को अलग करता है:

• गड्ढे
• उल्लंघनों
• घटाव
• बदलाव
• कंघी
• ट्रैक
• पसीना आना बांधने की मशीन

मैंने इन दोषों से निपटने का फैसला किया।

डेटा संग्रह

मुझे ऐसी तस्वीरें कहाँ मिल सकती हैं जो सड़क के बड़े हिस्से को दर्शाती हैं, और यहां तक ​​कि जियोलोकेशन के संदर्भ में भी? जवाब स्फटिकों में आया - यांडेक्स (या Google) के नक्शे पर पैनोरमा, हालांकि, थोड़ी खोज के बाद, मुझे कई और वैकल्पिक विकल्प मिले:

• प्रासंगिक अनुरोधों के लिए चित्रों के लिए खोज इंजन जारी करना;
• शिकायतें प्राप्त करने के लिए साइटों पर तस्वीरें (रोश्यामा, गुस्से में नागरिक, पुण्य, आदि)
• Opendatascience ने एक चिह्नित डेटासेट के साथ सड़क दोष का पता लगाने के लिए एक परियोजना को प्रेरित किया - github.com/sekilab/RoadDamageDetector

दुर्भाग्य से, इन विकल्पों के विश्लेषण से पता चला कि वे मेरे लिए बहुत उपयुक्त नहीं हैं: खोज इंजन जारी करने से बहुत शोर होता है (बहुत सारी तस्वीरें जो सड़क नहीं हैं, विभिन्न रेंडर, आदि), शिकायतें प्राप्त करने के लिए साइटों से प्राप्त तस्वीरों में केवल डामर की सतह के बड़े उल्लंघन के साथ तस्वीरें हैं। , कवरेज की थोड़ी सी भी उल्लंघन के साथ और इन साइटों पर उल्लंघन के बिना काफी कम तस्वीरें हैं, रोडडैमेजडेक्टर परियोजना से डेटासेट जापान में एकत्र किया गया है और इसमें कवरेज के बड़े उल्लंघन के साथ नमूने शामिल नहीं हैं, साथ ही बिना कवरेज के सड़कें भी हैं।

चूंकि वैकल्पिक विकल्प उपयुक्त नहीं हैं, हम यैंडेक्स पैनोरामा का उपयोग करेंगे (मैंने Google पैनोरमा विकल्प को बाहर रखा है, क्योंकि रूस में कम शहरों में सेवा प्रस्तुत की जाती है और इसे कम बार अद्यतन किया जाता है)। उन्होंने 100 हजार से अधिक लोगों की आबादी के साथ-साथ संघीय केंद्रों में शहरों में डेटा एकत्र करने का निर्णय लिया। मैंने शहर के नामों की एक सूची बनाई - उनमें से 176 थे, बाद में यह पता चला कि उनमें से केवल 149 में पैनोरमा है। मैं पार्सिंग टाइलों की सुविधाओं में तल्लीन नहीं करूंगा, मैं कहूंगा कि अंत में मुझे 149 फ़ोल्डर्स (प्रत्येक शहर के लिए एक) मिला जिसमें कुल 1.7 मिलियन तस्वीरें थीं। उदाहरण के लिए, नोवोकुज़नेट्सक के लिए, फ़ोल्डर इस तरह दिखता था:



डाउनलोड की गई तस्वीरों की संख्या से, शहरों को निम्नानुसार वितरित किया गया था:

प्रशिक्षण के लिए डेटासेट तैयार करना

और इसलिए, डेटासेट इकट्ठे हुए हैं, अब कैसे, सड़क खंड और संलग्न वस्तुओं की एक तस्वीर होने पर, उस पर चित्रित डामर की गुणवत्ता का पता लगाएं? मैंने मध्य के ठीक नीचे मूल फ़ोटो के केंद्र में 350 * 244 पिक्सेल मापने वाले फ़ोटो के एक टुकड़े को काटने का फैसला किया। फिर कटे हुए टुकड़े को क्षैतिज रूप से 244 पिक्सेल के आकार तक कम करें। परिणामी छवि (244 * 244 आकार में) इनोवेटिव एनकोडर के लिए इनपुट होगी:



बेहतर तरीके से समझने के लिए कि मैं किस डेटा के साथ काम करता हूं, पहले 2000 चित्रों को मैंने खुद चिह्नित किया था, बाकी चित्रों को Yandex.Tolki कर्मचारियों द्वारा चिह्नित किया गया था। उनसे पहले मैंने निम्नलिखित शब्दों में एक प्रश्न प्रस्तुत किया था।

फोटो में आपको कौन सी सड़क की सतह दिखती है:

1. मिट्टी / मलबे
2. फ़र्श पत्थर, टाइल, फुटपाथ
3. रेल, रेल की पटरियाँ
4. पानी, बड़े पोखर
5. डामर
6. फोटो में कोई सड़क नहीं है / विदेशी वस्तुएं / कवरेज कारों के कारण दिखाई नहीं देती है

यदि कलाकार ने "डामर" चुना, तो एक मेनू दिखाई दिया जो इसकी गुणवत्ता का मूल्यांकन करने की पेशकश करता है:

1. उत्कृष्ट कवरेज
2. थोड़ा एकल दरारें / उथले एकल गड्ढे
3. बड़ी दरारें / ग्रिड दरारें / एकल मामूली गड्ढे
4. बड़े गड्ढे / गहरे गड्ढे / नष्ट किए गए लेप

दिखाए गए कार्यों के परीक्षण रन के रूप में, वाई टोलोकी निष्पादक कार्य की अखंडता में भिन्न नहीं होते हैं - वे गलती से माउस के साथ खेतों पर क्लिक करते हैं और कार्य को पूरा करने पर विचार करते हैं। मुझे नियंत्रण प्रश्न जोड़ना था (असाइनमेंट में 46 तस्वीरें थीं, जिनमें से 12 नियंत्रण थीं) और विलंबित स्वीकृति को सक्षम करना था। नियंत्रण प्रश्नों के रूप में, मैंने उन चित्रों का उपयोग किया जिन्हें मैंने स्वयं चिह्नित किया था। मैंने विलंबित स्वीकृति को स्वचालित कर दिया - Y. Toloka आपको कार्य के परिणाम CSV फ़ाइल पर अपलोड करने, और प्रतिक्रियाओं के सत्यापन के परिणामों को लोड करने की अनुमति देता है। जवाबों का सत्यापन निम्नानुसार किया गया है - यदि कार्य में प्रश्नों को नियंत्रित करने के लिए 5% से अधिक गलत उत्तर हैं, तो इसे अधूरा माना जाता है। इसके अलावा, यदि ठेकेदार ने एक उत्तर इंगित किया है जो तार्किक रूप से सत्य के करीब है, तो उसका उत्तर सही माना जाता है।
नतीजतन, मुझे लगभग 30 हजार टैग किए गए फोटो मिले, जिन्हें मैंने प्रशिक्षण के लिए तीन वर्गों में वितरित करने का फैसला किया:

• "अच्छा" - "डामर: उत्कृष्ट कोटिंग" और "डामर: मामूली एकल दरारें" लेबल वाली तस्वीरें
• "मध्य" - "पत्थर, टाइल्स, फुटपाथ", "रेल, रेलवे ट्रैक" और "डामर: बड़ी दरारें / ग्रिड दरारें / एकल माइनर डेंट" लेबल वाली तस्वीरें
• "बड़े" - "मिट्टी / कुचल पत्थर", "पानी, बड़े पोखर" और "डामर" लेबल वाली तस्वीरें: बड़ी संख्या में गड्ढे / गहरे गड्ढे / नष्ट फुटपाथ "
• टैग की गई तस्वीरें "फोटो में कोई सड़क नहीं है / विदेशी वस्तुएं / कवरेज कारों के कारण दिखाई नहीं दे रही है" बहुत (22 पीसी) थे और मैंने उन्हें आगे के काम से बाहर रखा।

क्लासिफायर विकास और प्रशिक्षण

इसलिए, डेटा एकत्र और लेबल किया जाता है, हम क्लासिफायरियर के विकास के लिए आगे बढ़ते हैं। आमतौर पर, छवि वर्गीकरण के कार्यों के लिए, विशेष रूप से जब छोटे डेटासेट पर प्रशिक्षण होता है, तो एक तैयार-किए गए दृढ़ एनकोडर का उपयोग किया जाता है, जिसके आउटपुट में एक नया क्लासिफायर जुड़ा होता है। मैंने एक छिपी हुई परत के बिना एक साधारण क्लासिफायर का उपयोग करने का फैसला किया, आकार की एक इनपुट परत 128 और आकार की एक आउटपुट परत 3. मैंने तुरंत इमेजनेट पर प्रशिक्षित कई तैयार विकल्पों का उपयोग करने का फैसला किया, जो एनकोडर के रूप में हैं:

• Xception
• Resnet
• आरंभ
• Vgg16
• Densenet121
• Mobilenet

यहाँ फ़ंक्शन है जो दिए गए एनकोडर के साथ केरस मॉडल बनाता है:

def createModel(typeModel): conv_base = None if(typeModel == "nasnet"): conv_base = keras.applications.nasnet.NASNetMobile(include_top=False, input_shape=(224,224,3), weights='imagenet') if(typeModel == "xception"): conv_base = keras.applications.xception.Xception(include_top=False, input_shape=(224,224,3), weights='imagenet') if(typeModel == "resnet"): conv_base = keras.applications.resnet50.ResNet50(include_top=False, input_shape=(224,224,3), weights='imagenet') if(typeModel == "inception"): conv_base = keras.applications.inception_v3.InceptionV3(include_top=False, input_shape=(224,224,3), weights='imagenet') if(typeModel == "densenet121"): conv_base = keras.applications.densenet.DenseNet121(include_top=False, input_shape=(224,224,3), weights='imagenet') if(typeModel == "mobilenet"): conv_base = keras.applications.mobilenet_v2.MobileNetV2(include_top=False, input_shape=(224,224,3), weights='imagenet') if(typeModel == "vgg16"): conv_base = keras.applications.vgg16.VGG16(include_top=False, input_shape=(224,224,3), weights='imagenet') conv_base.trainable = False model = Sequential() model.add(conv_base) model.add(Flatten()) model.add(Dense(128, activation='relu', kernel_regularizer=regularizers.l2(0.0002))) model.add(Dropout(0.3)) model.add(Dense(3, activation='softmax')) model.compile(optimizer=keras.optimizers.Adam(lr=1e-4), loss='binary_crossentropy', metrics=['accuracy']) return model 

प्रशिक्षण के लिए, मैंने वृद्धि के साथ एक जनरेटर का उपयोग किया (क्योंकि केरस में निर्मित वृद्धि की संभावनाएं मुझे अपर्याप्त लग रही थीं , तब मैंने ऑगमेंटोर लाइब्रेरी का उपयोग किया):

• ढलानों
• यादृच्छिक विकृति
• रोटेशन
• रंग स्वैप
• बदलाव
• विपरीत और चमक बदलें
• यादृच्छिक शोर जोड़ना
• छिड़कना

वृद्धि के बाद, तस्वीरें इस तरह दिखती हैं:



जनरेटर कोड:

 def get_datagen(): train_dir='~/data/train_img' test_dir='~/data/test_img' testDataGen = ImageDataGenerator(rescale=1. / 255) train_generator = datagen.flow_from_directory( train_dir, target_size=img_size, batch_size=16, class_mode='categorical') p = Augmentor.Pipeline(train_dir) p.skew(probability=0.9) p.random_distortion(probability=0.9,grid_width=3,grid_height=3,magnitude=8) p.rotate(probability=0.9, max_left_rotation=5, max_right_rotation=5) p.random_color(probability=0.7, min_factor=0.8, max_factor=1) p.flip_left_right(probability=0.7) p.random_brightness(probability=0.7, min_factor=0.8, max_factor=1.2) p.random_contrast(probability=0.5, min_factor=0.9, max_factor=1) p.random_erasing(probability=1,rectangle_area=0.2) p.crop_by_size(probability=1, width=244, height=244, centre=True) train_generator = keras_generator(p,batch_size=16) test_generator = testDataGen.flow_from_directory( test_dir, target_size=img_size, batch_size=32, class_mode='categorical') return (train_generator, test_generator) 

कोड दर्शाता है कि परीक्षण डेटा के लिए वृद्धि का उपयोग नहीं किया गया है।

एक ट्यून किए गए जनरेटर के बाद, आप मॉडल को प्रशिक्षित करना शुरू कर सकते हैं, हम इसे दो चरणों में पूरा करेंगे: पहला, केवल हमारे क्लासिफायरियर को प्रशिक्षित करें, फिर पूरी तरह से पूरे मॉडल को।

 def evalModelstep1(typeModel): K.clear_session() gc.collect() model=createModel(typeModel) traiGen,testGen=getDatagen() model.fit_generator(generator=traiGen, epochs=4, steps_per_epoch=30000/16, validation_steps=len(testGen), validation_data=testGen, ) return model def evalModelstep2(model): early_stopping_callback = EarlyStopping(monitor='val_loss', patience=3) model.layers[0].trainable=True model.trainable=True model.compile(optimizer=keras.optimizers.Adam(lr=1e-5), loss='binary_crossentropy', metrics=['accuracy']) traiGen,testGen=getDatagen() model.fit_generator(generator=traiGen, epochs=25, steps_per_epoch=30000/16, validation_steps=len(testGen), validation_data=testGen, callbacks=[early_stopping_callback] ) return model def full_fit(): model_names=[ "xception", "resnet", "inception", "vgg16", "densenet121", "mobilenet" ] for model_name in model_names: print("#########################################") print("#########################################") print("#########################################") print(model_name) print("#########################################") print("#########################################") print("#########################################") model = evalModelstep1(model_name) model = evalModelstep2(model) model.save("~/data/models/model_new_"+str(model_name)+".h5") 

Full_fit () पर कॉल करें और प्रतीक्षा करें। हम लंबे समय से इंतजार कर रहे हैं।

परिणामस्वरूप, हमारे पास छह प्रशिक्षित मॉडल होंगे, हम लेबल किए गए डेटा के एक अलग हिस्से पर इन मॉडलों की सटीकता की जांच करेंगे;

मॉडल का नाम	शुद्धता%
Xception	87.3
Resnet	90.8
आरंभ	90.2
Vgg16	89.2
Densenet121	90.6
Mobilenet	86.5

सामान्य तौर पर, बहुत कुछ नहीं, लेकिन इस तरह के एक छोटे से प्रशिक्षण नमूने के साथ, कोई भी अधिक उम्मीद नहीं कर सकता है। सटीकता को थोड़ा बढ़ाने के लिए, मैंने औसत से मॉडल के आउटपुट को संयुक्त किया:

 def create_meta_model(): model_names=[ "xception", "resnet", "inception", "vgg16", "densenet121", "mobilenet" ] model_input = Input(shape=(244,244,3)) submodels=[] i=0; for model_name in model_names: filename= "~/data/models/model_new_"+str(model_name)+".h5" submodel = keras.models.load_model(filename) submodel.name = model_name+"_"+str(i) i+=1 submodels.append(submodel(model_input)) out=average(submodels) model = Model(inputs = model_input,outputs=out) model.compile(optimizer=keras.optimizers.Adam(lr=1e-4), loss='binary_crossentropy', metrics=['accuracy']) return model 

परिणामी सटीकता 91.3% थी। इस परिणाम पर, मैंने रुकने का फैसला किया।

क्लासिफायर का उपयोग करना

अंत में क्लासिफ़ायर तैयार है और इसे कार्रवाई में डाला जा सकता है! मैं इनपुट डेटा तैयार करता हूं और क्लासिफायर को चलाता हूं - एक दिन से थोड़ा अधिक और 1.7 मिलियन तस्वीरों को संसाधित किया गया है। अब मजेदार हिस्सा परिणाम है। अच्छे कवरेज वाले सड़कों की सापेक्ष संख्या में पहले और अंतिम दस शहरों को तुरंत लाएँ:





और यहाँ संघीय विषयों द्वारा सड़क की गुणवत्ता रेटिंग है:




संघीय जिलों द्वारा रेटिंग:



एक पूरे के रूप में रूस में सड़क की गुणवत्ता का वितरण:



खैर, यह सब, हर कोई खुद निष्कर्ष निकाल सकता है।

अंत में, मैं प्रत्येक श्रेणी में सबसे अच्छी तस्वीरें दूंगा (जिन्हें उनकी कक्षा में अधिकतम मूल्य प्राप्त हुआ):



पीएस ने टिप्पणियों में सही तरीके से तस्वीरों की प्राप्ति के वर्षों के आंकड़ों की कमी को इंगित किया। मैं सही करता हूं और एक तालिका देता हूं:

साल	फ़ोटो की संख्या, पीसी
2008	37
2009	13
2010	157,030
2011	60,724
2012	42,387
2013	12148
2014	141,021
2015	46143
2016	410,385
2017	324,279
2018	581,961