source: internals/2016/aptoideimagesdetector/trunk/aptoide_mature_app_detector/aptoide_mature_app_detector/explicit_content_detector/API/Explicit_detector/analyse_app_kfold_tests.py @ 16525

Last change on this file since 16525 was 16462, checked in by dferreira, 4 years ago

File organization changed

File size: 8.1 KB
Line 
1# Diogo Daniel Soares Ferreira
2# diogodanielsoaresferreira@ua.pt
3# Aptoide, 2016
4
5# Testing to analyse the percentage of explicitness of an app with k-fold tests
6
7from __future__ import division
8import i2v
9import pickle
10import os
11import sqlite3
12import collections
13import glob
14import pickle
15from Illustration2Vector.illustration2vec_master.analyse_image import analyse_explicit
16from Text_categorization.Text_categorization import text_cat
17import random
18import nltk
19from datetime import datetime, time
20from nltk.metrics import precision, recall, f_measure
21from sklearn.naive_bayes import MultinomialNB, BernoulliNB
22from sklearn.linear_model import LogisticRegression, SGDClassifier, Ridge, Lasso, ElasticNet, SGDRegressor
23from nltk.classify.scikitlearn import SklearnClassifier
24from sklearn.svm import SVC, LinearSVC, NuSVC
25from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, ExtraTreesClassifier
26from sklearn import tree
27
28# Parameter k of k-fold tests
29k=5
30
31def analyse_app_train(illust2vec, app_info):
32       
33        def find_features(icon_list, scr_list, description_result):
34                features = {}
35                maximum = 0
36                flag = 0
37                safe = 0
38
39                # Find maximum percentage of explicitness and its safetiness percentage.
40               
41                if len(icon_list)==0:
42                        maximum = 0.5
43                        safe = 0.5
44                else:
45                        for icon in icon_list:
46                                for data in icon:
47                                        if data[0]=='explicit' and data[1]>maximum:
48                                                maximum = data[1]
49                                                flag = 1
50                                        if data[0]=='safe' and flag==1:
51                                                safe = data[1]
52                                                flag = 0
53                maximum_s = 0
54                flag = 0
55                safe_s = 0
56
57                if len(scr_list)==0:
58                        maximum_s = 0.5
59                        safe_s = 0.5
60                else:
61                        for scr in scr_list:
62                                for data in scr:
63                                        if data[0]=='explicit' and data[1]>maximum_s:
64                                                maximum_s = data[1]
65                                                flag = 1
66                                        if data[0]=='safe' and flag==1:
67                                                safe_s = data[1]
68                                                flag = 0
69
70                features['ic_exp'] = maximum
71                features['ic_non'] = safe
72                features['sc_exp'] = maximum_s
73                features['sc_non'] = safe_s
74                features['desc_exp'] = description_result.prob('exp')
75                return features
76
77        featuresets = []
78        try:
79                f = open("./featuresets.pickle", "rb")
80                featuresets = pickle.load(f)
81                f.close()
82                print "Open FeatureSets Pickle"
83        except IOError:
84                # It can take toooo much time (4000 apps database, +- 8 hours)
85                print "Did not Find FeatureSets Pickle"
86                num=0
87                # Building the featureset
88                for info in app_info:
89                        icons_l = []
90                        screens = []
91                        for icon in info[0]:
92                                try:
93                                        icons_l.append(analyse_explicit(illust2vec, icon))
94                                except:
95                                        print "Could not resize image"
96
97                        for scr in info[1]:
98                                try:
99                                        screens.append(analyse_explicit(illust2vec, scr))
100                                except:
101                                        print "Could not resize image"
102
103                        desc = text_cat(info[2], len(info[2]), info[3],info[4])
104                        num+=1
105                        if (num%100)==0:
106                                print num
107                        features = find_features(icons_l, screens, desc)
108                        featuresets.append((features, info[5]))
109
110                random.shuffle(featuresets)
111                save_model = open("./featuresets.pickle", "wb")
112                pickle.dump(featuresets, save_model)
113                save_model.close()
114
115        # Divide explicit and non_explicit features
116        explicit_feat = [feature for feature in featuresets if feature[1]=='exp']
117        non_explicit_feat = [feature for feature in featuresets if feature[1]=='non']
118
119
120        i=0
121        while i<k:
122
123                # Creating testing and training set
124                testing_set = explicit_feat[int((i*len(explicit_feat)/k)):int(((i+1)*len(explicit_feat)/k))]+non_explicit_feat[int((i*len(non_explicit_feat)/k)):int(((i+1)*len(non_explicit_feat)/k))]
125                training_set = [x for j,x in enumerate(explicit_feat) if j<(i*len(explicit_feat)/k) or j>((i+1)*len(explicit_feat)/k)]
126                training_set += [x for j,x in enumerate(non_explicit_feat) if j<(i*len(non_explicit_feat)/k) or j>((i+1)*len(non_explicit_feat)/k)]
127                random.shuffle(training_set)
128                random.shuffle(testing_set)
129
130                def results(classifier, testing_set, training_set):
131                        now = datetime.now()
132                        # Training the classifier
133                        classifier = classifier.train(training_set)
134                        refsets = collections.defaultdict(set)
135                        testsets = collections.defaultdict(set)
136
137                        tp=0
138                        fp=0
139                        tn=0
140                        fn=0
141                        # Gets the true/false positives/negatives
142                        for i, (features, label) in enumerate(testing_set):
143                                refsets[label].add(i)
144                                observed = classifier.classify(features)
145                                testsets[observed].add(i)
146                                if label =='exp' and observed =='exp':
147                                        tp += 1
148                                elif label=='non' and observed=='non':
149                                        tn += 1
150                                elif label=='exp' and observed=='non':
151                                        fn += 1
152                                else:
153                                        fp += 1
154
155                        print "Time training: " + str(datetime.now()-now)
156                        print "True Positives: " + str(tp)
157                        print "False Positives: " + str(fp)
158                        print "True Negatives: " + str(tn)
159                        print "False Negatives: " + str(fn)
160                        print 'Explicit Precision: ', precision(refsets['exp'], testsets['exp'])
161                        print 'Explicit recall: ', recall(refsets['exp'], testsets['exp'])
162                        print 'Explicit F-Score: ', f_measure(refsets['exp'], testsets['exp'])
163                        print 'Non-Explicit Precision: ', precision(refsets['non'], testsets['non'])
164                        print 'Non-Explicit Recall: ', recall(refsets['non'], testsets['non'])
165                        print 'Non-Explicit F-Score: ', f_measure(refsets['non'], testsets['non'])
166
167                        print "Accuracy percent: ", (nltk.classify.accuracy(classifier, testing_set))*100
168                        return classifier
169
170
171                try:
172                        print "\n****** SGD CLASSIFIER ************"
173                        results(SklearnClassifier(SGDClassifier()), testing_set, training_set)
174                except:
175                        pass
176                try:
177                        print "\n****** ADA BOOST ************"
178                        results(SklearnClassifier(AdaBoostClassifier()), testing_set, training_set)
179                except:
180                        pass
181                try:
182                        print "\n****** LOGISTIC REGRESSION ************"
183                        saving_model = results(SklearnClassifier(LogisticRegression()), testing_set, training_set)
184                except:
185                        pass
186                try:
187                        print "\n****** SVC ************"
188                        results(SklearnClassifier(SVC()), testing_set, training_set)
189                except:
190                        pass
191                try:
192                        print "\n****** LINEAR SVC ************"
193                        results(SklearnClassifier(LinearSVC()), testing_set, training_set)
194                except:
195                        pass
196               
197                i+=1
198
199
200if __name__=='__main__':
201
202        try:
203                # Tries to load the illustration2vec model
204                illust2vec_f = open("Illustration2Vector/illustration2vec_master/illust2vec.pickle", "rb")
205                illust2vec = pickle.load(illust2vec_f)
206                illust2vec_f.close()
207        except IOError:
208                illust2vec = i2v.make_i2v_with_chainer(
209            "Illustration2Vector/illustration2vec-master/illust2vec_tag_ver200.caffemodel", "Illustration2Vector/illustration2vec-master/tag_list.json")
210                save_model = open("Illustration2Vector/illustration2vec_master/illust2vec.pickle", "wb")
211                pickle.dump(illust2vec, save_model)
212                save_model.close()
213
214        icons = []
215        screenshots = []
216        description = ""
217        # Gets all the content from database
218        db = sqlite3.connect('./API to download database/app_info_big.db')
219        c = db.cursor()
220
221        explicit_content = []
222        non_explicit_content = []
223        exp_size = 0
224        non_size = 0
225
226
227        c.execute(''' SELECT title,id,description, category, age FROM app_data WHERE mature=1''')
228
229        for d in c.fetchall():
230                explicit_content.append(d)
231                exp_size += 1
232
233
234        c.execute(''' SELECT title,id,description, category, age FROM app_data WHERE mature=0''')
235
236        for d in c.fetchall():
237                non_explicit_content.append(d)
238                non_size += 1
239
240        db.close()
241
242        print "Non-Explicit Size: "+str(non_size)
243        print "Explicit Size: "+str(exp_size)
244
245        # Get images from an app id
246        def get_images_list(id_int):
247
248                icons = []
249                scr = []
250
251                os.chdir("./API to download database/Big_Database/images/screenshot")
252                types = [".jpg", ".png"]
253                for type_image in types:
254                        for image in glob.glob(str(id_int)+"*"+type_image):
255                            scr.append("./API to download database/Big_Database/images/screenshot/"+image)
256
257                os.chdir("../icon")
258                types = [".jpg", ".png"]
259                for type_image in types:
260                        for image in glob.glob(str(id_int)+"*"+type_image):
261                                icons.append("./API to download database/Big_Database/images/icon/"+image)
262                os.chdir("../../../..")
263
264                return icons, scr
265
266        app_info = []
267        print "Appending all images..."
268        now = datetime.now()
269        for d in explicit_content:
270                icons, screenshots = get_images_list(d[1])
271                description = d[2]
272                cat = d[3]
273                age = d[4]
274                app_info.append((icons, screenshots, description,cat,age,'exp'))
275
276        for d in non_explicit_content:
277                icons, screenshots = get_images_list(d[1])
278                description = d[2]
279                cat = d[3]
280                age = d[4]
281                app_info.append((icons, screenshots, description, cat, age,'non'))
282        print str(datetime.now()-now)
283        analyse_app_train(illust2vec, app_info)
284
Note: See TracBrowser for help on using the repository browser.