コード例 #1
0
    def testReadme(self):
        openscoring = Openscoring()

        pmml = os.path.join(os.path.dirname(__file__), "resources",
                            "DecisionTreeIris.pmml")

        with open(pmml, "rb") as instream:
            pmmlBytes = instream.read()
        self.assertTrue(isinstance(pmmlBytes, bytes))
        self.assertEqual(4306, len(pmmlBytes))
        modelResponse = openscoring.deploy("Iris", pmmlBytes)
        self.assertEqual("Iris", modelResponse.id)

        modelResponse = openscoring.deployFile("Iris", pmml)
        self.assertEqual("Iris", modelResponse.id)

        arguments = {
            "Sepal_Length": 5.1,
            "Sepal_Width": 3.5,
            "Petal_Length": 1.4,
            "Petal_Width": 0.2
        }
        result = openscoring.evaluate("Iris", arguments)
        self.assertEqual(
            {
                "Species": "setosa",
                "Probability_setosa": 1.0,
                "Probability_versicolor": 0.0,
                "Probability_virginica": 0.0,
                "Node_Id": "2"
            }, result)
        evaluationRequest = EvaluationRequest("record-001", arguments)
        evaluationResponse = openscoring.evaluate("Iris", evaluationRequest)
        self.assertEqual(evaluationRequest.id, evaluationResponse.id)
        self.assertEqual("setosa", evaluationResponse.result["Species"])

        inCsv = os.path.join(os.path.dirname(__file__), "resources",
                             "input.csv")
        outCsv = os.path.join(tempfile.gettempdir(), "output.csv")

        df = pandas.read_csv(inCsv, sep=",")

        result = openscoring.evaluateCsv("Iris", df)
        self.assertEqual(df["Id"].tolist(), result["Id"].tolist())
        self.assertEqual(["setosa", "versicolor", "virginica"],
                         result["Species"].tolist())

        self.assertFalse(os.path.isfile(outCsv))
        openscoring.evaluateCsvFile("Iris", inCsv, outCsv)
        self.assertTrue(
            os.path.isfile(outCsv) and os.path.getsize(outCsv) > 10)

        os.remove(outCsv)

        openscoring.undeploy("Iris")

        with self.assertRaises(Exception) as context:
            openscoring.evaluate("Iris", arguments)
        self.assertEqual("Model \"Iris\" not found", str(context.exception))
コード例 #2
0
class FNDOpenScoring:
    def __init__(self):
        self.scoring = Openscoring("http://localhost:8080/openscoring")
        self.arguments = {"sourceTaggedAsFakeCount": 2.0, "reporterScore": 3.0}

    def _deploy(self):
        self.scoring.deployFile("FakeNewsDetector", "FakeNewsAIModel.pmml",
                                **{"auth": ("admin", "adminadmin")})

    def _setArgs(self, jsonString):
        jsonObj = json.loads(jsonString)
        self.arguments["similarWebAvgScore"] = jsonObj['average']
        self.arguments["similarWebStdScore"] = jsonObj['variance']
        self.arguments["fakeFactSitesCount"] = jsonObj['blacklisted']

    def __call__(self, jsonString):
        self._deploy()
        self._setArgs(jsonString)
        result = self.scoring.evaluate("FakeNewsDetector", self.arguments)
        return result
コード例 #3
0
ファイル: app.py プロジェクト: nmud19/hosting_test
def get_predictions(pw, pl, sw, sl):
    """
    Get predictions by source
    :param pw:
    :param pl:
    :param sw:
    :param sl:
    :return:
    """
    arguments = {
        "sepal_length": float(sl),
        "sepal_width": float(sw),
        "petal_length": float(pl),
        "petal_width": float(pw)
    }
    print(arguments)
    from openscoring import Openscoring
    os = Openscoring("http://localhost:8080/openscoring")
    result = os.evaluate("Iris", arguments)

    print(result)
    return html.Div([
        html.H3("The class detected was  : {}".format(result['species'])),
    ])
コード例 #4
0
	def testReadme(self):
		openscoring = Openscoring(base_url = "http://localhost:8080/openscoring", token = os.getenv("OPENSCORING_TOKEN", None))

		pmml = os.path.join(os.path.dirname(__file__), "resources", "DecisionTreeIris.pmml")

		with open(pmml, "rb") as instream:
			pmmlBytes = instream.read()
		self.assertTrue(isinstance(pmmlBytes, bytes))
		self.assertEqual(2919, len(pmmlBytes))
		modelResponse = openscoring.deploy("Iris", pmmlBytes)
		self.assertEqual("Iris", modelResponse.id)

		modelResponse = openscoring.deployFile("Iris", pmml)
		self.assertEqual("Iris", modelResponse.id)

		arguments = {
			"Sepal.Length" : 5.1,
			"Sepal.Width" : 3.5,
			"Petal.Length" : 1.4,
			"Petal.Width" : 0.2
		}
		results = openscoring.evaluate("Iris", arguments)
		self.assertEqual({"Species" : "setosa", "probability(setosa)" : 1.0, "probability(versicolor)" : 0.0, "probability(virginica)" : 0.0}, results)
		evaluationRequest = EvaluationRequest("record-001", arguments)
		evaluationResponse = openscoring.evaluate("Iris", evaluationRequest)
		self.assertEqual(evaluationRequest.id, evaluationResponse.id)
		self.assertEqual("setosa", evaluationResponse.results["Species"])

		batchArguments = [
			{
				"Petal.Length" : 1.4,
				"Petal.Width" : 0.2
			},
			{
				"Petal.Length" : 4.7,
				"Petal.Width" : 1.4
			},
			{
				"Petal.Length" : 3.6,
				"Petal.Width" : 2.5
			}
		]
		batchResults = openscoring.evaluateBatch("Iris", batchArguments)
		self.assertEquals(3, len(batchResults))
		self.assertEquals({"Species" : "setosa", "probability(setosa)" : 1.0, "probability(versicolor)" : 0.0, "probability(virginica)" : 0.0}, batchResults[0])
		self.assertEquals({"Species" : "versicolor", "probability(setosa)" : 0.0, "probability(versicolor)" : (49.0 / 54.0), "probability(virginica)" : (5.0 / 54.0)}, batchResults[1])
		self.assertEquals({"Species" : "virginica", "probability(setosa)" : 0.0, "probability(versicolor)" : (1.0 / 46.0), "probability(virginica)" : (45.0 / 46.0)}, batchResults[2])
		evaluationRequests = [EvaluationRequest(None, arguments) for arguments in batchArguments]
		batchEvaluationRequest = BatchEvaluationRequest("batch-A", evaluationRequests)
		batchEvaluationResponse = openscoring.evaluateBatch("Iris", batchEvaluationRequest)
		self.assertEqual(batchEvaluationRequest.id, batchEvaluationResponse.id)
		evaluationResponses = batchEvaluationResponse.responses
		self.assertEqual(3, len(evaluationResponses))
		self.assertEqual("setosa", evaluationResponses[0].results["Species"])
		self.assertEqual("versicolor", evaluationResponses[1].results["Species"])
		self.assertEqual("virginica", evaluationResponses[2].results["Species"])

		inCsv = os.path.join(os.path.dirname(__file__), "resources", "input.csv")
		outCsv = os.path.join(tempfile.gettempdir(), "output.csv")

		dfArguments = pandas.read_csv(inCsv, sep = ",")
		dfResults = openscoring.evaluateCsv("Iris", dfArguments)
		self.assertEqual((3, 1 + 4), dfResults.shape)
		self.assertEqual(dfArguments["Id"].tolist(), dfResults["Id"].tolist())
		self.assertEqual(["setosa", "versicolor", "virginica"], dfResults["Species"].tolist())

		self.assertFalse(os.path.isfile(outCsv))
		openscoring.evaluateCsvFile("Iris", inCsv, outCsv)
		self.assertTrue(os.path.isfile(outCsv) and os.path.getsize(outCsv) > 10)

		os.remove(outCsv)

		openscoring.undeploy("Iris")

		with self.assertRaises(Exception) as context:
			openscoring.evaluate("Iris", arguments)
		self.assertEqual("Not Found", str(context.exception))
コード例 #5
0
class PmmlInferenceService(AbstractInferenceService):
  """
  The service to load PMML model and make inference.
  """

  def __init__(self, model_name, model_base_path, verbose=False):
    """
    Initialize the service.
        
    Args:
      model_name: The name of the model.
      model_base_path: The file path of the model.
    Return:
      None
    """

    super(PmmlInferenceService, self).__init__()

    self.model_name = model_name
    self.model_base_path = model_base_path
    self.model_version_list = [1]
    self.model_graph_signature = ""
    self.platform = "PMML"

    # Load model
    from openscoring import Openscoring
    openscoring_server_endpoint = "localhost:8080"
    kwargs = {"auth" : ("admin", "adminadmin")}
    self.openscoring = Openscoring("http://{}/openscoring".format(openscoring_server_endpoint))
    self.openscoring.deployFile(self.model_name, self.model_base_path, **kwargs)

    self.model_graph_signature = "No signature for PMML models"
    self.verbose = verbose

  def inference(self, json_data):
    """
    Make inference with the current Session object and JSON request data.
        
    Args:
      json_data: The JSON serialized object with key and array data.
                 Example is {"model_version": 1, "data": {"keys": [[1.0], [2.0]], "features": [[10, 10, 10, 8, 6, 1, 8, 9, 1], [6, 2, 1, 1, 1, 1, 7, 1, 1]]}}.
    Return:
      The dictionary with key and array data.
      Example is {"keys": [[11], [2]], "softmax": [[0.61554497, 0.38445505], [0.61554497, 0.38445505]], "prediction": [0, 0]}.
    """

    # 1. Build inference data
    # Example: arguments = {"Sepal_Length" : 5.1, "Sepal_Width" : 3.5, "Petal_Length" : 1.4, "Petal_Width" : 0.2}
    request_json_data =  json_data["data"]

    # 2. Do inference
    if self.verbose:
      start_time = time.time()

    # Example: {'Probability_setosa': 1.0, 'Probability_versicolor': 0.0, 'Node_Id': '2', 'Species': 'setosa', 'Probability_virginica': 0.0}
    predict_result = self.openscoring.evaluate(self.model_name, request_json_data)

    if self.verbose:
      logging.debug("Inference time: {} s".format(time.time() - start_time))

    # 3. Build return data
    result = {
        "result": predict_result,
    }

    if self.verbose:
      logging.debug("Inference result: {}".format(result))

    return result
コード例 #6
0
#!/usr/bin/env python

from openscoring import Openscoring

os = Openscoring("http://localhost:8080/openscoring")

kwargs = {"auth": ("admin", "adminadmin")}

model_file_path = "../../models/pmml_iris/DecisionTreeIris.pmml"
model_name = "PmmlModel"
os.deployFile(model_name, model_file_path, **kwargs)

arguments = {
    "Sepal_Length": 5.1,
    "Sepal_Width": 3.5,
    "Petal_Length": 1.4,
    "Petal_Width": 0.2
}

result = os.evaluate(model_name, arguments)
print(result)