Ausnahme beim Ausführen eines REST-Aufrufs

Question

Ich arbeite gerade an einem REST-Aufruf mit Flask Framework. und ich bin auf dem Weg in einige Fehler geraten, die ich nicht herausfinden kann, warum sie auftreten (immer noch versuchen). Der Fehler wird wie unten dargestellt:

[2016-09-20 18:53:26,486] ERROR in app: Exception on /Recommend [GET] 
Traceback (most recent call last): 
    File "/anaconda/lib/python2.7/site-packages/flask/app.py", line 1988, in wsgi_app 
    response = self.full_dispatch_request() 
    File "/anaconda/lib/python2.7/site-packages/flask/app.py", line 1641, in full_dispatch_request 
    rv = self.handle_user_exception(e) 
    File "/anaconda/lib/python2.7/site-packages/flask_cors/extension.py", line 161, in wrapped_function 
    return cors_after_request(app.make_response(f(*args, **kwargs))) 
    File "/anaconda/lib/python2.7/site-packages/flask_api/app.py", line 97, in handle_user_exception 
    for typecheck, handler in chain(blueprint_handlers.items(), app_handlers.items()): 
AttributeError: 'tuple' object has no attribute 'items' 
127.0.0.1 - - [20/Sep/2016 18:53:26] "GET /Recommend HTTP/1.1" 500 - 

hier ist der Code, den ich gebaut habe:

from flask import request, jsonify 
from flask_api import FlaskAPI 
from flask_cors import CORS 

from sets import Set 
from collections import defaultdict 
import itertools 
import copy 

app = FlaskAPI(__name__) 
CORS(app) 

content = None 

class Apriori:  
    def __init__(self): 
     self.no_of_transactions = None 
     self.min_support = 0.5 
     self.min_confidence = 0.75 
     self.transactions = {} 
     self.set_of_items = set() 
     self.frequencies = {} 
     self.frequent_itemsets_of_order_n = {} 
     self.association_rules = {} 

    def createPowerSet(self,s): 
     powerset = set() 
     for i in xrange(2**len(s)): 
      subset = tuple([x for j,x in enumerate(s) if (i >> j) & 1]) 
      if len(subset) == 0: 
       pass 
      elif len(subset) == 1: 
       powerset.add(subset[0]) 
      else: 
       powerset.add(subset) 
     return powerset 

    def createFrequentItemSets(self,set_of_items,len): 
     frequent_itemsets = set(itertools.combinations(set_of_items, len)) 
     for i in list(frequent_itemsets): 
      tempset = set(i) 
      self.frequencies[i] = 0 
      for k, v in self.transactions.iteritems(): 
       if tempset.issubset(set(v)): 
        self.frequencies[i] += 1 
      if float(self.frequencies[i])/self.no_of_transactions < self.min_support: 
       frequent_itemsets.discard(i) 
     return frequent_itemsets 

    def mineAssociationRules(self,frequent_itemset): 
     s = set(frequent_itemset) 
     subs = list(self.createPowerSet(s)) 
     for each in subs: 
      if sorted(tuple(set(each))) == sorted(tuple(s)): 
       continue    
      if len(set(each))==1: 
       antecedent = list(set(each))[0] 
      elif len(set(each))>1: 
       antecedent = tuple(set(each)) 

      if len(s.difference(set(each)))==1: 
       consequent = list(s.difference(set(each)))[0] 
      elif len(s.difference(set(each)))>1: 
       consequent = tuple(s.difference(set(each)))    
      AuC = tuple(s)   
      if float(self.frequencies[AuC])/self.frequencies[antecedent] >= self.min_confidence: 
       if antecedent in self.association_rules: 
        pass 
       else: 
        if type(antecedent) is tuple: 
         antecedent = (",").join(antecedent) 
        if type(consequent) is tuple: 
         consequent = (",").join(consequent) 
        self.association_rules[antecedent] = consequent 

    def implement(self,transactions): 
     #for i in range(0,self.no_of_transactions): 
     for i in range(0,len(transactions)): 
      self.transactions["T"+str(i)] = defaultdict(list) 
      self.transactions["T"+str(i)] = transactions[i].split(',') 
      self.set_of_items = self.set_of_items.union(Set(self.transactions["T"+str(i)]))   
     for i in list(self.set_of_items): 
      self.frequencies[i] = 0 
      for k, v in self.transactions.iteritems(): 
       if i in v: 
        self.frequencies[i] = self.frequencies[i] + 1 
      if float(self.frequencies[i])/self.no_of_transactions < self.min_support: 
       self.set_of_items.discard(i)     
     self.frequent_itemsets_of_order_n[1] = self.set_of_items 
     l = 1   
     reps = copy.deepcopy(self.set_of_items) 
     while True: 
      l += 1 
      result = self.createFrequentItemSets(self.set_of_items, l) 
      if len(result) == 0: 
       break 
      self.frequent_itemsets_of_order_n[l] = result 
      reps = copy.deepcopy(self.frequent_itemsets_of_order_n[l])   
     l = l-1   
     while l>2: 
      for each in self.frequent_itemsets_of_order_n[l]: 
       self.mineAssociationRules(each) 
      l = l-1 

@app.route('/Recommend') 
def FindAssociations(): 
    transactions = ["A,C,D,F,G","A,B,C,D,F","C,D,E","A,D,F","A,C,D,E,F","B,C,D,E,F,G"] 
    apr = Apriori() 
    apr.implement(transactions) 
    return jsonify(rules=apr.association_rules) 

if __name__ == "__main__": 
    app.run(port=5000) 

ich einige Beispiel-Code im Web gefunden ausgeführt haben, und baute das obige Skript basierend auf diesen Skripten . Sie haben gut geklappt. Die Klasse, die ich gebaut habe, basierte auf einem anderen Python-Programm, das ich früher gebaut hatte und das gut funktionierte. Sollte ich die Klasse aus einem anderen Skript importiert haben, anstatt es hier zu bauen?

Answer 1

Es gibt eine Reihe von Fehlern in Ihrem Apriori, die behoben werden müssen. Es gibt einige Versuche, sich durch self.no_of_transactions (z. B. Zeile 87) zu teilen, die auf None initialisiert und nie geändert wird. Die Division durch None löst eine Ausnahme:

>>> 1/None 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
TypeError: unsupported operand type(s) for /: 'int' and 'NoneType' 

Diese Ausnahme dann in Flask-API handle_user_exception() Verfahren behandelt wird, die auch einen Fehler zu haben scheint, wie in der Ausnahme gezeigt, dass es wirft.

Der Weg, es zu beheben, ist, Ihren Code zu korrigieren, damit er nicht durch None teilt.