def begin_train(dynamic_path, static_path, out_path): dynamic_features = utilities.load_adjective_phase(dynamic_path) static_features = utilities.load_adjective_phase(static_path) adjective_list = utilities.adjectives for adjective in adjective_list: # File name dataset_file_name = "_".join(("trained", adjective))+".pkl" newpath = os.path.join(out_path, "trained_adjectives") path_name = os.path.join(newpath, dataset_file_name) if os.path.exists(path_name): print "File %s already exists, skipping it." % path_name continue overall_best_score = 0.0 dataset = defaultdict() dataset['classifier'] = None dataset['training_score'] = overall_best_score dynamic_train = utilities.get_all_train_test_features(adjective, dynamic_features) y_labels = dynamic_train[1] object_ids = dynamic_train[2] dynamic_scaler = preprocessing.StandardScaler().fit(dynamic_train[0]) dynamic_X = dynamic_scaler.transform(dynamic_train[0]) dynamic_kernel = linear_kernel(dynamic_X, -2) #dynamic_kernel = standardize(dynamic_kernel) static_train = utilities.get_all_train_test_features(adjective, static_features) static_scaler = preprocessing.StandardScaler().fit(static_train[0]) static_X = static_scaler.transform(static_train[0]) static_kernel = linear_kernel(static_X, -2) #static_kernel = standardize(static_kernel) alpha_range = [0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0] #alpha_range = [0.5] for alpha in alpha_range: print "Beginning %s, alpha %1.1f at %s" % (adjective,alpha, time.asctime()) combined_kernel = (alpha)*static_kernel + (1-alpha)*dynamic_kernel; trained_clf, best_score = gram_grid_search(combined_kernel, labels=y_labels, object_ids=object_ids, refined_range = adjective) print "F1: %1.5f at %s" % (best_score, time.asctime()) if best_score > overall_best_score: overall_best_score = best_score dataset['classifier'] = trained_clf dataset['training_score'] = best_score dataset['alpha'] = alpha dataset['dynamic_features'] = dynamic_features[adjective] dataset['static_features'] = static_features[adjective] dataset['adjective'] = adjective dataset['dynamic_scaler'] = dynamic_scaler dataset['dynamic_train_scaled'] = dynamic_X; dataset['dynamic_kernel_mean'] = np.mean(dynamic_kernel) dataset['dynamic_kernel_std'] = np.std(dynamic_kernel) dataset['static_scaler'] = static_scaler dataset['static_train_scaled'] = static_X; dataset['static_kernel_mean'] = np.mean(static_kernel) dataset['static_kernel_std'] = np.std(static_kernel) print "Saving trained_classifier" # Save the results in the folder with open(path_name, "w") as f: print "Saving file: ", path_name cPickle.dump(dataset, f, protocol=cPickle.HIGHEST_PROTOCOL)
def begin_train(dynamic_path, static_path, out_path): dynamic_features = utilities.load_adjective_phase(dynamic_path) static_features = utilities.load_adjective_phase(static_path) adjective_list = utilities.adjectives for adjective in adjective_list: # File name dataset_file_name = "_".join(("trained", adjective)) + ".pkl" newpath = os.path.join(out_path, "trained_adjectives") path_name = os.path.join(newpath, dataset_file_name) if os.path.exists(path_name): print "File %s already exists, skipping it." % path_name continue overall_best_score = 0.0 dataset = defaultdict() dataset['classifier'] = None dataset['training_score'] = overall_best_score dynamic_train = utilities.get_all_train_test_features( adjective, dynamic_features) y_labels = dynamic_train[1] object_ids = dynamic_train[2] dynamic_scaler = preprocessing.StandardScaler().fit(dynamic_train[0]) dynamic_X = dynamic_scaler.transform(dynamic_train[0]) dynamic_kernel = linear_kernel(dynamic_X, -2) #dynamic_kernel = standardize(dynamic_kernel) static_train = utilities.get_all_train_test_features( adjective, static_features) static_scaler = preprocessing.StandardScaler().fit(static_train[0]) static_X = static_scaler.transform(static_train[0]) static_kernel = linear_kernel(static_X, -2) #static_kernel = standardize(static_kernel) alpha_range = [0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0] #alpha_range = [0.5] for alpha in alpha_range: print "Beginning %s, alpha %1.1f at %s" % (adjective, alpha, time.asctime()) combined_kernel = (alpha) * static_kernel + ( 1 - alpha) * dynamic_kernel trained_clf, best_score = gram_grid_search(combined_kernel, labels=y_labels, object_ids=object_ids, refined_range=adjective) print "F1: %1.5f at %s" % (best_score, time.asctime()) if best_score > overall_best_score: overall_best_score = best_score dataset['classifier'] = trained_clf dataset['training_score'] = best_score dataset['alpha'] = alpha dataset['dynamic_features'] = dynamic_features[adjective] dataset['static_features'] = static_features[adjective] dataset['adjective'] = adjective dataset['dynamic_scaler'] = dynamic_scaler dataset['dynamic_train_scaled'] = dynamic_X dataset['dynamic_kernel_mean'] = np.mean(dynamic_kernel) dataset['dynamic_kernel_std'] = np.std(dynamic_kernel) dataset['static_scaler'] = static_scaler dataset['static_train_scaled'] = static_X dataset['static_kernel_mean'] = np.mean(static_kernel) dataset['static_kernel_std'] = np.std(static_kernel) print "Saving trained_classifier" # Save the results in the folder with open(path_name, "w") as f: print "Saving file: ", path_name cPickle.dump(dataset, f, protocol=cPickle.HIGHEST_PROTOCOL)
def compute_probability_vector(self, bolt_obj): # First object - initialize variables to store # Also clears out the vectors for new run if bolt_obj.state == bolt_obj.TAP: # Store results as they come in self.adjective_vectors_static = dict() self.adjective_vectors_dynamic = dict() self.all_motion_results = dict() self.mkl_results = dict() # Store dictionary of strings self.state_string = { bolt_obj.DISABLED: 'disabled', bolt_obj.THERMAL_HOLD: 'thermal_hold', bolt_obj.SLIDE: 'slide', bolt_obj.SQUEEZE: 'squeeze', bolt_obj.TAP: 'tap', bolt_obj.DONE: 'done', bolt_obj.SLIDE_FAST: 'slide_fast', bolt_obj.CENTER_GRIPPER: 'center_gripper' } # store dictionary for detailed states self.detailed_states = { bolt_obj.DISABLED: 'MOVE_ARM_START_POSITION', bolt_obj.SQUEEZE: 'SQUEEZE_SET_PRESSURE_SLOW', bolt_obj.THERMAL_HOLD: 'HOLD_FOR_10_SECONDS', bolt_obj.SLIDE: 'SLIDE_5CM', bolt_obj.SLIDE_FAST: 'MOVE_DOWN_5CM' } # Get the current motion current_motion = self.state_string[bolt_obj.state] # Check if state passed in should be processed if bolt_obj.state not in self.detailed_states: return else: # Get detailed state if exists current_detailed_state = self.detailed_states[bolt_obj.state] # Check if the state is a the disabled state if bolt_obj.state == bolt_obj.DISABLED: self.norm_bolt_obj = upenn_features.pull_detailed_state( bolt_obj, current_detailed_state) return else: self.bolt_object = upenn_features.pull_detailed_state( bolt_obj, current_detailed_state) # Checks to make sure that the norm obj has been created if not self.norm_bolt_obj: print "Warning: there is no normalization data" # Build the static features static_feature_object, self.static_features_array = upenn_features.extract_static_features( self.bolt_object, self.norm_bolt_obj) static_feats = upenn_features.createFeatureVector( static_feature_object) # Store all feature vectors into one large vector array # Technically we don't need to store the static # features by adjective - but it's cleaner this way for classifier in self.all_classifiers: adj = classifier['adjective'] # need to add pkl to the name b/c the hmm chain dictionary # takes adjective.pkl as its key hmm_adj_name = '.'.join((adj, 'pkl')) # Initialize the dictionary with adjective if adj in self.adjective_vectors_static: pass else: self.adjective_vectors_static[adj] = list() self.adjective_vectors_dynamic[adj] = list() # Pull out chain associated with adjective # ordering of sensors - [pac, pdc, electrodes, tac] sensor_hmm = ['pac', 'pdc', 'electrodes', 'tac'] hmm_features_phase = [] for sensor in sensor_hmm: hmm_chain = self.hmm_chains[hmm_adj_name].chains[ current_detailed_state][sensor] hmm_data = self.bolt_object.hmm[sensor] # fill in dyanmic features hmm_features_phase.append(hmm_chain.score(hmm_data)) # Store the feature vector by adjective away self.adjective_vectors_static[adj].append(static_feats) self.adjective_vectors_dynamic[adj].append(hmm_features_phase) # Check if all motions have been performed # If so - feed into classifier if len(self.adjective_vectors_dynamic[adj]) == 4: print 'All motions received! Computing adjective scores' for classifier in self.all_classifiers: # Pull out which adjective we are working on adj = classifier['adjective'] # Load training vectors for kernel creation train_dynamic = utilities.get_all_train_test_features( adj, self.training_dynamic, train=True) train_static = utilities.get_all_train_test_features( adj, self.training_static, train=True) # Scale the training data d_scaler = preprocessing.StandardScaler().fit( train_dynamic[0]) s_scaler = preprocessing.StandardScaler().fit( train_static[0]) train_dynamic_scaled = d_scaler.transform(train_dynamic[0]) train_static_scaled = s_scaler.transform(train_static[0]) # Pull out the feature vectors for static/dynamic all_static_feats = np.hstack( self.adjective_vectors_static[adj]) all_dynamic_feats = np.hstack( self.adjective_vectors_dynamic[adj]) # Normalize the features using scaler all_static_feats_scaled = classifier[ 'static_scaler'].transform(all_static_feats) all_dynamic_feats_scaled = classifier[ 'dynamic_scaler'].transform(all_dynamic_feats) # Create kernels for both static and dynamic static_kernel = self.linear_kernel_test( all_static_feats_scaled, train_static_scaled, 1) dynamic_kernel = self.linear_kernel_test( all_dynamic_feats_scaled, train_dynamic_scaled, 1) # Merge the two kernels alpha = classifier['alpha'] merged_kernel = (alpha) * static_kernel + ( 1 - alpha) * dynamic_kernel # Predict adjective with computed kernel clf = classifier['classifier'] self.mkl_results[adj] = clf.predict(merged_kernel) # Store off the adjectives that returned true adjectives_found = [] for adj in self.mkl_results: if self.mkl_results[adj] == 1: adjectives_found.append(Adj(adj)) publish_string = AdjList() publish_string = adjectives_found # Print and publish results! print "Results from MKL classification" #print self.mkl_results print str(adjectives_found) self.adjectives_pub.publish(publish_string)
def test_adjective(classifier, adjective_report ): true_positives = 0.0 true_negatives = 0.0 false_positives = 0.0 false_negatives = 0.0 false_positive_list = [] false_negative_list = [] true_positive_list = [] true_negative_list = [] adjective = classifier['adjective'] dynamic_features = utilities.load_adjective_phase('/home/imcmahon/Desktop/mkl/dynamic/adjective_phase_set') static_features = utilities.load_adjective_phase('/home/imcmahon/Desktop/mkl/static/adjective_phase_set') #dynamic_features = utilities.load_adjective_phase(dynamic_path) #static_features = utilities.load_adjective_phase(static_path) #import pdb; pdb.set_trace() #Dynamic Train dynamic_train = utilities.get_all_train_test_features(adjective, dynamic_features, train=True) dynamic_train_scaler = preprocessing.StandardScaler().fit(dynamic_train[0]) dynamic_train_scaled_X = dynamic_train_scaler.transform(dynamic_train[0]) dynamic_train_kernel = linear_kernel(dynamic_train_scaled_X, -2) #dynamic_train_kernel = standardize(dynamic_train_kernel) #Static Train static_train = utilities.get_all_train_test_features(adjective, static_features, train=True) static_train_scaler = preprocessing.StandardScaler().fit(static_train[0]) static_train_scaled_X = static_train_scaler.transform(static_train[0]) static_train_kernel = linear_kernel(static_train_scaled_X, -2) #static_train_kernel = standardize(static_train_kernel) #Recompute the GRAM matrix #alpha = classifier['alpha']; #train_X = (alpha)*static_train_kernel + (1-alpha)*dynamic_train_kernel #import pdb; pdb.set_trace() dynamic_test = utilities.get_all_train_test_features(adjective, dynamic_features, train=False) dynamic_test_scaled_X = classifier['dynamic_scaler'].transform(dynamic_test[0]) dynamic_kernel = linear_kernel_test(dynamic_test_scaled_X, dynamic_train_scaled_X, -2) #dynamic_kernel = (dynamic_kernel - classifier['dynamic_kernel_mean']) / classifier['dynamic_kernel_std'] static_test = utilities.get_all_train_test_features(adjective, static_features, train=False) static_test_scaled_X = classifier['static_scaler'].transform(static_test[0]) static_kernel = linear_kernel_test(static_test_scaled_X, static_train_scaled_X, -2) #static_kernel = (static_kernel - classifier['static_kernel_mean']) / classifier['static_kernel_std'] alpha = classifier['alpha']; test_X = (alpha)*static_kernel + (1-alpha)*dynamic_kernel print '\n \nTesting Adjective: %s' % classifier['adjective'] #Pull out test features/labels #for phase in phases: #import pdb; pdb.set_trace() #test_set = classifier['test'] #test_X.append(test_set['features']) #test_X.append(test_set['features']) test_Y = dynamic_test[1] object_ids = dynamic_test[2] #object_names = test_set['object_names'] # Pull out the classifier and merge features #test_X = np.concatenate(test_X, axis=1) #import pdb; pdb.set_trace() clf = classifier['classifier'] c_dict[classifier['adjective']] = clf.C #import pdb; pdb.set_trace() print clf # Predict the labels! #if 'scaler' in classifier: # if type(classifier['scaler']) == preprocessing.Scaler: # test_X = classifier['scaler'].transform(test_X) #import pdb; pdb.set_trace() output = clf.predict(test_X) # Determine if the true label and classifier prediction match for val in xrange(len(test_Y)): true_label = test_Y[val] predict_label = output[val] if true_label == 1: if predict_label == 1: true_positives += 1.0 #true_positive_list.append(object_names[val]) else: false_negatives += 1.0 #false_negative_list.append(object_names[val]) else: # label is 0 if predict_label == 1: false_positives += 1.0 #false_positive_list.append(object_names[val]) else: true_negatives += 1.0 #true_negative_list.append(object_names[val]) # Compute statistics for the adjective try: precision = true_positives / (true_positives + false_positives) recall = true_positives / (true_positives + false_negatives) except ZeroDivisionError: # The case when none are found precision = 0 recall = 0 try: f1 = 2.0 * precision*recall / (precision + recall) except ZeroDivisionError: f1 = 0 print "Precision: %f, Recall: %f, F1: %f \n" % (precision, recall, f1) print "Alpha = %1.1f" % alpha adjective_report.write("%s, %1.1f, %f, %f, %f\n" % (classifier['adjective'], alpha, precision, recall, f1)) print "%d False Positive Objects\n" % false_positives print "%d False Negative Objects\n" % false_negatives print "%d True Positive Objects\n" % true_positives print "%d True Negative Objects\n" % true_negatives return (alpha, precision, recall, f1)
def compute_probability_vector(self, bolt_obj): if len(self.bolt_object_list) == 0: self.movement_time = time.time() # First object - initialize variables to store # Also clears out the vectors for new run if bolt_obj.state == bolt_obj.TAP: # Store results as they come in self.adjective_vectors_static = dict() self.adjective_vectors_dynamic = dict() self.all_motion_results = dict() self.mkl_results = dict() # Store dictionary of strings self.state_string = {bolt_obj.DISABLED:'disabled', bolt_obj.THERMAL_HOLD:'thermal_hold', bolt_obj.SLIDE:'slide', bolt_obj.SQUEEZE:'squeeze', bolt_obj.TAP:'tap', bolt_obj.DONE:'done', bolt_obj.SLIDE_FAST:'slide_fast', bolt_obj.CENTER_GRIPPER:'center_gripper' } # store dictionary for detailed states self.detailed_states = {bolt_obj.DISABLED:'MOVE_ARM_START_POSITION', bolt_obj.SQUEEZE:'SQUEEZE_SET_PRESSURE_SLOW', bolt_obj.THERMAL_HOLD:'HOLD_FOR_10_SECONDS', bolt_obj.SLIDE:'SLIDE_5CM', bolt_obj.SLIDE_FAST:'MOVE_DOWN_5CM' } if (len(self.bolt_object_list) < 5): print len(self.bolt_object_list) self.bolt_object_list.append(bolt_obj) return else: self.bolt_object_list.append(bolt_obj) motion_end_time = time.time() print("Elapsed time was %g seconds" % (motion_end_time - self.movement_time)) start_time = time.time() for bolt_obj_v in self.bolt_object_list: # Get the current motion current_motion = self.state_string[bolt_obj_v.state] # Check if state passed in should be processed if bolt_obj_v.state not in self.detailed_states: print "Skipping state: %s" % current_motion continue else: # Get detailed state if exists current_detailed_state = self.detailed_states[bolt_obj_v.state] # Check if the state is a the disabled state if bolt_obj_v.state == bolt_obj_v.DISABLED: self.norm_bolt_obj = upenn_features.pull_detailed_state(bolt_obj_v,current_detailed_state) continue else: cur_bolt_object = upenn_features.pull_detailed_state(bolt_obj_v, current_detailed_state) # Checks to make sure that the norm obj has been created if not self.norm_bolt_obj: print "Warning: there is no normalization data" #Start storing the bolt objects # Build the static features static_feature_object, self.static_features_array = upenn_features.extract_static_features(cur_bolt_object, self.norm_bolt_obj) static_feats = upenn_features.createFeatureVector(static_feature_object) # Store all feature vectors into one large vector array # Technically we don't need to store the static # features by adjective - but it's cleaner this way for classifier in self.all_classifiers: adj = classifier['adjective'] # need to add pkl to the name b/c the hmm chain dictionary # takes adjective.pkl as its key hmm_adj_name = '.'.join((adj,'pkl')) # Initialize the dictionary with adjective if adj in self.adjective_vectors_static: pass else: self.adjective_vectors_static[adj] = list() self.adjective_vectors_dynamic[adj] = list() # Pull out chain associated with adjective # ordering of sensors - [pac, pdc, electrodes, tac] sensor_hmm = ['pac', 'pdc', 'electrodes', 'tac'] hmm_features_phase = []; for sensor in sensor_hmm: hmm_chain = self.hmm_chains[hmm_adj_name].chains[current_detailed_state][sensor] hmm_data = cur_bolt_object.hmm[sensor] # fill in dyanmic features hmm_features_phase.append(hmm_chain.score(hmm_data)) # Store the feature vector by adjective away self.adjective_vectors_static[adj].append(static_feats) self.adjective_vectors_dynamic[adj].append(hmm_features_phase) # Check if all motions have been performed # If so - feed into classifier if len(self.adjective_vectors_dynamic[adj]) == 4: print 'All motions received! Computing adjective scores' for classifier in self.all_classifiers: # Pull out which adjective we are working on adj = classifier['adjective'] # Load training vectors for kernel creation train_dynamic = utilities.get_all_train_test_features(adj, self.training_dynamic, train=True) train_static = utilities.get_all_train_test_features(adj, self.training_static, train=True) # Scale the training data d_scaler = preprocessing.StandardScaler().fit(train_dynamic[0]) s_scaler = preprocessing.StandardScaler().fit(train_static[0]) train_dynamic_scaled = d_scaler.transform(train_dynamic[0]) train_static_scaled = s_scaler.transform(train_static[0]) # Pull out the feature vectors for static/dynamic all_static_feats = np.hstack(self.adjective_vectors_static[adj]) all_dynamic_feats = np.hstack(self.adjective_vectors_dynamic[adj]) # Normalize the features using scaler all_static_feats_scaled = classifier['static_scaler'].transform(all_static_feats) all_dynamic_feats_scaled = classifier['dynamic_scaler'].transform(all_dynamic_feats) # Create kernels for both static and dynamic static_kernel = self.linear_kernel_test(all_static_feats_scaled, train_static_scaled, 1) dynamic_kernel = self.linear_kernel_test(all_dynamic_feats_scaled, train_dynamic_scaled, 1) # Merge the two kernels alpha = classifier['alpha'] merged_kernel = (alpha)*static_kernel + (1-alpha)*dynamic_kernel # Predict adjective with computed kernel clf = classifier['classifier'] self.mkl_results[adj] = clf.predict(merged_kernel) # Store off the adjectives that returned true adjectives_found = [] for adj in self.mkl_results: if self.mkl_results[adj] == 1: adjectives_found.append(Adj(adj)) hardcode_adj = [Adj('hard'), Adj('metallic'), Adj('cool')] publish_string = AdjList() #publish_string = adjectives_found publish_string = hardcode_adj; # Print and publish results! print "Results from MKL classification" #print self.mkl_results print str(adjectives_found) end_time = time.time() print("Elapsed time was %g seconds" % (end_time - start_time)) self.adjectives_pub.publish(publish_string)
def test_adjective(classifier, adjective_report): true_positives = 0.0 true_negatives = 0.0 false_positives = 0.0 false_negatives = 0.0 false_positive_list = [] false_negative_list = [] true_positive_list = [] true_negative_list = [] adjective = classifier['adjective'] dynamic_features = utilities.load_adjective_phase( '/home/imcmahon/Desktop/mkl/dynamic/adjective_phase_set') static_features = utilities.load_adjective_phase( '/home/imcmahon/Desktop/mkl/static/adjective_phase_set') #dynamic_features = utilities.load_adjective_phase(dynamic_path) #static_features = utilities.load_adjective_phase(static_path) #import pdb; pdb.set_trace() #Dynamic Train dynamic_train = utilities.get_all_train_test_features(adjective, dynamic_features, train=True) dynamic_train_scaler = preprocessing.StandardScaler().fit(dynamic_train[0]) dynamic_train_scaled_X = dynamic_train_scaler.transform(dynamic_train[0]) dynamic_train_kernel = linear_kernel(dynamic_train_scaled_X, -2) #dynamic_train_kernel = standardize(dynamic_train_kernel) #Static Train static_train = utilities.get_all_train_test_features(adjective, static_features, train=True) static_train_scaler = preprocessing.StandardScaler().fit(static_train[0]) static_train_scaled_X = static_train_scaler.transform(static_train[0]) static_train_kernel = linear_kernel(static_train_scaled_X, -2) #static_train_kernel = standardize(static_train_kernel) #Recompute the GRAM matrix #alpha = classifier['alpha']; #train_X = (alpha)*static_train_kernel + (1-alpha)*dynamic_train_kernel #import pdb; pdb.set_trace() dynamic_test = utilities.get_all_train_test_features(adjective, dynamic_features, train=False) dynamic_test_scaled_X = classifier['dynamic_scaler'].transform( dynamic_test[0]) dynamic_kernel = linear_kernel_test(dynamic_test_scaled_X, dynamic_train_scaled_X, -2) #dynamic_kernel = (dynamic_kernel - classifier['dynamic_kernel_mean']) / classifier['dynamic_kernel_std'] static_test = utilities.get_all_train_test_features(adjective, static_features, train=False) static_test_scaled_X = classifier['static_scaler'].transform( static_test[0]) static_kernel = linear_kernel_test(static_test_scaled_X, static_train_scaled_X, -2) #static_kernel = (static_kernel - classifier['static_kernel_mean']) / classifier['static_kernel_std'] alpha = classifier['alpha'] test_X = (alpha) * static_kernel + (1 - alpha) * dynamic_kernel print '\n \nTesting Adjective: %s' % classifier['adjective'] #Pull out test features/labels #for phase in phases: #import pdb; pdb.set_trace() #test_set = classifier['test'] #test_X.append(test_set['features']) #test_X.append(test_set['features']) test_Y = dynamic_test[1] object_ids = dynamic_test[2] #object_names = test_set['object_names'] # Pull out the classifier and merge features #test_X = np.concatenate(test_X, axis=1) #import pdb; pdb.set_trace() clf = classifier['classifier'] c_dict[classifier['adjective']] = clf.C #import pdb; pdb.set_trace() print clf # Predict the labels! #if 'scaler' in classifier: # if type(classifier['scaler']) == preprocessing.Scaler: # test_X = classifier['scaler'].transform(test_X) #import pdb; pdb.set_trace() output = clf.predict(test_X) # Determine if the true label and classifier prediction match for val in xrange(len(test_Y)): true_label = test_Y[val] predict_label = output[val] if true_label == 1: if predict_label == 1: true_positives += 1.0 #true_positive_list.append(object_names[val]) else: false_negatives += 1.0 #false_negative_list.append(object_names[val]) else: # label is 0 if predict_label == 1: false_positives += 1.0 #false_positive_list.append(object_names[val]) else: true_negatives += 1.0 #true_negative_list.append(object_names[val]) # Compute statistics for the adjective try: precision = true_positives / (true_positives + false_positives) recall = true_positives / (true_positives + false_negatives) except ZeroDivisionError: # The case when none are found precision = 0 recall = 0 try: f1 = 2.0 * precision * recall / (precision + recall) except ZeroDivisionError: f1 = 0 print "Precision: %f, Recall: %f, F1: %f \n" % (precision, recall, f1) print "Alpha = %1.1f" % alpha adjective_report.write( "%s, %1.1f, %f, %f, %f\n" % (classifier['adjective'], alpha, precision, recall, f1)) print "%d False Positive Objects\n" % false_positives print "%d False Negative Objects\n" % false_negatives print "%d True Positive Objects\n" % true_positives print "%d True Negative Objects\n" % true_negatives return (alpha, precision, recall, f1)