From 917b3fb1fc4185e1f2d8889019fc32ca45f73bb8 Mon Sep 17 00:00:00 2001 From: norangebit Date: Thu, 10 Jun 2021 12:24:09 +0200 Subject: [PATCH 1/3] Add introduction --- bibliography.bib | 165 +++++++++++++++++++++++++++++++++++++++++++++- src/chapter_1.md | 34 ++++++++++ src/metadata.yaml | 10 +++ 3 files changed, 208 insertions(+), 1 deletion(-) create mode 100644 src/chapter_1.md diff --git a/bibliography.bib b/bibliography.bib index ad0e342..1f508c5 100644 --- a/bibliography.bib +++ b/bibliography.bib @@ -106,6 +106,18 @@ langid = {english} } +@inproceedings{chen2015deepdrivinglearningaffordance, + title = {{{DeepDriving}}: {{Learning Affordance}} for {{Direct Perception}} in {{Autonomous Driving}}}, + shorttitle = {{{DeepDriving}}}, + author = {Chen, Chenyi and Seff, Ari and Kornhauser, Alain and Xiao, Jianxiong}, + date = {2015}, + pages = {2722--2730}, + url = {https://openaccess.thecvf.com/content_iccv_2015/html/Chen_DeepDriving_Learning_Affordance_ICCV_2015_paper.html}, + urldate = {2021-06-09}, + eventtitle = {Proceedings of the {{IEEE International Conference}} on {{Computer Vision}}}, + file = {/home/norangebit/Documenti/10-personal/12-organizzation/06-zotero/storage/4ZE2KTJC/Chen_DeepDriving_Learning_Affordance_ICCV_2015_paper.html} +} + @article{deboom2016representationlearningvery, title = {Representation Learning for Very Short Texts Using Weighted Word Embedding Aggregation}, author = {De Boom, Cedric and Van Canneyt, Steven and Demeester, Thomas and Dhoedt, Bart}, @@ -235,6 +247,22 @@ number = {4} } +@online{hannun2014deepspeechscaling, + title = {Deep {{Speech}}: {{Scaling}} up End-to-End Speech Recognition}, + shorttitle = {Deep {{Speech}}}, + author = {Hannun, Awni and Case, Carl and Casper, Jared and Catanzaro, Bryan and Diamos, Greg and Elsen, Erich and Prenger, Ryan and Satheesh, Sanjeev and Sengupta, Shubho and Coates, Adam and Ng, Andrew Y.}, + date = {2014-12-19}, + url = {http://arxiv.org/abs/1412.5567}, + urldate = {2021-06-09}, + abstract = {We present a state-of-the-art speech recognition system developed using end-to-end deep learning. Our architecture is significantly simpler than traditional speech systems, which rely on laboriously engineered processing pipelines; these traditional systems also tend to perform poorly when used in noisy environments. In contrast, our system does not need hand-designed components to model background noise, reverberation, or speaker variation, but instead directly learns a function that is robust to such effects. We do not need a phoneme dictionary, nor even the concept of a "phoneme." Key to our approach is a well-optimized RNN training system that uses multiple GPUs, as well as a set of novel data synthesis techniques that allow us to efficiently obtain a large amount of varied data for training. Our system, called Deep Speech, outperforms previously published results on the widely studied Switchboard Hub5'00, achieving 16.0\% error on the full test set. Deep Speech also handles challenging noisy environments better than widely used, state-of-the-art commercial speech systems.}, + archiveprefix = {arXiv}, + eprint = {1412.5567}, + eprinttype = {arxiv}, + file = {/home/norangebit/Documenti/10-personal/12-organizzation/07-zotero-attachments/undefined/Hannun_2014_Deep Speech.pdf;/home/norangebit/Documenti/10-personal/12-organizzation/06-zotero/storage/JH3YQS9Z/1412.html}, + keywords = {Computer Science - Computation and Language,Computer Science - Machine Learning,Computer Science - Neural and Evolutionary Computing}, + primaryclass = {cs} +} + @book{harrington2012machinelearningaction, title = {Machine {{Learning}} in {{Action}}}, author = {Harrington, Peter}, @@ -264,6 +292,35 @@ langid = {english} } +@inproceedings{he2016deepresiduallearning, + title = {Deep {{Residual Learning}} for {{Image Recognition}}}, + author = {He, Kaiming and Zhang, Xiangyu and Ren, Shaoqing and Sun, Jian}, + date = {2016}, + pages = {770--778}, + url = {https://openaccess.thecvf.com/content_cvpr_2016/html/He_Deep_Residual_Learning_CVPR_2016_paper.html}, + urldate = {2021-06-09}, + eventtitle = {Proceedings of the {{IEEE Conference}} on {{Computer Vision}} and {{Pattern Recognition}}}, + file = {/home/norangebit/Documenti/10-personal/12-organizzation/06-zotero/storage/B6WAY3GX/He_Deep_Residual_Learning_CVPR_2016_paper.html} +} + +@article{hirschberg2015advancesnaturallanguage, + title = {Advances in Natural Language Processing}, + author = {Hirschberg, Julia and Manning, Christopher D.}, + date = {2015-07-17}, + journaltitle = {Science}, + volume = {349}, + pages = {261--266}, + publisher = {{American Association for the Advancement of Science}}, + issn = {0036-8075, 1095-9203}, + doi = {10.1126/science.aaa8685}, + abstract = {Natural language processing employs computational techniques for the purpose of learning, understanding, and producing human language content. Early computational approaches to language research focused on automating the analysis of the linguistic structure of language and developing basic technologies such as machine translation, speech recognition, and speech synthesis. Today's researchers refine and make use of such tools in real-world applications, creating spoken dialogue systems and speech-to-speech translation engines, mining social media for information about health or finance, and identifying sentiment and emotion toward products and services. We describe successes and challenges in this rapidly advancing area.}, + eprint = {26185244}, + eprinttype = {pmid}, + file = {/home/norangebit/Documenti/10-personal/12-organizzation/06-zotero/storage/Z36CCHGE/261.html}, + langid = {english}, + number = {6245} +} + @online{humbatova-2019-taxonomyrealfaults, title = {Taxonomy of {{Real Faults}} in {{Deep Learning Systems}}}, author = {Humbatova, Nargiz and Jahangirova, Gunel and Bavota, Gabriele and Riccio, Vincenzo and Stocco, Andrea and Tonella, Paolo}, @@ -280,6 +337,40 @@ primaryclass = {cs} } +@online{huval2015empiricalevaluationdeep, + title = {An {{Empirical Evaluation}} of {{Deep Learning}} on {{Highway Driving}}}, + author = {Huval, Brody and Wang, Tao and Tandon, Sameep and Kiske, Jeff and Song, Will and Pazhayampallil, Joel and Andriluka, Mykhaylo and Rajpurkar, Pranav and Migimatsu, Toki and Cheng-Yue, Royce and Mujica, Fernando and Coates, Adam and Ng, Andrew Y.}, + date = {2015-04-16}, + url = {http://arxiv.org/abs/1504.01716}, + urldate = {2021-06-09}, + abstract = {Numerous groups have applied a variety of deep learning techniques to computer vision problems in highway perception scenarios. In this paper, we presented a number of empirical evaluations of recent deep learning advances. Computer vision, combined with deep learning, has the potential to bring about a relatively inexpensive, robust solution to autonomous driving. To prepare deep learning for industry uptake and practical applications, neural networks will require large data sets that represent all possible driving environments and scenarios. We collect a large data set of highway data and apply deep learning and computer vision algorithms to problems such as car and lane detection. We show how existing convolutional neural networks (CNNs) can be used to perform lane and vehicle detection while running at frame rates required for a real-time system. Our results lend credence to the hypothesis that deep learning holds promise for autonomous driving.}, + archiveprefix = {arXiv}, + eprint = {1504.01716}, + eprinttype = {arxiv}, + file = {/home/norangebit/Documenti/10-personal/12-organizzation/06-zotero/storage/F6WDYMDF/1504.html}, + keywords = {Computer Science - Computer Vision and Pattern Recognition,Computer Science - Robotics}, + primaryclass = {cs} +} + +@article{liu2020deeplearningsystem, + title = {A Deep Learning System for Differential Diagnosis of Skin Diseases}, + author = {Liu, Yuan and Jain, Ayush and Eng, Clara and Way, David H. and Lee, Kang and Bui, Peggy and Kanada, Kimberly and de Oliveira Marinho, Guilherme and Gallegos, Jessica and Gabriele, Sara and Gupta, Vishakha and Singh, Nalini and Natarajan, Vivek and Hofmann-Wellenhof, Rainer and Corrado, Greg S. and Peng, Lily H. and Webster, Dale R. and Ai, Dennis and Huang, Susan J. and Liu, Yun and Dunn, R. Carter and Coz, David}, + date = {2020-06}, + journaltitle = {Nature Medicine}, + shortjournal = {Nat Med}, + volume = {26}, + pages = {900--908}, + publisher = {{Nature Publishing Group}}, + issn = {1546-170X}, + doi = {10.1038/s41591-020-0842-3}, + abstract = {Skin conditions affect 1.9 billion people. Because of a shortage of dermatologists, most cases are seen instead by general practitioners with lower diagnostic accuracy. We present a deep learning system (DLS) to provide a differential diagnosis of skin conditions using 16,114 de-identified cases (photographs and clinical data) from a teledermatology practice serving 17 sites. The DLS distinguishes between 26 common skin conditions, representing 80\% of cases seen in primary care, while also providing a secondary prediction covering 419 skin conditions. On 963 validation cases, where a rotating panel of three board-certified dermatologists defined the reference standard, the DLS was non-inferior to six other dermatologists and superior to six primary care physicians (PCPs) and six nurse practitioners (NPs) (top-1 accuracy: 0.66 DLS, 0.63 dermatologists, 0.44 PCPs and 0.40 NPs). These results highlight the potential of the DLS to assist general practitioners in diagnosing skin conditions.}, + file = {/home/norangebit/Documenti/10-personal/12-organizzation/06-zotero/storage/CGRLE4YH/s41591 020 0842 3.html}, + issue = {6}, + langid = {english}, + number = {6}, + options = {useprefix=true} +} + @article{liu2021exploratorystudyintroduction, title = {An {{Exploratory Study}} on the {{Introduction}} and {{Removal}} of {{Different Types}} of {{Technical Debt}}}, author = {Liu, Jiakun and Huang, Qiao and Xia, Xin and Shihab, Emad and Lo, David and Li, Shanping}, @@ -294,12 +385,21 @@ archiveprefix = {arXiv}, eprint = {2101.03730}, eprinttype = {arxiv}, - file = {/home/norangebit/Documenti/10-personal/12-organizzation/06-zotero/storage/FB78NEAM/2101.03730.pdf}, + file = {/home/norangebit/Documenti/10-personal/12-organizzation/07-zotero-attachments/undefined/Liu_2021_An Exploratory Study on the Introduction and Removal of Different Types of.pdf}, keywords = {Computer Science - Software Engineering}, langid = {english}, number = {2} } +@online{multicolumndeepneural, + title = {Multi-Column Deep Neural Networks for Image Classification}, + url = {https://ieeexplore.ieee.org/abstract/document/6248110/}, + urldate = {2021-06-09}, + abstract = {Traditional methods of computer vision and machine learning cannot match human performance on tasks such as the recognition of handwritten digits or traffic signs. Our biologically plausible, wide and deep artificial neural network architectures can. Small (often minimal) receptive fields of convolutional winner-take-all neurons yield large network depth, resulting in roughly as many sparsely connected neural layers as found in mammals between retina and visual cortex. Only winner neurons are trained. Several deep neural columns become experts on inputs preprocessed in different ways; their predictions are averaged. Graphics cards allow for fast training. On the very competitive MNIST handwriting benchmark, our method is the first to achieve near-human performance. On a traffic sign recognition benchmark it outperforms humans by a factor of two. We also improve the state-of-the-art on a plethora of common image classification benchmarks.}, + file = {/home/norangebit/Documenti/10-personal/12-organizzation/06-zotero/storage/2R4ZFR6C/6248110.html}, + langid = {american} +} + @online{naturallanguagetoolkit, title = {Natural {{Language Toolkit}} \textemdash{} {{NLTK}} 3.5 Documentation}, url = {https://www.nltk.org/}, @@ -317,6 +417,38 @@ langid = {american} } +@online{oktay2018attentionunetlearning, + title = {Attention {{U}}-{{Net}}: {{Learning Where}} to {{Look}} for the {{Pancreas}}}, + shorttitle = {Attention {{U}}-{{Net}}}, + author = {Oktay, Ozan and Schlemper, Jo and Folgoc, Loic Le and Lee, Matthew and Heinrich, Mattias and Misawa, Kazunari and Mori, Kensaku and McDonagh, Steven and Hammerla, Nils Y. and Kainz, Bernhard and Glocker, Ben and Rueckert, Daniel}, + date = {2018-05-20}, + url = {http://arxiv.org/abs/1804.03999}, + urldate = {2021-06-09}, + abstract = {We propose a novel attention gate (AG) model for medical imaging that automatically learns to focus on target structures of varying shapes and sizes. Models trained with AGs implicitly learn to suppress irrelevant regions in an input image while highlighting salient features useful for a specific task. This enables us to eliminate the necessity of using explicit external tissue/organ localisation modules of cascaded convolutional neural networks (CNNs). AGs can be easily integrated into standard CNN architectures such as the U-Net model with minimal computational overhead while increasing the model sensitivity and prediction accuracy. The proposed Attention U-Net architecture is evaluated on two large CT abdominal datasets for multi-class image segmentation. Experimental results show that AGs consistently improve the prediction performance of U-Net across different datasets and training sizes while preserving computational efficiency. The code for the proposed architecture is publicly available.}, + archiveprefix = {arXiv}, + eprint = {1804.03999}, + eprinttype = {arxiv}, + file = {/home/norangebit/Documenti/10-personal/12-organizzation/06-zotero/storage/LBH6UYV8/1804.html}, + keywords = {Computer Science - Computer Vision and Pattern Recognition}, + primaryclass = {cs} +} + +@article{rochkind1975sourcecodecontrol, + title = {The Source Code Control System}, + author = {Rochkind, Marc J.}, + date = {1975-12}, + journaltitle = {IEEE Transactions on Software Engineering}, + volume = {SE-1}, + pages = {364--370}, + issn = {1939-3520}, + doi = {10.1109/TSE.1975.6312866}, + abstract = {The Source Code Control System (SCCS) is a software tool designed to help programming projects control changes to source code. It provides facilities for storing, updating, and retrieving all versions of modules, for controlling updating privileges for identifying load modules by version number, and for recording who made each software change, when and where it was made, and why. This paper discusses the SCCS approach to source code control, shows how it is used and explains how it is implemented.}, + eventtitle = {{{IEEE Transactions}} on {{Software Engineering}}}, + file = {/home/norangebit/Documenti/10-personal/12-organizzation/06-zotero/storage/8KN2BXLY/6312866.html}, + keywords = {Configuration management,Control systems,Documentation,Laboratories,Libraries,Process control,program maintenance,Software,software control,software project management}, + number = {4} +} + @article{scalabrino2019listeningcrowdrelease, title = {Listening to the {{Crowd}} for the {{Release Planning}} of {{Mobile Apps}}}, author = {Scalabrino, Simone and Russo, Barbara and Oliveto, Rocco}, @@ -330,4 +462,35 @@ number = {1} } +@article{shannon1948mathematicaltheorycommunication, + title = {A Mathematical Theory of Communication}, + author = {Shannon, C. E.}, + date = {1948-07}, + journaltitle = {The Bell System Technical Journal}, + volume = {27}, + pages = {379--423}, + issn = {0005-8580}, + doi = {10.1002/j.1538-7305.1948.tb01338.x}, + abstract = {The recent development of various methods of modulation such as PCM and PPM which exchange bandwidth for signal-to-noise ratio has intensified the interest in a general theory of communication. A basis for such a theory is contained in the important papers of Nyquist1 and Hartley2 on this subject. In the present paper we will extend the theory to include a number of new factors, in particular the effect of noise in the channel, and the savings possible due to the statistical structure of the original message and due to the nature of the final destination of the information.}, + eventtitle = {The {{Bell System Technical Journal}}}, + file = {/home/norangebit/Documenti/10-personal/12-organizzation/06-zotero/storage/ZLGCL7V5/6773024.html}, + number = {3} +} + +@inproceedings{zhang2018empiricalstudytensorflow, + title = {An Empirical Study on {{TensorFlow}} Program Bugs}, + booktitle = {Proceedings of the 27th {{ACM SIGSOFT International Symposium}} on {{Software Testing}} and {{Analysis}}}, + author = {Zhang, Yuhao and Chen, Yifan and Cheung, Shing-Chi and Xiong, Yingfei and Zhang, Lu}, + date = {2018-07-12}, + pages = {129--140}, + publisher = {{ACM}}, + location = {{Amsterdam Netherlands}}, + doi = {10.1145/3213846.3213866}, + abstract = {Deep learning applications become increasingly popular in important domains such as self-driving systems and facial identity systems. Defective deep learning applications may lead to catastrophic consequences. Although recent research e orts were made on testing and debugging deep learning applications, the characteristics of deep learning defects have never been studied. To ll this gap, we studied deep learning applications built on top of TensorFlow and collected program bugs related to TensorFlow from StackOverow QA pages and Github projects. We extracted information from QA pages, commit messages, pull request messages, and issue discussions to examine the root causes and symptoms of these bugs. We also studied the strategies deployed by TensorFlow users for bug detection and localization. These ndings help researchers and TensorFlow users to gain a better understanding of coding defects in TensorFlow programs and point out a new direction for future research.}, + eventtitle = {{{ISSTA}} '18: {{International Symposium}} on {{Software Testing}} and {{Analysis}}}, + file = {/home/norangebit/Documenti/10-personal/12-organizzation/07-zotero-attachments/ACM/Zhang_2018_An empirical study on TensorFlow program bugs.pdf}, + isbn = {978-1-4503-5699-2}, + langid = {english} +} + diff --git a/src/chapter_1.md b/src/chapter_1.md new file mode 100644 index 0000000..79a882f --- /dev/null +++ b/src/chapter_1.md @@ -0,0 +1,34 @@ +# Introduzione + +La storia dell'industria dello sviluppo software è caratterizzata da diversi cambiamenti rispetto alle applicazioni dominati. +Negli anni ottanta il dominio dominante era quello dei personal computer, puoi abbiamo avuto Internet a cui è seguita la nascita del Web al \ac{CERN}. +Nel 2007 con l'annuncio del primo iPhone è inizia l'era del *mobile computing* a cui è seguita quella del *cloud computing*. +Negli ultimi anni l'industria non è stata a guardare, ma ha dato vita a sempre più prodotti che fanno uso di \ac{AI} e \ac{ML}. +Gli strumenti e i software che fanno uso di queste tecnologie sono ormai parte della nostra vita quotidiana e pervadono i campi più disparati. +Tra questi sicuramente possiamo annoverare: riconoscimento di immagini, diagnosi di malattie, \ac{NLP}, guida autonoma e riconoscimento vocale. + +La crescente produzione di software basato sul \acl{ML} ha generato un forte impulso anche per quanto riguarda la ricerca. +L'attenzione non è stata puntata unicamente sullo studio di nuovi modelli e architetture, ma anche sul processo di sviluppo di questi prodotti per andare a valutare i vari problemi da un punto di vista ingegneristico. +Il seguente lavoro si muove proprio in questo solco e ha lo scopo di studiare come le componenti di \ac{ML} sono distribuite sull'architettura dei sistemi, ma anche di capire se esistono delle differenze tra gli interventi di *issue fixing* doviti a problematiche di \acl{ML} e quelli generici. + +## Opere correlate + +In questo lavoro[@gonzalez2020statemluniverse10] vengono studiate mediante tecniche di statistica descrittiva, le differenze tra sistemi di \ac{ML}, a loro volta divisi in framework e applicazioni, e sistemi generici. +Gli aspetti considerati sono vari, si va dalla distribuzione dei contributi, divisi tra interni ed esterni, fino all'analisi dei linguaggi più utilizzati, passando per un'analisi sulla popolarità dei vari repositories. +In altri lavori il focus è stato puntato sulla gestione delle dipendenze dei progetti di \acl{ML}. +In particolare lo scopo dello studio[@han2020empiricalstudydependency] era valutare le eventuali differenze che sussistevano in base al framework utilizzato (`TensorFlow`, `PyTorch`, `Theano`). +In questo caso gli aspetti considerati sono stati la natura del progetto (tutorial/libri, applicativi, ricerca), il dominio applicativo, la popolarità e la frequenza di aggiornamento delle dipendenze di \ac{ML}. +In altri[@grichi2020impactmultilanguagedevelopment] casi l'attenzione è stata rivolta alla natura *multi-linguaggio* tipica delle soluzioni di \acl{ML} e all'impatto che ciò ha sul sistema. +Gli aspetti principalmente presi in considerazione sono stati il tempo necessario ad accettare una modifica e la propensione al manifestarsi di *bug*. + +In letteratura sono presenti anche molti lavori che vanno ad analizzare le problematiche e i *bug* riscontrati all'interno di applicazioni di \acl{ML}. +In alcuni casi lo studio[@zhang2018empiricalstudytensorflow] è stato svolto in maniera specifica per un singolo framework. +Mentre in altri casi[@humbatova-2019-taxonomyrealfaults] lo scopo era quello di andare a definire una tassonomia delle problematiche che fosse però generale per tutti i framework e le applicazioni di \ac{ML}. +Altre volte ancora l'analisi[@liu2021exploratorystudyintroduction] è stata mirata su alcuni aspetti come l'introduzione e la rimozione di \ac{SATD} all'interno di progetti che fanno uso di \ac{DL}. + +La quasi totalità degli studi precedentemente discussi utilizzava come fonte d'informazione per individuare le problematiche direttamente i progetti e la loro storia. +Altri lavori[@bangash2019whatdevelopersknow; @han2020whatprogrammersdiscuss; @alshangiti2019whydevelopingmachine] invece hanno analizzato le discussioni su *StackOverflow* per andare a capire quali sono le fasi più critiche del processo di sviluppo e quali sono gli argomenti che gli sviluppatori discutono più frequentemente. + +Altri studi[@hassan2009predictingfaultsusing] ancora hanno traslando il concetto di entropia[@shannon1948mathematicaltheorycommunication] utilizzato nella teoria della comunicazione per andare a valutare la complessità del processo di cambiamento del software. +Andando, inoltre, ad evidenziare come la complessità del processo possa essere utilizzata per predire i *faults* all'interno dei prodotti software con risultati migliori rispetto alle metriche di complessità del software. + diff --git a/src/metadata.yaml b/src/metadata.yaml index 663468d..334212a 100644 --- a/src/metadata.yaml +++ b/src/metadata.yaml @@ -29,10 +29,20 @@ link-citations: true ac-onlyused: true ac-title: Acronimi acronym: + - short: AI + long: Artificial Intelligence - short: API long: Application Program Interface + - short: CERN + long: European Council for Nuclear Research + - short: DL + long: Deep Learning - short: ML long: Machine Learning + - short: NLP + long: Natural Language Processing + - short: SATD + long: Self-Admitted Technical Debt - short: VPS long: Virtual Private Server ##### crossref ##### From 2bb005a9fa6e1c0821e80978d6b0065b31c60aa9 Mon Sep 17 00:00:00 2001 From: norangebit Date: Thu, 10 Jun 2021 13:29:03 +0200 Subject: [PATCH 2/3] Add research questions --- src/chapter_1.md | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git a/src/chapter_1.md b/src/chapter_1.md index 79a882f..3ed58ab 100644 --- a/src/chapter_1.md +++ b/src/chapter_1.md @@ -32,3 +32,28 @@ Altri lavori[@bangash2019whatdevelopersknow; @han2020whatprogrammersdiscuss; @al Altri studi[@hassan2009predictingfaultsusing] ancora hanno traslando il concetto di entropia[@shannon1948mathematicaltheorycommunication] utilizzato nella teoria della comunicazione per andare a valutare la complessità del processo di cambiamento del software. Andando, inoltre, ad evidenziare come la complessità del processo possa essere utilizzata per predire i *faults* all'interno dei prodotti software con risultati migliori rispetto alle metriche di complessità del software. +## Research Questions + +Questo studio ha l'obiettivo di dare una risposta a queste cinque domande: + +- **RQ1**: *come il \ac{ML} e' distribuito sull'architettura dei progetti?* + + In questa *RQ* si vuole investigare l'architettura dei progetti. + In particolare l'attenzione viene concentratala sui files e sulle directories modificate durante interventi di *issues fixing*. + Obbiettivo di questa domanda è anche individuare la percentuale di files che utilizzano import riconducibili a librerie e framework di \acl{ML}. +- **RQ2**: *come sono distribuiti i bug sulle diverse fasi di \ac{ML}?* + + Il workflow tipico per lo sviluppo di un'applicazione di \acl{ML} si compone di più fasi. + L'obiettivo di questa *RQ* è quello di individuare le fasi più critiche per quanto riguarda l'introduzione di difetti all'interno del prodotto software. +- **RQ3**: *esiste una differenza di entropy tra \ac{ML} bug e altri bug?* + + A partire dai lavori precedenti svolti sull'entropia di un cambiamento, si vuole capire se esiste una differenza in termini di entropia generata tra le correzioni dei difetti ascrivibili al \acl{ML} e gli altri difetti. +- **RQ4**: *come varia il livello di discussione tra \ac{ML} bug e altri bug?* + + Questa *RQ* riguarda il livello di discussione dei *bug*. + In particolare si vuole capire se, all'interno dei progetti di \acl{ML}, i bug generici sono discussi con lo stesso livello di approfondimento di quelli specifici del \ac{ML}. +- **RQ5**: *come varia il time-to-fix tra \ac{ML} bug e altri bug?* + + Un altro aspetto caratteristico di un *fix* è il tempo necessario per poter essere attuato. + Questa *RQ* ha lo scopo di verificare l'esistenza di differenze tra i *bug* generici e quelli di \acl{ML}. + From 0dbf8da5a3de4240939e4dbcf909dd05b34f4ab0 Mon Sep 17 00:00:00 2001 From: norangebit Date: Thu, 10 Jun 2021 16:01:45 +0200 Subject: [PATCH 3/3] Refactor relate works --- src/chapter_1.md | 37 ++++++++++++++++++++++++------------- 1 file changed, 24 insertions(+), 13 deletions(-) diff --git a/src/chapter_1.md b/src/chapter_1.md index 3ed58ab..b47dec3 100644 --- a/src/chapter_1.md +++ b/src/chapter_1.md @@ -13,21 +13,32 @@ Il seguente lavoro si muove proprio in questo solco e ha lo scopo di studiare co ## Opere correlate -In questo lavoro[@gonzalez2020statemluniverse10] vengono studiate mediante tecniche di statistica descrittiva, le differenze tra sistemi di \ac{ML}, a loro volta divisi in framework e applicazioni, e sistemi generici. -Gli aspetti considerati sono vari, si va dalla distribuzione dei contributi, divisi tra interni ed esterni, fino all'analisi dei linguaggi più utilizzati, passando per un'analisi sulla popolarità dei vari repositories. -In altri lavori il focus è stato puntato sulla gestione delle dipendenze dei progetti di \acl{ML}. -In particolare lo scopo dello studio[@han2020empiricalstudydependency] era valutare le eventuali differenze che sussistevano in base al framework utilizzato (`TensorFlow`, `PyTorch`, `Theano`). -In questo caso gli aspetti considerati sono stati la natura del progetto (tutorial/libri, applicativi, ricerca), il dominio applicativo, la popolarità e la frequenza di aggiornamento delle dipendenze di \ac{ML}. -In altri[@grichi2020impactmultilanguagedevelopment] casi l'attenzione è stata rivolta alla natura *multi-linguaggio* tipica delle soluzioni di \acl{ML} e all'impatto che ciò ha sul sistema. -Gli aspetti principalmente presi in considerazione sono stati il tempo necessario ad accettare una modifica e la propensione al manifestarsi di *bug*. +In questo lavoro[@gonzalez2020statemluniverse10] sono stati studiati mediante tecniche di statistica descrittiva $9325$ progetti. +I progetti sono stati distinti tra sistemi di \ac{ML}, a loro volta suddivisi in framework ($700$ elementi) e applicazioni ($4524$ elementi), e sistemi generici ($4101$ elementi). +Gli aspetti considerati per l'analisi sono vari, si va dalla distribuzione dei contributi, a loro volta divisi tra interni ed esterni, fino all'analisi dei linguaggi più utilizzati, passando per un'analisi sulla popolarità dei vari repositories. +Inoltre vengono valutate anche le differenze per quanto riguarda le interazioni collaborative (discussioni, review, ecc.). -In letteratura sono presenti anche molti lavori che vanno ad analizzare le problematiche e i *bug* riscontrati all'interno di applicazioni di \acl{ML}. -In alcuni casi lo studio[@zhang2018empiricalstudytensorflow] è stato svolto in maniera specifica per un singolo framework. -Mentre in altri casi[@humbatova-2019-taxonomyrealfaults] lo scopo era quello di andare a definire una tassonomia delle problematiche che fosse però generale per tutti i framework e le applicazioni di \ac{ML}. -Altre volte ancora l'analisi[@liu2021exploratorystudyintroduction] è stata mirata su alcuni aspetti come l'introduzione e la rimozione di \ac{SATD} all'interno di progetti che fanno uso di \ac{DL}. +In altri lavori[@han2020empiricalstudydependency] il focus è stato puntato sulla gestione delle dipendenze dei progetti di \acl{ML}. +In questo caso si va a valutare le eventuali differenze in base al framework utilizzato. +Le librerie considerate nello studio sono: `TensorFlow`, `PyTorch` e `Theano`. +Mentre eventuali differenze sono state ricercate rispetto agli obbiettivi del progetto (tutorial/libri, applicativi, ricerca), il dominio applicativo, la popolarità, la frequenza di aggiornamento delle dipendenze e i motivi degli aggiornamenti. -La quasi totalità degli studi precedentemente discussi utilizzava come fonte d'informazione per individuare le problematiche direttamente i progetti e la loro storia. -Altri lavori[@bangash2019whatdevelopersknow; @han2020whatprogrammersdiscuss; @alshangiti2019whydevelopingmachine] invece hanno analizzato le discussioni su *StackOverflow* per andare a capire quali sono le fasi più critiche del processo di sviluppo e quali sono gli argomenti che gli sviluppatori discutono più frequentemente. +In altri casi[@grichi2020impactmultilanguagedevelopment] ancora l'attenzione è stata rivolta alla natura *multi-linguaggio* tipica delle soluzioni di \acl{ML} e all'impatto che ciò ha sul sistema. +In questo caso sono stati considerati, tra progetti mono-linguaggio e multi-linguaggio, $27$ repository open source. +Per quanto riguarda l'analisi sono stati presi in considerazione la percentuale di pull request accettate, il tempo necessario per accettare una pull request e la propensione nell'introdurre i *bug* all'interno delle pull request. + +In letteratura sono presenti anche molti lavori che si concentrano sull'analisi delle problematiche e dei *bug* riscontrati all'interno di applicazioni di \acl{ML}. +In alcuni casi lo studio[@zhang2018empiricalstudytensorflow] è stato svolto in maniera specifica per una singola libreria. +Nello specifico sono state considerate $87$ domande postate su *StackOverflow* in relazione a bug di `TensorFlow` e $82$ commit, selezionati da $11$ progetti su *GitHub*. +Lo studio aveva l'obiettivo di individuare i sintomi e le cause scatenati di questi difetti e individuare le sfide per l'individuazione e la localizzazione di questi. + +In altri casi[@humbatova-2019-taxonomyrealfaults] l'attenzione non è stata rivolta ad una libreria specifica, ma si è cercato di definire una tassonomia delle problematiche che fosse però generale per tutti i framework e le applicazioni di \ac{ML}. +Anche in questo caso i dati per lo studio sono stati recuperati sia da *GitHub* che da *StackOverflow*. +Altre volte ancora l'analisi[@liu2021exploratorystudyintroduction] è stata mirata su alcuni aspetti specifici come l'introduzione e la rimozione di \ac{SATD} all'interno di progetti che fanno uso di \ac{DL}. + +Noi lavori precedentemente discussi l'analisi è stata svolta su dati recuperati dalla storia dei repositories e in alcuni casi recuperando informazioni aggiuntive da piattaforme di discussione online. +Altri lavori[@bangash2019whatdevelopersknow; @han2020whatprogrammersdiscuss; @alshangiti2019whydevelopingmachine] invece hanno analizzato unicamente le discussioni su *StackOverflow* per andare a capirne il contenuto. +Lo scopo di questi studi è quello di individuare le fasi più critiche del processo di sviluppo e capire quali sono gli argomenti che gli sviluppatori discutono più frequentemente. Altri studi[@hassan2009predictingfaultsusing] ancora hanno traslando il concetto di entropia[@shannon1948mathematicaltheorycommunication] utilizzato nella teoria della comunicazione per andare a valutare la complessità del processo di cambiamento del software. Andando, inoltre, ad evidenziare come la complessità del processo possa essere utilizzata per predire i *faults* all'interno dei prodotti software con risultati migliori rispetto alle metriche di complessità del software.