REST 호출에서 예외가 발생했습니다.

Question

현재 Flask Framework를 사용하여 REST 호출을하고 있습니다. 그리고 나는 길을 따라 약간의 실수를 겪었는데, 나는 그것이 왜 발생했는지에 관해서는 알 수 없다 (여전히 시도하고있다). 여기

[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 - 

내가 내장 한 코드입니다 : 오류는 다음과 같습니다 제가 웹에서 발견 된 일부 샘플 코드를 실행 않았다

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) 

, 그 스크립트를 기준으로 위의 스크립트를 구축 . 그들은 잘했습니다. 내가 만든 클래스는 이전에 잘 만들어진 다른 파이썬 프로그램을 기반으로했습니다. 클래스를 여기에 작성하는 대신 다른 스크립트에서 가져와야합니까?

Answer 1

수정해야 할 Apriori에는 여러 가지 오류가 있습니다. None으로 초기화되어 변경되지 않은 self.no_of_transactions (예 : 87 행)으로 나누기위한 몇 가지 시도가 있습니다.

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

이 예외는 다음 또한 제기 예외 같이 버그가있는 것 같습니다 플라스크-API의 handle_user_exception() 방법으로 처리됩니다 None으로 나누면 예외를 발생시킵니다.

해결 방법은 None으로 나누지 않도록 코드를 수정하는 것입니다.