def main(_):
parser = argparse.ArgumentParser()
parser.add_argument('--option', dest='option', type=str, default='train', help='actions: train, test, or predict')
args = parser.parse_args()
if args.option not in ['train', 'test', 'predict']:
print('invalid option: ', args.option)
print("Please input a option: train, test, or predict")
else:
sess = tf.Session(config=tf.ConfigProto(gpu_options=tf.GPUOptions(allow_growth=True)))
model = ModelRunner(sess, configure())
getattr(model, args.option)()
pass
def main():
# Used to run all of the respect ML algorithms on the data
csv = "SPY_data.csv"
stockdata = pd.read_csv(csv)
print(" ----- Output for SVM Model ----- ", "\n")
stockdata2 = stockdata.set_index(stockdata.columns[0])
svm_output(stockdata2)
print("\n", " ----- Output for KNN Model ----- ", "\n")
model1 = KNN(stockdata2)
model1.perform_KNN()
print("\n", " ----- Output for LDA & QDA Model ----- ", "\n")
runldaqda(stockdata)
print("\n", " ----- Output for Random Forest ----- ", "\n")
model2 = ModelRunner()
class Visualiser(object): def __init__(self, name, model_path, settings): self.name = name self.provider = ElementProvider(model_path) self.model_runner = ModelRunner(model_path) self.animation_data = AnimationData(settings) self.settings = settings def visualise(self, images, backgrounds, run_speed = 1000): (placements, stocks, _) = self.provider.provide() groups = self.model_runner.run(stocks, placements, self.settings) drawer = GroupDrawer(self.name, self.settings, groups) drawer.draw(images, backgrounds) self.animation_data.updateData(groups) self.animation_data.exportRunData() self.adjustRunSpeed(run_speed) def adjustRunSpeed(self, run_speed): self.animation_data.adjustRunSpeed(run_speed) self.animation_data.exportSettings()
media_player.play()
motor_driver.__start_motor__()
print()
print("Setting everything up...")
start = time.time()
# Setting up main objects that control execution
audio_recorder = AudioRecorder()
audio_recorder.__start_audio__()
motor_driver = MotorDriver()
model_runner = ModelRunner()
media_player = vlc.MediaPlayer(LULLABY_FILE)
old_volume = media_player.audio_get_volume()
media_player.audio_set_volume(100)
end = time.time()
print("Start-up in {} seconds".format(end - start))
finish_time = datetime.datetime.now() + datetime.timedelta(seconds=30)
while datetime.datetime.now() < finish_time:
# Actually records the audio and runs through the model
get_and_classify_audio(audio_recorder, model_runner, media_player,
motor_driver)
def __init__(self, name, model_path, settings): self.name = name self.provider = ElementProvider(model_path) self.model_runner = ModelRunner(model_path) self.animation_data = AnimationData(settings) self.settings = settings
from model import BoidFlockers from ModelRunner import ModelRunner param_path = "./parameter/nominal.toml" runner = ModelRunner(BoidFlockers, param_path) runner.run_headless()
from model import BoidFlockers from ModelRunner import ModelRunner param_path = "./parameter/nominal.toml" runner = ModelRunner(BoidFlockers, param_path) runner.run_silent()
from model import BoidFlockers from ModelRunner import ModelRunner param_path = "./parameter/nominal.toml" runner = ModelRunner(BoidFlockers, param_path) runner.visualize()
if __name__ == '__main__':
parser = ArgumentParser(formatter_class=ArgumentDefaultsHelpFormatter)
parser.add_argument('mode', choices=('train', 'test'), help='what to run')
parser.add_argument('--work_dir', help='where to save', default='work')
parser.add_argument('--test_data', help='path to test data', default='example/input.txt')
parser.add_argument('--test_output', help='path to write test predictions', default='pred.txt')
args = parser.parse_args()
random.seed(0)
if args.mode == 'train':
if not os.path.isdir(args.work_dir):
print('Making working directory {}'.format(args.work_dir))
os.makedirs(args.work_dir)
print('Instatiating model')
model = ModelRunner()
print('Loading training data')
train_data = ModelRunner.load_training_data()
print('Training')
model.run_train(train_data, args.work_dir)
print('Saving model')
model.save(args.work_dir)
elif args.mode == 'test':
print('Loading model')
model = ModelRunner.load(args.work_dir)
print('Loading test data from {}'.format(args.test_data))
test_data = ModelRunner.load_test_data(args.test_data)
print('Making predictions')
pred = model.run_pred(test_data)
print('Writing predictions to {}'.format(args.test_output))
assert len(pred) == len(test_data), 'Expected {} predictions but got {}'.format(len(test_data), len(pred))
from model import BoidFlockers
from ModelRunner import ModelRunner
param_path = "./parameter/nominal.toml"
runner = ModelRunner(BoidFlockers, param_path)
runner.save("./movie/movie.mp4", writer="ffmpeg")
def work_runner():
while True:
work = work_que.get()
model = ModelRunner(work)
model.run()
import cv2
ALLOWED_EXTENSIONS = {'png', 'jpg', 'jpeg'}
def allowed_file(filename):
return '.' in filename and \
filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
app = Flask(__name__)
app.config['UPLOAD_FOLDER'] = './static/temp/'
if not os.path.exists(app.config['UPLOAD_FOLDER']):
os.makedirs(app.config['UPLOAD_FOLDER'])
app.config['host'] = '0.0.0.0'
model_runner = ModelRunner('./export')
@app.route('/', methods=['GET'])
def home():
return render_template('index.html')
@app.route('/what', methods=['GET'])
def what():
return render_template('what.html')
@app.route('/why', methods=['GET'])
def why():
return render_template('why.html')