def wrap_high_level_accuracy(state): model = SLRModel( features=Features(Feature("Years", int, 1), ), predict=Feature("Salary", int, 1), location="tempdir", ) train( model, { "Years": 0, "Salary": 10 }, { "Years": 1, "Salary": 20 }, { "Years": 2, "Salary": 30 }, { "Years": 3, "Salary": 40 }, ) yield
def wrap_noasync_accuracy(state): model = SLRModel( features=Features(Feature("Years", int, 1), ), predict=Feature("Salary", int, 1), directory="tempdir", ) train( model, { "Years": 0, "Salary": 10 }, { "Years": 1, "Salary": 20 }, { "Years": 2, "Salary": 30 }, { "Years": 3, "Salary": 40 }, ) yield
async def main(): # Load the model using the entrypoint listed on the model plugins page SLRModel = Model.load("slr") # Configure the model model = SLRModel( features=Features(Feature("Years", int, 1)), predict=Feature("Salary", int, 1), # You can set this as any archive format like zip, tgz, etc. location="slr-model.tar.gz", ) # Train the model await train( model, { "Years": 0, "Expertise": 1, "Trust": 0.1, "Salary": 10 }, { "Years": 1, "Expertise": 3, "Trust": 0.2, "Salary": 20 }, )
async def test_models(self): with tempfile.TemporaryDirectory() as tempdir: # Model the HTTP API will pre-load model = SLRModel( features=Features(Feature("f1", float, 1)), predict=Feature("ans", int, 1), directory=tempdir, ) # y = m * x + b for equation SLR is solving for m = 5 b = 3 # Train the model await train(model, *[{ "f1": x, "ans": m * x + b } for x in range(0, 10)]) await accuracy( model, *[{ "f1": x, "ans": m * x + b } for x in range(10, 20)]) async with ServerRunner.patch(HTTPService.server) as tserver: cli = await tserver.start( HTTPService.server.cli( "-insecure", "-port", "0", "-models", "mymodel=slr", "-model-mymodel-directory", tempdir, "-model-mymodel-features", "f1:float:1", "-model-mymodel-predict", "ans:int:1", )) async with self.post( cli, f"/model/mymodel/predict/0", json={ f"record_{x}": { "features": { "f1": x } } for x in range(20, 30) }, ) as response: response = await response.json() records = response["records"] self.assertEqual(len(records), 10) for record in records.values(): should_be = m * record["features"]["f1"] + b prediction = record["prediction"]["ans"]["value"] percent_error = abs(should_be - prediction) / should_be self.assertLess(percent_error, 0.2)
async def main(): # Load the model using the entrypoint listed on the model plugins page SLRModel = Model.load("slr") # Configure the model model = SLRModel( features=Features(Feature("Years", int, 1)), predict=Feature("Salary", int, 1), directory="slr-model", ) # Train the model await train( model, { "Years": 0, "Expertise": 1, "Trust": 0.1, "Salary": 10 }, { "Years": 1, "Expertise": 3, "Trust": 0.2, "Salary": 20 }, )
def setUpClass(cls): # Create a temporary directory to store the trained model cls.model_dir = tempfile.TemporaryDirectory() # Create an instance of the model cls.model = MySLRModel( features=Features(Feature("X", float, 1)), predict=Feature("Y", float, 1), directory=cls.model_dir.name, )
def setUpClass(cls): # Create a temporary directory to store the trained model cls.model_dir = tempfile.TemporaryDirectory() # Create an instance of the model cls.model = MySLRModel( features=Features(Feature("X", float, 1)), predict=Feature("Y", float, 1), location=cls.model_dir.name, ) cls.scorer = MeanSquaredErrorAccuracy()
async def _add_fake_model(self): with tempfile.TemporaryDirectory() as tempdir: async with FakeModel( FakeModelConfig( location=tempdir, features=Features(Feature("by_ten")), predict=Feature("by_ten"), )) as model: self.model = self.cli.app["models"][self.mlabel] = model async with model() as mctx: self.mctx = self.cli.app["model_contexts"][ self.mlabel] = mctx yield
def setUpClass(cls): cls.model_dir = tempfile.TemporaryDirectory() cls.model = PyTorchNeuralNetwork( classifications=["rock", "paper", "scissors"], features=Features(Feature("image", int, 300 * 300)), predict=Feature("label", int, 1), directory=cls.model_dir.name, network=RockPaperScissorsModel, epochs=1, batch_size=32, imageSize=150, validation_split=0.2, loss=Loss, optimizer="Adam", enableGPU=True, )
def setUpClass(cls): # Create a temporary directory to store the trained model cls.model_dir = tempfile.TemporaryDirectory() # Create the training data cls.train_data = [] for x, y in TRAIN_DATA: cls.train_data.append({"X": x, "Y": y}) # Create the test data cls.test_data = [] for x, y in TEST_DATA: cls.test_data.append({"X": x, "Y": y}) # Create an instance of the model cls.model = LogisticRegression( directory=cls.model_dir.name, predict=DefFeature("Y", float, 1), features=Features(DefFeature("X", float, 1)), )
async def main(): # Configure the model model = MySLRModel( features=Features(Feature("Years", int, 1)), predict=Feature("Salary", int, 1), directory="model", ) # Train the model await train(model, "train.csv") # Assess accuracy print("Accuracy:", await accuracy(model, "test.csv")) # Make predictions async for i, features, prediction in predict(model, "predict.csv"): features["Salary"] = prediction["Salary"]["value"] print(features)
def setUpClass(cls): cls.model_dir = tempfile.TemporaryDirectory() cls.model = PyTorchNeuralNetwork( classifications=["rock", "paper", "scissors"], features=Features(Feature("image", int, 300 * 300)), predict=Feature("label", int, 1), directory=cls.model_dir.name, network=RockPaperScissorsModel, epochs=1, batch_size=32, imageSize=150, validation_split=0.2, loss=Loss, optimizer="Adam", enableGPU=True, ) cls.traindir = asyncio.run( cached_download_unpack_archive( "https://storage.googleapis.com/laurencemoroney-blog.appspot.com/rps.zip", "rps.zip", "traindir", "c6a9119b0c6a0907b782bd99e04ce09a0924c0895df6a26bc6fb06baca4526f55e51f7156cceb4791cc65632d66085e8", ) ) cls.testdir = asyncio.run( cached_download_unpack_archive( "https://storage.googleapis.com/laurencemoroney-blog.appspot.com/rps-test-set.zip", "rps-test-set.zip", "testdir", "fc45a0ebe58b9aafc3cd5a60020fa042d3a19c26b0f820aee630b9602c8f53dd52fd40f35d44432dd031dea8f30a5f66", ) ) cls.predictdir = asyncio.run( cached_download_unpack_archive( "https://storage.googleapis.com/laurencemoroney-blog.appspot.com/rps-validation.zip", "rps-validation.zip", "predictdir", "375457bb95771ffeace2beedab877292d232f31e76502618d25e0d92a3e029d386429f52c771b05ae1c7229d2f5ecc29", ) )
async def main(): # Configure the model model = MySLRModel( features=Features(Feature("Years", int, 1)), predict=Feature("Salary", int, 1), location="model", ) # Train the model await train(model, "train.csv") # Assess accuracy scorer = MeanSquaredErrorAccuracy() print( "Accuracy:", await score(model, scorer, Feature("Salary", int, 1), "test.csv"), ) # Make predictions async for i, features, prediction in predict(model, "predict.csv"): features["Salary"] = prediction["Salary"]["value"] print(features)
async def main(): model = LinearRegressionModel( features=Features( DefFeature("Years", int, 1), DefFeature("Expertise", int, 1), DefFeature("Trust", float, 1), ), predict=DefFeature("Salary", int, 1), ) # Train the model await train( model, {"Years": 0, "Expertise": 1, "Trust": 0.1, "Salary": 10}, {"Years": 1, "Expertise": 3, "Trust": 0.2, "Salary": 20}, {"Years": 2, "Expertise": 5, "Trust": 0.3, "Salary": 30}, {"Years": 3, "Expertise": 7, "Trust": 0.4, "Salary": 40}, ) # Assess accuracy print( "Accuracy:", await accuracy( model, {"Years": 4, "Expertise": 9, "Trust": 0.5, "Salary": 50}, {"Years": 5, "Expertise": 11, "Trust": 0.6, "Salary": 60}, ), ) # Make prediction async for i, features, prediction in predict( model, {"Years": 6, "Expertise": 13, "Trust": 0.7}, {"Years": 7, "Expertise": 15, "Trust": 0.8}, ): features["Salary"] = prediction["Salary"]["value"] print(features)
from dffml import CSVSource, Features, Feature from dffml.noasync import train, accuracy, predict from dffml_model_scikit import LinearRegressionModel model = LinearRegressionModel( features=Features( Feature("Years", int, 1), Feature("Expertise", int, 1), Feature("Trust", float, 1), ), predict=Feature("Salary", int, 1), directory="tempdir", ) # Train the model train(model, "train.csv") # Assess accuracy (alternate way of specifying data source) print("Accuracy:", accuracy(model, CSVSource(filename="test.csv"))) # Make prediction for i, features, prediction in predict( model, { "Years": 6, "Expertise": 13, "Trust": 0.7 }, { "Years": 7, "Expertise": 15,
from dffml import Features, DefFeature from dffml.noasync import train, accuracy, predict from dffml.model.slr import SLRModel model = SLRModel( features=Features(DefFeature("f1", float, 1)), predict=DefFeature("ans", int, 1), ) # Train the model train(model, "dataset.csv") # Assess accuracy (alternate way of specifying data source) print("Accuracy:", accuracy(model, "dataset.csv")) # Make prediction for i, features, prediction in predict(model, {"f1": 0.8, "ans": 0}): features["ans"] = prediction["ans"]["value"] print(features)
async def main(): model = LinearRegressionModel( features=Features( Feature("Years", int, 1), Feature("Expertise", int, 1), Feature("Trust", float, 1), ), predict=Feature("Salary", int, 1), location="tempdir", ) # Train the model await train( model, { "Years": 0, "Expertise": 1, "Trust": 0.1, "Salary": 10 }, { "Years": 1, "Expertise": 3, "Trust": 0.2, "Salary": 20 }, { "Years": 2, "Expertise": 5, "Trust": 0.3, "Salary": 30 }, { "Years": 3, "Expertise": 7, "Trust": 0.4, "Salary": 40 }, ) # Assess accuracy scorer = MeanSquaredErrorAccuracy() print( "Accuracy:", await score( model, scorer, Feature("Salary", int, 1), { "Years": 4, "Expertise": 9, "Trust": 0.5, "Salary": 50 }, { "Years": 5, "Expertise": 11, "Trust": 0.6, "Salary": 60 }, ), ) # Make prediction async for i, features, prediction in predict( model, { "Years": 6, "Expertise": 13, "Trust": 0.7 }, { "Years": 7, "Expertise": 15, "Trust": 0.8 }, ): features["Salary"] = prediction["Salary"]["value"] print(features)
from dffml import Feature, Features from dffml.noasync import score, train from dffml_model_scratch.anomalydetection import AnomalyModel from dffml_model_scratch.anomaly_detection_scorer import ( AnomalyDetectionAccuracy, ) # Configure the model model = AnomalyModel( features=Features(Feature("A", int, 2),), predict=Feature("Y", int, 1), location="model", ) # Train the model train(model, "trainex.csv") # Assess accuracy for test set scorer = AnomalyDetectionAccuracy() print( "Test set F1 score :", score(model, scorer, Feature("Y", int, 1), "testex.csv"), ) # Assess accuracy for training set print( "Training set F1 score :", score(model, scorer, Feature("Y", int, 1), "trainex.csv"),
from dffml import CSVSource, Features, Feature from dffml.noasync import train, accuracy, predict from dffml_model_tensorflow_hub.text_classifier import TextClassificationModel model = TextClassificationModel( features=Features(Feature("sentence", str, 1)), predict=Feature("sentiment", int, 1), classifications=[0, 1, 2], clstype=int, directory="tempdir", ) # Train the model train(model, "train.csv") # Assess accuracy (alternate way of specifying data source) print("Accuracy:", accuracy(model, CSVSource(filename="test.csv"))) # Make prediction for i, features, prediction in predict( model, {"sentence": "This track is horrible"}, ): features["sentiment"] = prediction["sentiment"]["value"] print(features)
XGBClassifierModelConfig, ) iris = load_iris() y = iris["target"] X = iris["data"] trainX, testX, trainy, testy = train_test_split(X, y, test_size=0.1, random_state=123) # Configure the model model = XGBClassifierModel( XGBClassifierModelConfig( features=Features(Feature( "data", float, )), predict=Feature("target", float, 1), directory="model", max_depth=3, learning_rate=0.01, n_estimators=200, reg_lambda=1, reg_alpha=0, gamma=0, colsample_bytree=0, subsample=1, )) # Train the model train(model, *[{"data": x, "target": y} for x, y in zip(trainX, trainy)])
# block 4 x = self.pooling(self.relu(self.conv3(x))) # fully connected layer x = self.linear(x.view(-1, 16 * 9 * 9)) return x RockPaperScissorsModel = ConvNet() Loss = CrossEntropyLossFunction() # Define the dffml model config model = PyTorchNeuralNetwork( classifications=["rock", "paper", "scissors"], features=Features(Feature("image", int, 300 * 300)), predict=Feature("label", int, 1), directory="rps_model", network=RockPaperScissorsModel, epochs=10, batch_size=32, imageSize=150, validation_split=0.2, loss=Loss, optimizer="Adam", enableGPU=True, patience=2, ) # Define source for training image dataset train_source = DirectorySource(
from dffml import CSVSource, Features, DefFeature from dffml.noasync import train, accuracy, predict from dffml_model_tensorflow.dnnr import DNNRegressionModel model = DNNRegressionModel( features=Features(DefFeature("Feature1", float, 1), DefFeature("Feature2", float, 1)), predict=DefFeature("TARGET", float, 1), epochs=300, steps=2000, hidden=[8, 16, 8], ) # Train the model train(model, "train.csv") # Assess accuracy (alternate way of specifying data source) print("Accuracy:", accuracy(model, CSVSource(filename="test.csv"))) # Make prediction for i, features, prediction in predict(model, { "Feature1": 0.21, "Feature2": 0.18, "TARGET": 0.84 }): features["TARGET"] = prediction["TARGET"]["value"] print(features)
import asyncio from dffml import train, Features, DefFeature from dffml.operation.output import GetSingle from dffml.df.memory import MemoryOrchestrator from dffml.operation.mapping import create_mapping from dffml.operation.preprocess import literal_eval from dffml.df.types import DataFlow, Input, InputFlow from dffml.operation.io import AcceptUserInput, print_output from dffml.operation.model import model_predict, ModelPredictConfig from dffml.model.slr import SLRModel slr_model = SLRModel( features=Features(DefFeature("Years", int, 1), ), predict=DefFeature("Salary", int, 1), ) # This Dataflow takes input from stdio using `AcceptUserInput` # operation. The string input which corresponds to feature `Years` # is converted to `int`/`float` by # `literal_eval` operation. # `create_mapping` operation creates a mapping using the numeric output # of `literal_eval` eg. {"Years":34}. # The mapping is then fed to `model_predict` operation which # uses the `slr` model trained above to make prediction. The prediction is then printed to # stdout using `print_output` operation. dataflow = DataFlow( operations={ "get_user_input": AcceptUserInput, "literal_eval_input": literal_eval, "create_feature_map": create_mapping,
from dffml import CSVSource, Features, DefFeature from dffml.noasync import train, accuracy, predict from dffml_model_tensorflow.dnnc import DNNClassifierModel model = DNNClassifierModel( features=Features( DefFeature("SepalLength", float, 1), DefFeature("SepalWidth", float, 1), DefFeature("PetalLength", float, 1), DefFeature("PetalWidth", float, 1), ), predict=DefFeature("classification", int, 1), epochs=3000, steps=20000, classifications=[0, 1, 2], clstype=int, ) # Train the model train(model, "iris_training.csv") # Assess accuracy (alternate way of specifying data source) print("Accuracy:", accuracy(model, CSVSource(filename="iris_test.csv"))) # Make prediction for i, features, prediction in predict( model, { "PetalLength": 4.2, "PetalWidth": 1.5, "SepalLength": 5.9,
from dffml import CSVSource, Features, Feature from dffml.noasync import train, accuracy, predict from dffml_model_scratch.logisticregression import LogisticRegression model = LogisticRegression( features=Features(Feature("f1", float, 1)), predict=Feature("ans", int, 1), ) # Train the model train(model, "dataset.csv") # Assess accuracy (alternate way of specifying data source) print("Accuracy:", accuracy(model, CSVSource(filename="dataset.csv"))) # Make prediction for i, features, prediction in predict(model, {"f1": 0.8, "ans": 0}): features["ans"] = prediction["ans"]["value"] print(features)
async def test_scorer(self): with tempfile.TemporaryDirectory() as tempdir: model = SLRModel( features=Features(Feature("f1", float, 1)), predict=Feature("ans", int, 1), location=tempdir, ) # y = m * x + b for equation SLR is solving for m = 5 b = 3 # Train the model await train(model, *[{ "f1": x, "ans": m * x + b } for x in range(0, 10)]) source = JSONSource( filename=pathlib.Path(tempdir, "source.json"), allowempty=True, readwrite=True, ) # Record the source will have in it await save( source, *[ Record( str(i), data={"features": { "f1": x, "ans": (m * x) + b }}, ) for i, x in enumerate(range(10, 20)) ], ) async with ServerRunner.patch(HTTPService.server) as tserver: cli = await tserver.start( HTTPService.server.cli( "-insecure", "-port", "0", "-models", "mymodel=slr", "-model-mymodel-location", tempdir, "-model-mymodel-features", "f1:float:1", "-model-mymodel-predict", "ans:int:1", "-features", "ans:int:1", "-sources", "mysource=json", "-source-mysource-filename", str(source.config.filename), "-scorers", "myscorer=mse", )) async with self.post(cli, "/scorer/myscorer/mymodel/score", json=["mysource"]) as r: self.assertEqual(await r.json(), {"accuracy": 0.0})
from dffml import Feature, Features from dffml.noasync import train, accuracy, predict from REPLACE_IMPORT_PACKAGE_NAME.myslr import MySLRModel model = MySLRModel( features=Features(Feature("x", float, 1)), predict=Feature("y", int, 1), directory="tempdir", ) # Train the model train(model, "train.csv") # Assess accuracy (alternate way of specifying data source) print("Accuracy:", accuracy(model, "test.csv")) # Make prediction for i, features, prediction in predict(model, "predict.csv"): features["y"] = prediction["y"]["value"] print(features)
from dffml import Features, Feature from dffml.noasync import train, accuracy, predict from dffml_model_autosklearn import AutoSklearnRegressorModel model = AutoSklearnRegressorModel( features=Features( Feature("Feature1", float, 1), Feature("Feature2", float, 1), ), predict=Feature("TARGET", float, 1), directory="tempdir-python", time_left_for_this_task=120, ) def main(): # Train the model train(model, "train.csv") # Assess accuracy print("Accuracy:", accuracy(model, "test.csv")) # Make prediction for i, features, prediction in predict(model, "predict.csv"): features["TARGET"] = prediction["TARGET"]["value"] print(features) if __name__ == "__main__": main()