Example #1
0
	def setInitState(self, initState=None):
		self.gameState = initState
		self.stateToFeatures()
		if self.algo == "dqn":
			self.algo = algorithms.Algorithms("dqn",self.state.size,self.numAngles*self.numForces,self.state)
		elif self.algo == "semi-grad-sarsa":
			self.algo = algorithms.Algorithms("semi-grad-sarsa",self.state.size,self.numAngles*self.numForces,self.state, numAngles=self.numAngles, numForces=self.numForces)
		elif self.algo == "closest-greedy":
			self.algo = algorithms.Algorithms("closest-greedy",self.state.size,self.numAngles*self.numForces,self.state, numAngles=self.numAngles, numForces=self.numForces)
		elif self.algo == "random":
			self.algo = algorithms.Algorithms("random",self.state.size,self.numAngles*self.numForces,self.state, numAngles=self.numAngles, numForces=self.numForces)	
Example #2
0
def TestCorrelation(item_user_matrix, user):
    algo = algorithms.Algorithms()
    algo.setMatrix(item_user_matrix)

    # get user items
    all_user_items = item_user_matrix.iloc[
        item_user_matrix.index.get_loc(user), :]
    unique_user_items = all_user_items.index[all_user_items.notnull()]

    all_recommended_items = []
    # go over each item the user has rated
    for item in unique_user_items:
        results = algo.calculateCorrelation(item)

        # add only those results that are unique
        for result in results:
            if result not in all_recommended_items:
                all_recommended_items.append(result)

    # remove items the user has already seen
    for already_seen_item in unique_user_items:
        if already_seen_item in all_recommended_items:
            all_recommended_items.remove(already_seen_item)

    return all_recommended_items
Example #3
0
    def UpdateVideoItem(self, item):
        """
        Accepts an item. It returns an updated item. 
        """
        #logFile.debug('starting UpdateVideoItem for %s (%s)',item.name, self.channelName)
        item.thumb = self.CacheThumb(item.thumbUrl)
        # open the url to read the media url
        data = uriHandler.Open(item.url, pb=False)

        # create the algorithm helper
        algHelper = algorithms.Algorithms()

        results = common.DoRegexFindAll(self.mediaUrlRegex, data)
        megavideoResults = common.DoRegexFindAll(
            '<param name="movie" value="([^"]+)"></param>', data)
        veohResults = common.DoRegexFindAll(
            'src="http://www.veoh.com/[^?]+\?permalinkId=([^&]+)', data)
        googleResults = common.DoRegexFindAll(
            '(http://video.google.com/googleplayer.swf\?docId=[^"]+)"', data)

        # First give it a try using the default regex
        if len(results) > 0:
            item.mediaurl = results[-1]
            logFile.debug("MediaUrl found: %s", item.mediaurl)
            item.complete = True

        # If there were no results, try megavideo.com
        elif len(megavideoResults) > 0:
            url = megavideoResults[-1]
            url = algHelper.DecodeItemUrl(url)
            data = uriHandler.Open(url, pb=True)
            item.mediaurl = algHelper.ExtractMediaUrl(url, data)

        # then try veoh
        elif len(veohResults) > 0:
            url = "http://www.veoh.com/videos/%s?cmpTag" % veohResults[-1]
            url = algHelper.DecodeItemUrl(url)
            data = uriHandler.Open(url, pb=True)
            item.mediaurl = algHelper.ExtractMediaUrl(url, data)

        # then google
        elif len(googleResults) > 0:
            url = googleResults[-1]
            url = algHelper.DecodeItemUrl(url)
            data = uriHandler.Open(url, pb=True)
            item.mediaurl = algHelper.ExtractMediaUrl(url, data)

        # If all else fails, return an error
        else:
            item.mediaurl = ""
            logFile.error("MediaUrl not found in url: %s", item.url)
            item.complete = False

        logFile.debug("%s was updated with mediaurl: %s", item.name,
                      item.mediaurl)
        return item
Example #4
0
def get_keyword():
    if not request.json['title'] and not request.json[
            'description'] and not request.json['uniqueCrawledId']:
        return abort(
            400,
            errors="You need to send paramter text with query Id or requestId")
    query_str = request.json['title']
    data_id = request.json['description']
    crawledId = request.json['uniqueCrawledId']
    return json.dumps(algo.Algorithms().initialize(query_str, data_id,
                                                   crawledId))
Example #5
0
def test():
    if not request.args.get('text'):
        return json.dumps({"error": "text parameter is missing."})
    query_str = request.args.get('text')
    data_id = request.args.get('amazonDataId') if (
        request.args.get('amazonDataId')) else 111111
    crawledId = request.args.get('uniqueCrawledId') if (
        request.args.get('uniqueCrawledId')) else 000000
    type = 'D' if (request.args.get('type')
                   and request.args.get('type') == 'D') else 'T'
    return json.dumps(algo.Algorithms().process_algorithm(
        query_str, data_id, crawledId, 0, type))
Example #6
0
 def __init__(self, nodeDict, adjMatrix, instanceName, solution):
     self.nodeDict = nodeDict
     self.adjMatrix = adjMatrix
     self.counts = len(nodeDict)
     self.edgeDict = {}
     self.instanceName = instanceName
     self.solution = solution
     for i in range(self.counts):
         for j in range(i + 1, self.counts):
             vertices = (i, j)
             self.edgeDict[vertices] = self.adjMatrix[i, j]
     self.Bounds = bounds.Bounds(self.nodeDict, self.adjMatrix)
     self.solutions = algorithms.Algorithms(self.nodeDict, self.adjMatrix,
                                            self.counts, self.edgeDict)
Example #7
0
def CenteredCosineSimilarity(item_user_matrix, user):
    #initate class
    algo = algorithms.Algorithms()
    algo.setMatrix(item_user_matrix)

    # get user items
    unique_user_items = item_user_matrix[user][
        item_user_matrix[user].notnull()]
    unique_user_items = unique_user_items.index

    all_recommended_items = []
    for item in unique_user_items:
        results = algo.calculateCosineSimilarity(item)
        # add only those results that are unique
        for result in results[0]:
            if result not in all_recommended_items:
                all_recommended_items.append(result)

    # remove items the user has already seen
    for already_seen_item in unique_user_items:
        if already_seen_item in all_recommended_items:
            all_recommended_items.remove(already_seen_item)

    return all_recommended_items
Example #8
0
        print("Digits dataset")
        print("************")

        # Loading the dataset
        digits = datasets.load_digits()
        x = digits.data
        y = digits.target

    # Standardizing data
    sc_x = StandardScaler()
    x_std = sc_x.fit_transform(x)

    # Splitting data
    x_std_tr, x_std_ts, y_tr, y_ts = train_test_split(x_std, y, test_size=0.3, random_state=1)

    algorithm = algorithms.Algorithms(n_components=2, kernel="rbf", gamma=15, c=100, seed=1, x_train=x_std_tr,
                                      y_train=y_tr, x_test=x_std_ts)

    # ## Regular Logistic Regression ##
    orig_logreg_y_ts_pred = algorithm.run_logisticreg()
    accuracy = np.sum(orig_logreg_y_ts_pred == y_ts) / len(y_ts)
    print("LogReg accuracy before dim reduction: " + str(accuracy))

    for name in ["PCA", "LDA", "Kernel_PCA"]:

        print("\n\n" + name)
        # Reducing the dimensions
        x_tr_reduc, x_ts_reduc = algorithm.call("run_" + name.lower())

        # Logistic Regression on reduced dimensions
        algorithm.x_tr, algorithm.x_ts = x_tr_reduc, x_ts_reduc
        logreg_y_ts_pred = algorithm.run_logisticreg()