def parse_args():
"""
Parses arguments
"""
import argparse
import parser
#argparse stuff
parser = argparse.ArgumentParser(description="Scan files and store results in elastic search")
parser.add_argument("-v", "--verbose", action="store_true")
parser.add_argument('Report', help="Report file with one json report per line")
return parser.parse_args()
def parse_args():
parser = argparse.ArgumentParser(description=__doc__);
parser.add_argument("--name", help="attribute name");
parser.add_argument("--formula", help="formula to compute new attribute");
parser.add_argument("input_mesh", help="input mesh");
parser.add_argument("output_mesh", help="output mesh");
return parser.parse_args();
def main():
parser = argparse.ArgumentParser(
description='argdoc turns all argparse arguments into beautiful, end-user friendly documentation',
formatter_class=argparse.RawTextHelpFormatter)
parser.add_argument(
'filename',
help="Name of the file for which you want to create documentation")
parser.add_argument(
'-f', '--format',
help="Format of the outputted documentation.\nOptions: ['md', 'html']" +
"\nDefault: 'html'",
choices=['md', 'html'],
default="html",
metavar="")
parser.add_argument(
'-n', '--noob',
help=("Set whether or not to include the beginner instructions in the Docs"
'\n(See templates for example of beginner info.)'),
action="store_false",
default=True)
parser.add_argument(
'-q', '--quiet',
help="Supresses success message",
action='store_false')
args = parser.parse_args()
parse_pyfile(args.filename, format=args.format, noob=args.noob)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-v', '--verbose', action="store_true", default=False)
parser.add_argument('source', action="store")
args = parser.parse_args(sys.argv[1:])
global verbose
verbose = args.verbose
source = args.source
show_tokens(source)
ast, symtab = show_ast(source)
show_code(ast, symtab)
def main():
parser = argparse.ArgumentParser(description='Music Scanner')
parser.add_argument('-d','--directory', help='Directory', required=True)
args = parser.parse_args()
x = 0
L = []
badalbums = []
for dirName,subdirList,fileList in os.walk(args.directory):
#Prune bad directories from list
if re.search(r'([Ss]ingles|lost\+found|System\ Volume\ Information|.*RECYCLE?)',dirName):
pass
else:
try:
# Separate out Artist Name from Album Title
em = re.search(r'^.*/(newmusic|music|MUSIC|Music)/(.*)_-_(.*)/?',dirName)
# Prune off extra "/". if group 2 contains a "/" character, don't print
if re.search(r'/',em.group(2)):
pass
else:
#print em.group(1) ,"~~~", em.group(2)
for fname in fileList:
# Get actual music files, not other files
if re.search(r'\.(flac$|wav$|mp3$|m4a$|mp4$|wma$)',fname):
L.append(fname)
x = x+1
if x == 0:
pass
else:
pass
# Print out total files contained in Album
#print x , "songs in", em.group(1) , em.group(2)
# Do you want to print this data to stdout or write it to a file?
group2 = re.sub(r"_",' ', em.group(2))
group3 = re.sub(r"_",' ', em.group(3))
if re.search(r'/',group3):
group3 = group3.rstrip('/')
#print group2,group3
# Function that compares my albums to musicBrainz goes here!
foundtracks = querymusicbrainz.gather(group2,group3)
if int(x) != int(foundtracks):
print bcolors.WARNING + "You're missing some tracks bro!" + bcolors.ENDC
print x , "songs in", dirName, foundtracks, "in MusicBrainz"
L = []
x = 0
except AttributeError:
print "Cannot parse ", dirName
badalbums.append(dirName)
def get_args():
parser = argparse.ArgumentParser(
description='A Maze interpreter (http://esolangs.org/wiki/Maze)')
parser.add_argument('file', type=open,
help='the program to run')
parser.add_argument('-d', '--debug', action='store_true',
help='display the maze during interpretation.')
parser.add_argument('-l', '--log-length', default=10, type=int,
help='Max length of debug log.')
parser.add_argument('-c', '--no-colors', action='store_false',
help='shows the maze without color when in debug mode.')
parser.add_argument('-f', '--fps', default=10, type=int,
help='the fps of the maze when in debug mode.')
args = parser.parse_args()
return args
def args():
parser = argparse.ArgumentParser(description="Get information needed to \
parse the log")
parser.add_argument('script', nargs='?') # Why does argparse read the
# script name? Who knows.
parser.add_argument('infile', nargs='?', default=sys.stdin)
parser.add_argument('parser', nargs='?', default='IrssiBitlbee')
parser.add_argument('viewer', nargs='?', default='Null')
return parser.parse_args(sys.argv)
def main():
parser = argparse.ArgumentParser(description = 'Fetch soccer league, team and player data from Wikipedia.')
parser.add_argument('-L', dest = 'specific_league', type = str,
default = '', help = 'fetch only one league')
parser.add_argument('-l', dest = 'fetch_only_leagues', action = 'store_true', help = 'fetch only leagues')
parser.add_argument('-o', dest = 'output_dir', action = 'store', type = str, default = '', help = 'output directory')
args = parser.parse_args()
Globals.setDataDir(args.output_dir)
if args.fetch_only_leagues:
Globals.fetchTeams = False
Globals.dumpTextFiles = True
try:
fetchLeagueData(args.specific_league.decode('utf-8'))
except:
# http://www.doughellmann.com/articles/how-tos/python-exception-handling/index.html
try:
raise
finally:
try:
cleanup()
print Globals.progress
except Exception, e:
print >> sys.stderr, "Error: couldn't save progress:", str(e)
pass
def AddBuildArgs(self, parser):
parser.add_argument("-j", "--jobs", type=int, dest='jobs',
default=0, help="Number of jobs to run simultaneously.")
parser.add_argument("-p", "--profile", type=str, dest='profile',
default='release', help="Build profile: debug or release.")
parser.add_argument("--generate-scons", dest='generate_scons',
action="store_true", help="Generate scons file.")
def parse_args():
global args
parser = argparse.ArgumentParser(description = __doc__,
formatter_class = argparse.RawDescriptionHelpFormatter)
parser.add_argument("-e", "--big-endian", action="store_true",
help="Target encodes data in big-endian format"
"(little endian is the default)")
parser.add_argument("-i", "--input",
help="Input file from which MMU regions are read.")
parser.add_argument("-o", "--output",
help="Output file into which the page tables are written.")
parser.add_argument("-v", "--verbose", action="store_true",
help="Lists all the relavent data generated.")
args = parser.parse_args()
def parse_options():
parser = argparse.ArgumentParser(
description=("Download the hourly weather data for all the"
" stations available in aemet.es.")
)
parser.add_argument('-d', '--debug', action='store_true',
help="Enable debug mode.")
parser.add_argument('-v', '--verbose', default="2",
help="Verbosity level. Options: 0=ERROR, 1=WARNING,"
" 2=INFO or 3=DEBUG. Default: 2.")
parser.add_argument('-o', '--output', default=settings.DEFAULT_OUTPUT_DIR,
help="Output directory path where files will be"
" downloaded. Default: aemet_data.")
parser.add_argument('-f', '--format', default='txt',
help="Store file in the specified format."
"Options: csv or txt. Default: csv.")
return parser.parse_args()
def parse_args():
"""
Parses arguments
"""
import argparse
import parser
#argparse stuff
parser = argparse.ArgumentParser(description="Scan files and store results in elastic search")
parser.add_argument("-r", "--recursive", action="store_true")
parser.add_argument("-v", "--verbose", action="store_true")
parser.add_argument('Files', help="Files and Directories to attach", nargs='+')
return parser.parse_args()
def main():
import argparse
parser = argparse.ArgumentParser(description = 'Process Celltone code')
parser.add_argument('--update', '-u', action = 'store_true',
help = 'Allow for dynamic updating of source file during runtime')
parser.add_argument('--file', '-f', help = 'Output to MIDI file instead of the MIDI device')
parser.add_argument('--length', '-l', help = 'Stop after <LENGTH> seconds')
group = parser.add_mutually_exclusive_group()
group.add_argument('-v', action = 'store_true', help = 'verbose')
group.add_argument('-vv', action = 'store_true', help = 'more verbose')
group.add_argument('-vvv', action = 'store_true', help = 'even more verbose')
parser.add_argument('filename', nargs = '?', help = 'if omitted reads from stdin')
args = parser.parse_args()
verbosity = 0
if args.v:
verbosity = 1
if args.vv:
verbosity = 2
if args.vvv:
verbosity = 3
try:
if not args.filename or args.filename == '-':
if args.update:
self.error('Cannot dynamically update from stdin')
code = ''.join(sys.stdin.readlines())
else:
if not os.path.exists(args.filename):
self.error('Error: No such file \'%s\'' % args.filename)
with open(args.filename) as f:
code = ''.join(f.readlines())
except KeyboardInterrupt:
sys.exit(0)
ct = Celltone(code, verbosity, args.filename, args.update, args.file, args.length)
ct.start()
sys.exit(0)
def parse_args():
parser = argparse.ArgumentParser(
description='DNS for libvirt',
)
parser.add_argument(
'--config',
metavar='CONFIGFILE',
help='path to YAML config file',
)
parser.add_argument(
'--server',
action='store_true', default=False,
help='Run as the server (http/sql access).',
)
parser.add_argument(
'remainder',
nargs=argparse.REMAINDER,
help='Remainder arguments for webpy, ip:port for listen address'
)
args = parser.parse_args()
return args
def argparser():
parser = argparse.ArgumentParser()
parser.add_argument(
'-F', type=str, required=True,
help='training data path') #File path for our MAINMAST code
parser.add_argument(
'-M',
type=str,
default='Train_Model',
help='model path for evluation and the path to save model')
parser.add_argument('--mode',
type=int,
required=True,
help='0:default mode to run\n')
parser.add_argument('--epochs',
default=1024,
type=int,
help='number of total epochs to run')
parser.add_argument('--lr',
'--learning-rate',
default=0.002,
type=float,
help='initial learning rate')
parser.add_argument('--lr1',
default=0.1,
type=float,
help='initial learning rate for new optimizer1')
parser.add_argument('--reg',
default=1e-7,
type=float,
help='initial l2 regularization lambda')
parser.add_argument('--gamma',
type=float,
default=0.1,
help='LR is multiplied by gamma on schedule.')
parser.add_argument('--momentum',
default=0.9,
type=float,
metavar='M',
help='momentum')
parser.add_argument('--patience',
default=10,
type=int,
help='patient epoch for updating the lr scheduler')
parser.add_argument('--weight_decay',
'--wd',
default=5e-4,
type=float,
metavar='W',
help='weight decay (default: 5e-4)')
parser.add_argument('--seed', type=int, default=888, help='manual seed')
parser.add_argument('--batch_size',
type=int,
default=512,
help='batch size')
parser.add_argument('--choose',
type=str,
default='0',
help='specified gpu')
parser.add_argument('--num_workers',
type=int,
default=16,
help='number of data loading workers')
parser.add_argument('--cuda', type=bool, default=True, help='enables cuda')
parser.add_argument(
'--rot',
type=float,
default=180,
help='range of angle for rotation, default:[-180, 180]')
parser.add_argument('--shear',
type=float,
default=30,
help='range of angle for shearing, default: [-30, 30]')
parser.add_argument(
'--translate',
type=float,
default=0.2,
help='range of ratio of translation to the height/width of the image')
parser.add_argument('--shrink',
type=float,
default=0.8,
help='the lower bound of scaling')
parser.add_argument('--enlarge',
type=float,
default=1.2,
help='the higher bound of scaling')
parser.add_argument(
'--shift',
type=float,
default=4,
help='shift parameter for projective data changing method')
parser.add_argument('--log_path',
type=str,
default='train_log',
help='training log record path')
parser.add_argument('--model_path',
type=str,
default='train_model',
help="training result record path")
parser.add_argument('--type',
type=int,
default=0,
help='specify the model\n'
'0: Wide ResNet-28-2\n'
'1: Wide ResNet-28-2-Large')
parser.add_argument('--resume',
type=int,
default=0,
help='reload trained model to continue training')
parser.add_argument(
'--KL_Lambda',
default=1.0,
type=float,
help='hyper parameter to control the KL divergence loss term')
parser.add_argument(
'--lambda',
type=float,
default=10,
help=
'warm factor in combined loss of projective AET and classifier loss')
parser.add_argument(
'--lambda1',
type=float,
default=7.5,
help='warm factor in combined loss of affine AET and classifier loss')
parser.add_argument(
'--lambda2',
type=float,
default=5,
help=
'warm factor in combined loss of similarity AET and classifier loss')
parser.add_argument(
'--lambda3',
type=float,
default=2,
help='warm factor in combined loss of euclidean AET and classifier loss'
)
parser.add_argument(
'--lambda4',
type=float,
default=0.5,
help='warm factor in combined loss ofCCBS AET and classifier loss')
parser.add_argument(
'--max_lambda',
type=float,
default=1.0,
help='balanced factor in combined loss of AET and classifier loss')
parser.add_argument(
'--max_lambda1',
type=float,
default=0.75,
help=
'balanced factor in combined loss of affine AET and classifier loss')
parser.add_argument(
'--max_lambda2',
type=float,
default=0.5,
help=
'balanced factor in combined loss of similarity AET and classifier loss'
)
parser.add_argument(
'--max_lambda3',
type=float,
default=0.2,
help=
'balanced factor in combined loss of euclidean AET and classifier loss'
)
parser.add_argument(
'--max_lambda4',
type=float,
default=0.05,
help='balanced factor in combined loss of CCBS AET and classifier loss'
)
parser.add_argument('--portion',
type=float,
default=0.08,
help='percentage of data with labels')
parser.add_argument(
'--beta',
type=float,
default=75,
help='hyper parameter for the consistency loss in MixMatch part')
parser.add_argument('--ema_decay',
default=0.999,
type=float,
help='EMA decay hyper-parameter')
parser.add_argument('--T',
default=0.5,
type=float,
help='Temperature settings applied for the sharpening')
parser.add_argument('--alpha',
default=0.75,
type=float,
help='Alpha settings for the mixup part')
parser.add_argument('--mix_iteration',
default=1024,
type=int,
help='Required iteration for mixmatch in each epoch')
parser.add_argument('--start_epoch',
default=0,
type=int,
help='startring epoch for resuming situation')
parser.add_argument('--dataset',
default='cifar10',
type=str,
help='Choose dataset for training')
parser.add_argument(
'--tensorboard',
default=1,
type=int,
help='Use tensorboard to keep results or not. Default: True')
parser.add_argument(
'--mix_mode',
default=0,
type=int,
help=
'Mix up mode: 0:choose default mixmatch mixup mode\n 1: choose mixup with mosaic operations'
)
parser.add_argument(
'--Mixmatch_warm',
default=16,
type=int,
help='Steps that necessary for warming up the enloss term in Mixmatch')
parser.add_argument(
'-S',
default='',
type=str,
help='the path to save all the training logs and models')
parser.add_argument('--use_ema',
default=1,
type=int,
help='Use ema or not during training:default=1')
args = parser.parse_args()
params = vars(args)
return params
def get_parser():
parser = argparse.ArgumentParser(
description='Deep learning multiclass classification')
parser.add_argument('-dataset', '--datasetPath', help='Path to dataset')
parser.add_argument('-rate',
'--learningRate',
help='Set the learning rate')
parser.add_argument('-epochs', '--epochs', help='Set the epochs')
parser.add_argument('-batch-size',
'--batchSize',
help='Set the batch size')
parser.add_argument('-classes',
'--numClasses',
help='Set the number of classes')
parser.add_argument('-zscore', '--zScore', help='Set the Z score')
parser.add_argument('-decay', '--weightDecay', help='Set the weight decay')
main(parser)
global post_url
print("1: {}".format(data))
session = requests.Session()
session.verify = False
# session.post('http://{}:3000/users/1/web_requests/7/super_s3cret_mf1_string'.format(post_url), data=data)
def dataReceived2(data):
global post_url
print("2: {}".format(data))
session = requests.Session()
session.verify = False
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('port', help="port", default=7682, nargs="?")
parser.add_argument('username', help='username', default='ubnt', nargs="?")
parser.add_argument('pwd', help='password', default='ubnt', nargs="?")
parser.add_argument('post_url', help='url to post data changes', nargs="?")
args = parser.parse_args()
loop = asyncio.get_event_loop()
#
discovery = MFiDiscovery()
post_url = args.post_url
asyncio.get_event_loop().run_until_complete(asyncio.sleep(10))
mymFI = []
d1 = discovery.devices[0](discovery.devices[0].address, args.port, args.username, args.pwd)
d1.callback = dataReceived
d2 = discovery.devices[1](discovery.devices[1].address, args.port, args.username, args.pwd)
d2.callback = dataReceived2
def parseArguments(args=None):
# valid datetime args
def valid_date(s):
try:
return datetime.strptime(s, "%d/%m/%Y")
except ValueError:
msg = "Not a valid date: '{0}'.".format(s)
raise argparse.ArgumentTypeError(msg)
# parse arguments
parser = argparse.ArgumentParser(description='data-prepare-dem')
parser.add_argument('dem', action="store")
parser.add_argument('product', action="store")
parser.add_argument('-r', '--res', type=int, help='resolution', default=20)
parser.add_argument('-f', '--file', help='scene filename', default=None)
parser.add_argument('-p',
'--path',
help='scene root path',
default='/data/raw/fiji')
parser.add_argument('-s',
'--start',
help='start date DD/MM/YYYY',
default=None,
type=valid_date)
parser.add_argument('-e',
'--end',
help='end date DD/MM/YYYY',
default=None,
type=valid_date)
return parser.parse_args(args)
if dict_conf[option] == -1:
DebugPrint("skip: %s" % option)
except:
print("exception on %s!" % option)
dict_conf[option] = None
return dict_conf
# ./dada_dbdisk.py -a ../config/pipeline.conf -b 0 -c 0 -d /beegfs/DENG/docker
if __name__ == "__main__":
parser = argparse.ArgumentParser(
description=
'To transfer data from shared memeory to disk with a docker container')
parser.add_argument('-a',
'--pipeline_conf',
type=str,
nargs='+',
help='The configuration of pipeline')
parser.add_argument('-b',
'--beam',
type=int,
nargs='+',
help='The beam id from 0')
parser.add_argument('-c',
'--part',
type=int,
nargs='+',
help='The part id from 0')
parser.add_argument('-d',
'--directory',
type=str,
def main():
parser = argparse.ArgumentParser(
description=
"Resolution Theorem Prover for CISC481. James Skripchuk 2019")
parser.add_argument(
"--file",
type=str,
help="A file containing a set of premise clauses and a goal clause.")
parser.add_argument(
"--folder",
type=str,
help="A folder containing different files of test cases to resolve.")
parser.add_argument("--method",
type=str,
help="Search Method. 'bfs' or 'dfs'. Defaults to dfs.")
parser.add_argument(
"--max_depth",
type=int,
help=
"How long to search until terminating early. Used to prevent infinite loops. Defaults to 300."
)
parser.add_argument("--test_cases",
action="store_true",
help="Run through the provided test cases.")
parser.add_argument("--helper_function_test",
action="store_true",
help="Run through tests on helper functions.")
args = parser.parse_args()
method = "dfs"
max_depth = 300
folder = ""
if args.helper_function_test:
helper_function_test()
if args.method:
method = args.method
if method != "dfs" and method != "bfs":
print(
"Search method must be 'dfs' or 'bfs'. Run 'python3 resolver.py' -h for details"
)
quit()
if args.max_depth:
max_depth = args.max_depth
if args.folder:
folder = args.folder
if args.test_cases:
folder = "./test_cases"
if folder:
test_resolve_folder(folder, method, max_depth)
elif args.file:
resolve_file(args.file, method, max_depth)
if not folder and not args.file and not args.test_cases:
print(
"No file or folder specified. Use --folder, --file, or --test_cases arguments. Run 'python3 resolver.py -h' for details."
)
def main():
parser = argparse.ArgumentParser(
description="Twitter sentiment analysis classification")
parser.add_argument(
"--probability_threshold",
type=float,
default=None,
help=
"an numeric between 0.5 and 1 that will be used as a threshold to classify the tweet. If probability is lower than it, then the twitter is classified as neutral (polarity=2)"
)
parser.add_argument(
"--test",
dest="test",
action="store_true",
help=
"run the classification for the test file available and save it to /test folder"
)
parser.add_argument("--search_keyword",
type=str,
help="a word used to search Twitter")
parser.add_argument(
"--fetch_size",
type=int,
default=100,
help=
"an integer with the amount of tweets to fetch during each run (default is 100)"
)
args = parser.parse_args()
if "probability_threshold" in args:
probability_threshold = args.probability_threshold
else:
probability_threshold = 0
if "test" in args:
if args.test == True:
inbound_dataset = load_test_dataset()
outbound_dataset = classify_tweets(inbound_dataset,
probability_threshold)
Y_test = outbound_dataset["polarity"]
predicted = outbound_dataset["predicted"]
test_folder = os.path.join(os.getcwd(), 'test_model')
if not os.path.exists(test_folder):
os.makedirs(test_folder)
# Save evaluations
sys.stdout = open(
os.path.join(test_folder, "confusion_matrix.txt"), "w")
print("Confusion Matrix:\n", confusion_matrix(Y_test, predicted))
sys.stdout.close()
sys.stdout = open(
os.path.join(test_folder, "classification_report.txt"), "w")
print("Classification Report:\n",
classification_report(Y_test, predicted))
sys.stdout.close()
sys.stdout = open(os.path.join(test_folder, "precision.txt"), "w")
print("Precision:\n", accuracy_score(Y_test, predicted))
sys.stdout.close()
# Save Dataset
file_name = os.path.join(test_folder, "outbound_test.csv")
outbound_dataset.to_csv(file_name, index=False)
else:
if "search_keyword" not in args:
print("A search keyword must be informed!")
sys.exit()
else:
search_keyword = args.search_keyword
if search_keyword.strip() == "":
print("A search keyword must be informed!")
sys.exit()
if "fetch_size" not in args:
print(
"The size of fetch was not informed! Default (100) will be used"
)
fetch_size = 100
else:
fetch_size = args.fetch_size
inbound_dataset = get_twitter(search_keyword, fetch_size)
outbound_dataset = classify_tweets(inbound_dataset,
probability_threshold)
load_into_database(outbound_dataset, search_keyword)
output_folder = os.path.join(os.getcwd(), 'outbound')
if not os.path.exists(output_folder):
os.makedirs(output_folder)
file_name = "outbound_" + time.strftime("%Y%m%d_%H%M%S") + ".csv"
file_name = os.path.join(output_folder, file_name)
outbound_dataset.to_csv(file_name, index=False)
print ('ATTENTION UN FICHIER DE LOCK EXISTE DEJA')
do_purge()
elif not os.path.isdir(MEP_CONF):
#print (xtermcolor.colorize('ATTENTION LE REPERTOIRE MEP
#N EXISTE PAS', 0xaf0000))
print ('ATTENTION LE REPERTOIRE MEP N EXISTE PAS')
do_purge()
elif not os.path.isdir(MEP_REP):
#print (xtermcolor.colorize('ATTENTION LE REPERTOIRE LOG DES
#MEP N EXISTE PAS', 0xaf0000))
print ('ATTENTION LE REPERTOIRE LOG DES MEP N EXISTE PAS')
do_purge()
##### recuperation utilisateur + tag
parser = argparse.ArgumentParser(usage="mep.py -a application -t tag")
parser.add_argument('-a', '--application', action='store')
parser.add_argument('-t', '--tag', action='store')
args = parser.parse_args()
if (args.application):
application = args.application
do_lock()
else:
application = raw_input('Entrez projet: ')
do_lock()
if not os.path.isdir(os.path.join(SVN_LOCAL, application)):
#print (xtermcolor.colorize('ATTENTION LE REPOSITORY
# DU PROJET N EXISTE PAS', 0xaf0000))
print ('ATTENTION LE REPOSITORY DU PROJET N EXISTE PAS')
do_purge()
# cv2.namedWindow("frame", cv2.WND_PROP_FULLSCREEN)
# cv2.setWindowProperty("frame", cv2.WND_PROP_FULLSCREEN, cv2.cv.CV_WINDOW_FULLSCREEN)
cv2.imshow('frame', draw)
cv2.imwrite(SAVE_PATH + utils.get_frame_fig_name(i), draw)
k = cv2.waitKey(30) & 0xff
i += 1
if k == 27:
break
cap.release()
cv2.destroyAllWindows()
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("video", help = "A: Suturing: B: Pizza making")
parser.add_argument("type", help = "1: MOG 2: MOG2 3: Ken's algorithm")
args = parser.parse_args()
cap = None
if args.video == 'A':
cap = cv2.VideoCapture('/home/animesh/DeepMilestones/jigsaws/Suturing_video/frames/Suturing_E003_capture2/cropped_scaled.avi')
elif args.video == 'B':
cap = cv2.VideoCapture('/home/animesh/C3D/examples/c3d_feature_extraction/input/frm/pizza8/videos/cropped_scaled.avi')
else:
print "Invalid video type"
sys.exit()
if (int(args.type) == 1):
params = (500, 10, 0.9, 1)
run_video_with_bsub(cap, cv2.BackgroundSubtractorMOG, params = None)
elif (int(args.type) == 2):
import psyco
psyco.full()
except ImportError:
pass
from dbfpy.dbf import Dbf
from constants.extensions import CSV
import sys
import parser
import argparse
from elementtree.SimpleXMLWriter import XMLWriter
from lambert import Belgium1972LambertProjection
parser = argparse.ArgumentParser(description='Reads the AGIV CRAB database in DBF and converts this to .csv/.osm format.')
parser.add_argument('path', help='The path to the CRAB DBF files.')
parser.add_argument('--output-csv', default='crab.csv', help='The path to the output csv file.')
parser.add_argument('--filter-postcode', help='The postocde to filter on, will restrict data to this postcode only.', default='')
parser.add_argument('--write-postcodes', action='store_true', default=False)
parser.add_argument('--output-osm', default='crab.osm', help='The path to the output OSM XML file.')
args = parser.parse_args()
straatnm_dbf = args.path + 'straatnm.dbf'
huisnr_dbf = args.path + 'huisnr.dbf'
pkancode_dbf = args.path + 'pkancode.dbf'
gemnm_dbf = args.path + 'gemnm.dbf'
gem_dbf = args.path + 'gem.dbf'
tobjhnr_dbf = args.path + 'tobjhnr.dbf'
terrobj_dbf = args.path + 'terrobj.dbf'
do_terrobj = 1
logger.info("ovs-ofctl add-flow br-int priority=66,dl_type=0x800,in_port="+lastport+",nw_src="+src+",nw_dst="+dst+",actions=output:"+brintport)
print "ovs-ofctl add-flow br-int priority=66,dl_type=0x800,in_port="+lastport+",nw_src="+src+",nw_dst="+dst+",actions=output:"+brintport
os.system("ovs-ofctl add-flow br-int priority=66,dl_type=0x800,in_port="+lastport+",nw_src="+src+",nw_dst="+dst+",actions=output:"+brintport)
fo.write("ovs-ofctl --strict del-flows br-int priority=66,dl_type=0x800,in_port="+lastport+",nw_src="+src+",nw_dst="+dst+"\n")
return (returnflag)
def get_ip():
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect(("8.8.8.8", 80))
return s.getsockname()[0]
### Main Part ###
parser = argparse.ArgumentParser() #handler for arguments passed
parser.add_argument("-s", "--server",help="pass the local server ip. If not, it finds it automatically",type=str) # option configurations, needs to be required
parser.add_argument("-i", "--brint",help="pass the connection of br-int to br-ex port, or use default '2' ",type=str)
parser.add_argument("-e", "--brex",help="pass the connection of br-ex to br-int port, or use default '2' ",type=str)
parser.add_argument("-t", "--breth",help="pass the connection of br-eth0 to br-ex port, or use default '3' ",type=str)
args = parser.parse_args() # pass the arguments to the parser
# default values for ports
brexport = "2"
brintport = "2"
breth0port = "3"
print ""
print ""
print "===SONATA PROJECT==="
print "SFC-AGENT Initializing..."
print ""
print ""
status = get_value(id, 'status', s.provider_failed)
message = get_value(id, 'message', s.provider_failed)
value = status if message is None else "%s // %s" % (status, message)
row.append(value)
csvwriter.writerow(row)
csvfile.close()
return True
except:
return None
traceback.print_exc()
pass
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument('-i', '--inputFolder', default='none',
help='path to folder that contains all summaries [Required]')
parser.add_argument('-o', '--outputFile', default='summary_all.csv', help='path to output file [Required]')
input_folder = parser.parse_args().inputFolder
output_path = parser.parse_args().outputFile
summaries = []
for file_name in os.listdir(input_folder):
full_path = os.path.realpath(os.path.join(input_folder, file_name))
summary = GlobalSummary.load_from_json_file(full_path)
if summary:
summaries.append(summary)
statistic_all_rerun_to_csv(summaries, output_path)
print "Final report is write to %s " % (output_path)
R = 0.12*W_ref
canvas = ROOT.TCanvas('canvas', 'canvas', 50, 50, W, H)
canvas.SetFillColor(0)
canvas.SetBorderMode(0)
canvas.SetFrameFillStyle(0)
canvas.SetFrameBorderMode(0)
canvas.SetLeftMargin( L/W )
canvas.SetRightMargin( R/W )
canvas.SetTopMargin( T/H )
canvas.SetBottomMargin( B/H )
canvas.SetTickx(0)
canvas.SetTicky(0)
parser = argparse.ArgumentParser()
parser.add_argument('file', help='JSON file you want to draw')
parser.add_argument('output', help='Output filename')
args = parser.parse_args()
data = {}
with open(args.file, 'r') as f:
data = json.load(f)
if data['dimension'] != 2:
raise Exception("Only 2-d scale-factors / efficiencies are supported")
if 'formula' in data and data['formula']:
raise Exception("Formula are not supported")
x_min = data['binning']['x'][0]
## Main part
logger.info("")
logger.info("===SONATA PROJECT===")
logger.info("Starting SFC Node Agent")
server = get_ip()
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_address = (server, 55555)
logger.info('starting up on %s port %s' % server_address)
sock.bind(server_address)
sock.listen(5)
#configurations
parser = argparse.ArgumentParser() #handler for arguments passed
parser.add_argument("-m", "--compute",help="pass the name of the other node",type=str) # option configurations, needs to be required
parser.add_argument("-i", "--brint",help="pass the connection of br-int to br-tun port, or use default '1' ",type=str)
parser.add_argument("-c", "--control",help="pass the connection of br-tun to contoller, or use default '2' ",type=str)
parser.add_argument("-n", "--node",help="pass the connection of br-int to the other node, or use default '3' ",type=str) # TODO number of nodes. and port corresponding to nodes
args = parser.parse_args() # pass the arguments to the parser
# default values for ports
server = get_ip()
if args.compute: # parse the server adress passed
compute = args.compute
if args.brint:
brintport = args.brint
else:
brintport = '1'
if args.control:
import os
import io
import sys
import string
import parser
import argparse
import time
import json
import shapefile
from collections import namedtuple
from lambert import Belgium1972LambertProjection
parser = argparse.ArgumentParser(description='Reads the AGIV CRAB database in Shapefile format and converts this to a number of json files.')
parser.add_argument('path', help='Path to the CrabAdr.shp file.')
parser.add_argument('--output-dir', default='data/', help='The path to the output files.')
parser.add_argument('--osm-output', action="store_true", help='Also write one OSM file next to the tree of JSON files')
args = parser.parse_args()
# Check the output directory first, before all calculations
outputDir = args.output_dir
if (outputDir[-1] != '/'):
outputDir += '/'
if os.path.exists(outputDir):
sys.exit("The directory " + outputDir + " already exists. Please delete the directory before proceeding.")
# Statistical variables
stats = {
def argparser(dataset=None,
metric=None,
epsilon=0.3,
k=50,
q=0.8,
clusters=10,
iter=30,
repeat=10,
alpha=0.01,
seed=0,
ratio=0.2,
verbose=2000,
delta=0.01):
parser = argparse.ArgumentParser()
# image dataaset
parser.add_argument('--dataset',
type=str,
default=dataset,
help='dataset name')
parser.add_argument('--seed',
type=int,
default=seed,
help='random seed number')
parser.add_argument('--ratio',
type=float,
default=ratio,
help='ratio of validation dataset')
# perturbation family
parser.add_argument('--metric',
type=str,
default=metric,
help='type of perturbations')
parser.add_argument('--epsilon',
type=float,
default=epsilon,
help='perturbation strength')
# k nearest neighbour
parser.add_argument('--k',
type=int,
default=k,
help='number of nearest neighbors for knn')
parser.add_argument('--q',
type=float,
default=q,
help='initial covered density quantile')
# kmeans clustering
parser.add_argument('--clusters',
type=int,
default=clusters,
help='number of clusters for kmeans')
parser.add_argument('--iter',
type=int,
default=iter,
help='number of iterations for kmeans')
parser.add_argument('--repeat',
type=int,
default=repeat,
help='number of repeated experiments')
# other arguments
parser.add_argument('--alpha',
type=float,
default=alpha,
help='risk threshold')
parser.add_argument('--delta', type=float, default=delta)
parser.add_argument('--verbose', type=int, default=verbose)
parser.add_argument('--proctitle', type=str, default="")
args = parser.parse_args()
if args.dataset is not None:
args.proctitle += args.dataset + '/'
if args.metric is not None:
args.proctitle += args.metric + '/' + 'epsilon_' + str(
args.epsilon)
banned = [
'proctitle', 'dataset', 'metric', 'epsilon', 'alpha', 'seed',
'ratio', 'k', 'iter', 'repeat', 'verbose', 'delta'
]
if metric == 'euclidean':
banned += 'q'
for arg in sorted(vars(args)):
if arg not in banned and getattr(args, arg) is not None:
args.proctitle += '_' + arg + '_' + str(getattr(args, arg))
else:
raise ValueError('Need to specify the family of perturbations.')
else:
raise ValueError('Need to specify the image dataset.')
return args
previous_container_name = "paf-diskdb"
current_container_name = "paf-dbdisk"
kfname_b2f = "baseband2baseband.beam{:02d}part{:02d}.key".format(beam, part)
ddir = ConfigSectionMap(pipeline_conf, "BASEBAND2BASEBAND")['dir']
key_b2f = ConfigSectionMap(pipeline_conf, "BASEBAND2BASEBAND")['key']
dvolume = '{:s}:{:s}'.format(ddir, ddir)
com_line = "docker run --rm -it --ipc=container:{:s} -v {:s} -u {:d}:{:d} --cap-add=IPC_LOCK --ulimit memlock=-1:-1 --name {:s} xinpingdeng/paf-base taskset -c {:d} dada_dbdisk -k {:s} -D {:s} -s".format(previous_container_name, dvolume, uid, gid, current_container_name, cpu, key_b2f, ddir)
print com_line
os.system(com_line)
# ./baseband2baseband_dbdisk.py -a ../config/pipeline.conf -b 0 -c 0 -d 8 9 -e J1939+2134.par
if __name__ == "__main__":
parser = argparse.ArgumentParser(description='To transfer data from shared memeory to disk with a docker container')
parser.add_argument('-a', '--pipeline_conf', type=str, nargs='+',
help='The configuration of pipeline')
parser.add_argument('-b', '--beam', type=int, nargs='+',
help='The beam id from 0')
parser.add_argument('-c', '--part', type=int, nargs='+',
help='The part id from 0')
parser.add_argument('-d', '--cpu', type=int, nargs='+',
help='Bind threads to cpu')
parser.add_argument('-e', '--par_fname', type=str, nargs='+',
help='The name of pulsar par file')
args = parser.parse_args()
t_dbdisk = threading.Thread(target = dbdisk, args = (args,))
t_baseband2baseband = threading.Thread(target = baseband2baseband, args = (args,))
t_dbdisk.start()
import os
import io
import sys
import string
import parser
import argparse
import time
import json
import shapefile
from collections import namedtuple
from lambert import Belgium1972LambertProjection
parser = argparse.ArgumentParser(description='Reads the AGIV CRAB database in Shapefile format and converts this to a number of json files.')
parser.add_argument('path', help='Path to the CrabAdr.shp file.')
parser.add_argument('--output-dir', default='data/', help='The path to the output files.')
parser.add_argument('--osm-output', action="store_true", help='Also write one OSM file next to the tree of JSON files')
args = parser.parse_args()
# Check the output directory first, before all calculations
outputDir = args.output_dir
if (outputDir[-1] != '/'):
outputDir += '/'
if os.path.exists(outputDir):
sys.exit("The directory " + outputDir + " already exists. Please delete the directory before proceeding.")
# Statistical variables
stats = {
def parse_args(availableCommands):
parser = argparse.ArgumentParser(description=__doc__)
commandsHelp = "Available commands: %s" % (", ".join(availableCommands))
parser.add_argument(metavar="CMD", dest="command", help=commandsHelp)
parser.add_argument(metavar="ZIPFILE",
dest="files",
nargs="+",
help="Space separated list of zip files to handle")
parser.add_argument(
"-r",
"--randomize",
dest="randomize",
action="store_true",
help="Randomize the processing order of zip files and responses")
parser.add_argument(
"-c",
"--convert2odt",
dest="convert2odt",
action="store_true",
help=
"Converts almost all non-odt:s to the .odt format for further processing. This takes time."
)
parser.add_argument("--progress",
metavar="N",
dest="progress",
type=int,
default=0,
help="Show number of files processed (every N file)")
parser.add_argument("--names",
dest="printNames",
action="store_true",
help="Print filenames of all processed files")
parser.add_argument(
"-j",
dest="processes",
default=max(multiprocessing.cpu_count() - 1, 1),
type=int,
help="Number of processes to use. Defaults to number of CPUs - 1.")
parser.add_argument("-n",
"--num",
dest="numberOfFiles",
type=int,
metavar="NUM",
default=0,
help="Abort after NUM files analyzed")
parser.add_argument("-q",
"--queue-size",
dest="queueSize",
type=int,
default=10,
metavar="SIZE",
help="Size of the queue of files to analyze")
parser.add_argument("--file-pattern",
dest="filePattern",
metavar="PATTERN",
default="*",
help="File pattern for files to analyze")
parser.add_argument("--offset",
dest="offset",
metavar="NUM",
type=int,
help="Skip the first NUM files")
parser.add_argument(
"--wipe-db",
dest="wipeDatabase",
action="store_true",
help="Wipe the SQLite file before saving analysis results")
return parser.parse_args()
def argparser():
parser = argparse.ArgumentParser()
parser.add_argument('-F', type=str, required=True,
help='map path') #File path for our MAINMAST code
parser.add_argument(
'--mode',
type=int,
required=True,
help='0: Predict structures for EM MAP\n'
'1: Predict structures for EM maps with pdb structure\n'
'2: Predict structure for experimental maps with 4 models\n'
'3: Predict and evaluate structure for experimental maps with 4 models\n'
)
parser.add_argument(
'--resize',
type=int,
default=0,
help=
"0: resizing maps with numba optimized (some maps size are not supported);\n"
"1: resizing maps with scipy (relatively slow but support almost all maps)."
)
parser.add_argument('-P',
type=str,
default="",
help="PDB path for evaluating Model's performance")
parser.add_argument(
'-M',
type=str,
default="best_model",
help="Trained model path which saved all the trained models")
parser.add_argument(
'--type',
type=int,
help=
'0:simulated map at 6 A 1: simulated map at 10 A 2: simulated map at 6-10 A 3:experimental map'
)
parser.add_argument('--gpu',
type=str,
default='0',
help='gpu id choose for training')
parser.add_argument('--class',
type=int,
default='4',
help='number of classes')
parser.add_argument('--batch_size',
type=int,
default=256,
help='batch size for training')
parser.add_argument('--contour',
type=float,
default=0.0,
help='Contour level for real map')
parser.add_argument('--cardinality',
default=32,
type=int,
help='ResNeXt cardinality')
parser.add_argument('--drop_rate',
type=float,
default=0.3,
help="Drop out rate for the phase2 Model")
parser.add_argument(
'--fold',
type=int,
default=1,
help='specify the fold Model used for predicting the real map')
args = parser.parse_args()
# try:
# import ray,socket
# rayinit()
# except:
# print('ray need to be installed')#We do not need this since GAN can't be paralleled.
params = vars(args)
return params
import numpy as np
import random
from heap import heap_struct
import pdb
import matplotlib.pyplot as plt
import matplotlib.animation as animation
import parser
import argparse
import os
parser = argparse.ArgumentParser(description='node number')
parser.add_argument('--node_num',
'-n',
type=int,
default=10,
help='filename in dataset folder')
args = parser.parse_args()
node_num = args.node_num
print(node_num)
def dijkstra(network, weght, start, goal):
fig = plt.figure()
ims = []
flag = []
d_goal = [10000 for i in range(len(network))]
im = plt.bar(range(len(d_goal)), d_goal, width=0.5, color='black')
sec_prd, nchunk, ndf_chk_rbuf, ndf_chk_tbuf, ndf_chk_prd,
ctrl_socket, hdr_fname, instrument)
print capture_command
os.system(capture_command)
# Delete PSRDADA buffer
os.system("dada_db -d -k {:s}".format(key))
if __name__ == "__main__":
parser = argparse.ArgumentParser(
description='To capture data from given beam and given part')
parser.add_argument('-a',
'--system_conf',
type=str,
nargs='+',
help='The configuration of PAF system')
parser.add_argument('-b',
'--pipeline_conf',
type=str,
nargs='+',
help='The configuration of pipeline')
parser.add_argument('-c',
'--hdr',
type=int,
nargs='+',
help='Record packet header or not')
parser.add_argument('-d',
'--bind',
type=int,
def linkedinsearch():
if request.method == 'POST':
# check if the post request has the file part
keyword = request.form['searchkey']
options = Options()
options.headless = True
parser = argparse.ArgumentParser()
parser.add_argument('-url',
'--url',
help='URL to the online repository of images')
args = vars(parser.parse_args())
url = args['url']
url = "https://www.linkedin.com/login"
#userid = str(input("Enter email address or number with country code: "))
#password = getpass.getpass('Enter your password:'******'permissions.default.image', 2)
driver = webdriver.Firefox(firefoxProfile)
driver.get(url)
driver.implicitly_wait(3)
driver.find_element_by_id("username").send_keys(
'*****@*****.**')
driver.find_element_by_id("password").send_keys('amway2775035')
driver.find_element_by_xpath(
"/html/body/div/main/div/form/div[3]/button").click()
#, 'Manager', 'Web Developer', 'React Developer','Java Developer', 'IOS Developer'
tmpd = {}
d = pd.DataFrame(columns=['name', 'linkedin', 'skills'])
driver.get(
'https://www.linkedin.com/search/results/people/?keywords=' +
keyword + '&origin=SUGGESTION')
#driver.find_element_by_xpath("/html/body/header/div/form/div/div/div/div/div[1]/div/input").send_keys(i+Keys.ENTER)
content = driver.find_element_by_class_name('blended-srp-results-js')
source_code = content.get_attribute("innerHTML")
soup = BeautifulSoup(source_code, "html.parser")
data = soup.findAll('a', {'class': 'search-result__result-link'})
count = 0
for j in range(len(data)):
if j % 2 == 0:
pass
driver.get("https://www.linkedin.com" + str(data[j]['href']))
time.sleep(2)
driver.execute_script(
"window.scrollTo(0, document.body.scrollHeight);")
time.sleep(2)
try:
element = driver.find_element_by_class_name(
'pv-skill-categories-section')
actions = ActionChains(driver)
actions.move_to_element(element).click()
except:
element = driver.find_element_by_class_name(
'pv-profile-section__card-heading')
actions = ActionChains(driver)
actions.move_to_element(element).click()
finally:
driver.execute_script("arguments[0].scrollIntoView();",
element)
myElem = WebDriverWait(driver, 20).until(
EC.presence_of_element_located(
(By.CLASS_NAME,
'pv-profile-section__card-action-bar')))
#driver.find_element_by_class_name('pv-skill-categories-section').click()
content = driver.find_element_by_class_name('core-rail')
print(str(content))
tmp = scrap(content.get_attribute("innerHTML"), data[j]['href'])
d.loc[len(d)] = tmp
main = []
main = content.get_attribute("innerHTML")
a = pd.DataFrame((d['skills'].fillna("Python DataAnalysis"), d['name'],
d['linkedin']))
d = d.reset_index(drop=True)
a = a.T
skills = pd.DataFrame(a['skills'].str.split(" ", n=-1, expand=True))
skills.insert(0, 'Name', a['name'])
skills.insert(1, 'Linkedin', a['linkedin'])
linkdata = d.values.tolist()
return render_template("l_search.html", l=linkdata)
def create_parser():
parser = argparse.ArgumentParser(description='Run the prediction using NRC and features')
parser.add_argument('-ng','--ngrams',
help='Should generate ngrams', default=True)
parser.add_argument('-cg','--chargrams',
help='Should generate chargrams', default=True)
parser.add_argument('-cc','--count_caps',
help='Count number of all cap letters words', default=True)
parser.add_argument('-cm','--count_mentions', default=True,
help='Count number of mentions')
parser.add_argument('-ch','--count_hash', default=True,
help='Count number of hash words')
parser.add_argument('-cp','--count_pos', default=True,
help='Count number of words per pos')
parser.add_argument('-el','--elongated', default=True,
help='Count elongated words')
parser.add_argument('-le','--lexicon',
help='Use lexicons BING, MPQA, NRC', default=True)
parser.add_argument('-cl','--cluster', default=True,
help='Use word cluster')
parser.add_argument('-pu','--punctuation', default=True,
help='Create punctuation features')
parser.add_argument('-em','--emoticon', default=True,
help='Count number of words per pos')
parser.add_argument('-so','--so_cal', default=True,
help='Create SO_CAL Features')
parser.add_argument('-ss','--syn_strength', default=True,
help='Use syn strength features')
parser.add_argument('-lw','--liwc', default=False,
help='Use LIWC features')
return parser
import numpy as np
from Kmeans_def import k_means
from Kmeans_def import plot_classtering
import parser
import argparse
import os
parser = argparse.ArgumentParser(description='data loading trial')
parser.add_argument('--filename',
'-f',
type=str,
default='piyo',
help='filename in dataset folder')
args = parser.parse_args()
filename = args.filename
filepath = os.path.join('../../dataset/implementation/k-means/data',
'%s.npy' % filename)
dataset = np.load(filepath)
def make_kernel(name):
if name == 'linear':
def kernel(x, y):
K = np.dot(x, y)
return K
elif name == 'RBF':
gamma = float(input('gamma (positive real number) :'))
def kernel(x, y):
K = np.exp(-gamma * (sum((x - y)**2)))
return K
def parse_args(availableCommands):
parser = argparse.ArgumentParser(description=__doc__)
commandsHelp = "Available commands: %s" % (", ".join(availableCommands))
parser.add_argument(metavar="CMD",
dest="command",
help=commandsHelp)
parser.add_argument(metavar="ZIPFILE",
dest="files",
nargs="+",
help="Space separated list of zip files to handle")
parser.add_argument("-r",
"--randomize",
dest="randomize",
action="store_true",
help="Randomize the processing order of zip files and responses")
parser.add_argument("-c",
"--convert2odt",
dest="convert2odt",
action="store_true",
help="Converts almost all non-odt:s to the .odt format for further processing. This takes time.")
parser.add_argument("--progress",
metavar="N",
dest="progress",
type=int,
default=0,
help="Show number of files processed (every N file)")
parser.add_argument("--names",
dest="printNames",
action="store_true",
help="Print filenames of all processed files")
parser.add_argument("-j",
dest="processes",
default=max(multiprocessing.cpu_count() - 1, 1),
type=int,
help="Number of processes to use. Defaults to number of CPUs - 1.")
parser.add_argument("-n",
"--num",
dest="numberOfFiles",
type=int,
metavar="NUM",
default=0,
help="Abort after NUM files analyzed")
parser.add_argument("-q",
"--queue-size",
dest="queueSize",
type=int,
default=10,
metavar="SIZE",
help="Size of the queue of files to analyze")
parser.add_argument("--file-pattern",
dest="filePattern",
metavar="PATTERN",
default="*",
help="File pattern for files to analyze")
parser.add_argument("--offset",
dest="offset",
metavar="NUM",
type=int,
help="Skip the first NUM files")
parser.add_argument("--wipe-db",
dest="wipeDatabase",
action="store_true",
help="Wipe the SQLite file before saving analysis results")
return parser.parse_args()
def init_classifier_compression_arg_parser():
'''Common classifier-compression application command-line arguments.
'''
SUMMARY_CHOICES = ['sparsity', 'compute', 'model', 'modules', 'png', 'png_w_params']
parser = argparse.ArgumentParser(description='Distiller image classification model compression')
parser.add_argument('data', metavar='DIR', help='path to dataset')
parser.add_argument('--arch', '-a', metavar='ARCH', default='resnet18', type=lambda s: s.lower(),
choices=models.ALL_MODEL_NAMES,
help='model architecture: ' +
' | '.join(models.ALL_MODEL_NAMES) +
' (default: resnet18)')
parser.add_argument('-j', '--workers', default=4, type=int, metavar='N',
help='number of data loading workers (default: 4)')
parser.add_argument('--epochs', type=int, metavar='N', default=90,
help='number of total epochs to run (default: 90')
parser.add_argument('-b', '--batch-size', default=256, type=int,
metavar='N', help='mini-batch size (default: 256)')
optimizer_args = parser.add_argument_group('Optimizer arguments')
optimizer_args.add_argument('--lr', '--learning-rate', default=0.1,
type=float, metavar='LR', help='initial learning rate')
optimizer_args.add_argument('--momentum', default=0.9, type=float,
metavar='M', help='momentum')
optimizer_args.add_argument('--weight-decay', '--wd', default=1e-4, type=float,
metavar='W', help='weight decay (default: 1e-4)')
parser.add_argument('--print-freq', '-p', default=10, type=int,
metavar='N', help='print frequency (default: 10)')
parser.add_argument('--verbose', '-v', action='store_true', help='Emit debug log messages')
load_checkpoint_group = parser.add_argument_group('Resuming arguments')
load_checkpoint_group_exc = load_checkpoint_group.add_mutually_exclusive_group()
# TODO(barrh): args.deprecated_resume is deprecated since v0.3.1
load_checkpoint_group_exc.add_argument('--resume', dest='deprecated_resume', default='', type=str,
metavar='PATH', help=argparse.SUPPRESS)
load_checkpoint_group_exc.add_argument('--resume-from', dest='resumed_checkpoint_path', default='',
type=str, metavar='PATH',
help='path to latest checkpoint. Use to resume paused training session.')
load_checkpoint_group_exc.add_argument('--exp-load-weights-from', dest='load_model_path',
default='', type=str, metavar='PATH',
help='path to checkpoint to load weights from (excluding other fields) (experimental)')
load_checkpoint_group.add_argument('--pretrained', dest='pretrained', action='store_true',
help='use pre-trained model')
load_checkpoint_group.add_argument('--reset-optimizer', action='store_true',
help='Flag to override optimizer if resumed from checkpoint. This will reset epochs count.')
parser.add_argument('-e', '--evaluate', dest='evaluate', action='store_true',
help='evaluate model on test set')
parser.add_argument('--activation-stats', '--act-stats', nargs='+', metavar='PHASE', default=list(),
help='collect activation statistics on phases: train, valid, and/or test'
' (WARNING: this slows down training)')
parser.add_argument('--activation-histograms', '--act-hist',
type=distiller.utils.float_range_argparse_checker(exc_min=True),
metavar='PORTION_OF_TEST_SET',
help='Run the model in evaluation mode on the specified portion of the test dataset and '
'generate activation histograms. NOTE: This slows down evaluation significantly')
parser.add_argument('--masks-sparsity', dest='masks_sparsity', action='store_true', default=False,
help='print masks sparsity table at end of each epoch')
parser.add_argument('--param-hist', dest='log_params_histograms', action='store_true', default=False,
help='log the parameter tensors histograms to file '
'(WARNING: this can use significant disk space)')
parser.add_argument('--summary', type=lambda s: s.lower(), choices=SUMMARY_CHOICES, action='append',
help='print a summary of the model, and exit - options: | '.join(SUMMARY_CHOICES))
parser.add_argument('--export-onnx', action='store', nargs='?', type=str, const='model.onnx', default=None,
help='export model to ONNX format')
parser.add_argument('--compress', dest='compress', type=str, nargs='?', action='store',
help='configuration file for pruning the model (default is to use hard-coded schedule)')
parser.add_argument('--sense', dest='sensitivity', choices=['element', 'filter', 'channel'],
type=lambda s: s.lower(), help='test the sensitivity of layers to pruning')
parser.add_argument('--sense-range', dest='sensitivity_range', type=float, nargs=3, default=[0.0, 0.95, 0.05],
help='an optional parameter for sensitivity testing '
'providing the range of sparsities to test.\n'
'This is equivalent to creating sensitivities = np.arange(start, stop, step)')
parser.add_argument('--extras', default=None, type=str,
help='file with extra configuration information')
parser.add_argument('--deterministic', '--det', action='store_true',
help='Ensure deterministic execution for re-producible results.')
parser.add_argument('--seed', type=int, default=None,
help='seed the PRNG for CPU, CUDA, numpy, and Python')
parser.add_argument('--gpus', metavar='DEV_ID', default=None,
help='Comma-separated list of GPU device IDs to be used '
'(default is to use all available devices)')
parser.add_argument('--cpu', action='store_true', default=False,
help='Use CPU only. \n'
'Flag not set => uses GPUs according to the --gpus flag value.'
'Flag set => overrides the --gpus flag')
parser.add_argument('--name', '-n', metavar='NAME', default=None, help='Experiment name')
parser.add_argument('--out-dir', '-o', dest='output_dir', default='logs', help='Path to dump logs and checkpoints')
parser.add_argument('--validation-split', '--valid-size', '--vs', dest='validation_split',
type=float_range(exc_max=True), default=0.1,
help='Portion of training dataset to set aside for validation')
parser.add_argument('--effective-train-size', '--etrs', type=float_range(exc_min=True), default=1.,
help='Portion of training dataset to be used in each epoch. '
'NOTE: If --validation-split is set, then the value of this argument is applied '
'AFTER the train-validation split according to that argument')
parser.add_argument('--effective-valid-size', '--evs', type=float_range(exc_min=True), default=1.,
help='Portion of validation dataset to be used in each epoch. '
'NOTE: If --validation-split is set, then the value of this argument is applied '
'AFTER the train-validation split according to that argument')
parser.add_argument('--effective-test-size', '--etes', type=float_range(exc_min=True), default=1.,
help='Portion of test dataset to be used in each epoch')
parser.add_argument('--confusion', dest='display_confusion', default=False, action='store_true',
help='Display the confusion matrix')
parser.add_argument('--num-best-scores', dest='num_best_scores', default=1, type=int,
help='number of best scores to track and report (default: 1)')
parser.add_argument('--load-serialized', dest='load_serialized', action='store_true', default=False,
help='Load a model without DataParallel wrapping it')
parser.add_argument('--thinnify', dest='thinnify', action='store_true', default=False,
help='physically remove zero-filters and create a smaller model')
distiller.quantization.add_post_train_quant_args(parser)
return parser
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# =============================================================================
import os
import re
import glob
import parser
import argparse
import subprocess
parser = argparse.ArgumentParser()
parser.add_argument('restore_path', type=str)
parser.add_argument('--host', type=str, default="lmdgx01")
parser.add_argument('--target', type=str, default="lm_x86_avx")
parser.add_argument('--home_dir', type=str, default="/home/ki42/works/blueoil")
parser.add_argument('-n', '--dry_run', action="store_true")
args = parser.parse_args()
def run():
cmd_download_prj = "rsync -ravz -e ssh "
# cmd_download_prj += "--update --exclude='*.o' --exclude='*.cpp' "
cmd_download_prj += "--update --exclude='*.o' "
cmd_download_prj += "{}:{}/{}.prj tmp/".format(args.host, args.home_dir,
args.restore_path)
print(cmd_download_prj)
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument("--answer", action='store_true', help="answer")
parser.add_argument("word")
return parser.parse_args()
from deep_models import models
import numpy as np
import tensorflow as tf
import os
import parser
import argparse
if __name__ == '__main__':
parser = argparse.ArgumentParser()
# Input Arguments
# Model Specs
parser.add_argument('--block',
help='Block to use in deep layer',
type=str,
required=True,
choices=['van', 'f_E', 'Sf_EM', 'Wf_EM'])
parser.add_argument('--depth',
help='Depth of model',
type=int,
required=True)
parser.add_argument('--resolution',
help='reolution of images in tfrecords files',
type=int,
required=True,
nargs=2)
parser.add_argument('--dt',
this_gate = ''
line_input = '' # input name in line
line_output = '' # output name in line
connected_gate = [] # used to store the pre_gate and the next_gate
reg_gateName = r'(gate[0-9]+)'
reg_gateType = r'([a-z]+[0-9]+)'
pair_list = []
check = -1 # used to check whether it is a legal gate
has_pre_gate = False
has_next_gate = False
random_sequence = []
random_counter = 0
i = 0
counter = 0
parser = argparse.ArgumentParser(usage='python wire_CircuitScanner [-h] <circuit.v> [number]]', description='This program will camouflage <circuit.v> with dummy wire',)
parser.add_argument('<circuit.v>', help='input circuit to be camouflaged')
parser.add_argument('number', action='store', type=int, help='define the maximum number of gates to be selected, trade off between time and difficulty')
args = parser.parse_args()
Num_pair = args.number
circuitIn = sys.argv[1]
CircuitPath = os.path.abspath(circuitIn)
if not os.path.isfile(CircuitPath):
print 'Invalid input circuit file!!!\n'
# open circuit and scan line by line
with open(circuitIn, 'r') as infile:
inV = infile.read()
Vlines = inV.replace('\r','').split(';\n')
delta_std=params['delta_std'],
logdir=logdir,
rollout_length=params['rollout_length'],
shift=params['shift'],
params=params,
seed = params['seed'])
ARS.train(params['n_iter'])
return
if __name__ == '__main__':
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--env_name', type=str, default='HalfCheetah-v1')
parser.add_argument('--n_iter', '-n', type=int, default=1000)
parser.add_argument('--n_directions', '-nd', type=int, default=8)
parser.add_argument('--deltas_used', '-du', type=int, default=8)
parser.add_argument('--step_size', '-s', type=float, default=0.02)
parser.add_argument('--delta_std', '-std', type=float, default=.03)
parser.add_argument('--n_workers', '-e', type=int, default=18)
parser.add_argument('--rollout_length', '-r', type=int, default=1000)
# for Swimmer-v1 and HalfCheetah-v1 use shift = 0
# for Hopper-v1, Walker2d-v1, and Ant-v1 use shift = 1
# for Humanoid-v1 used shift = 5
parser.add_argument('--shift', type=float, default=0)
parser.add_argument('--seed', type=int, default=237)
parser.add_argument('--policy_type', type=str, default='linear')
parser.add_argument('--dir_path', type=str, default='data')
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument('number', type=int, nargs='*')
return parser.parse_args()
def main():
parser = argparse.ArgumentParser()
## Env setup
parser.add_argument('--env_name', type=str, default='point-v0')
parser.add_argument('--num_agents', '-na', type=int, default=5)
parser.add_argument('--seed', '-sd', type=int, default=0)
parser.add_argument('--max_iter', '-it', type=int, default=2000)
parser.add_argument('--policy', '-po', type=str, default='FC')
parser.add_argument('--embedding', '-em', type=str, default='a_s')
parser.add_argument('--num_workers', '-nw', type=int, default=4)
parser.add_argument('--filename', '-f', type=str, default='')
parser.add_argument('--num_evals', '-ne', type=int, default=0)
parser.add_argument('--flush', '-fl', type=int, default=1000) # may need this. it resets ray, because sometimes it fills the memory.
parser.add_argument('--ob_filter', '-ob', type=str, default='MeanStdFilter') # 'NoFilter'
parser.add_argument('--w_nov', '-wn', type=float, default=-1) # if negative it uses the adaptive method, else it will be fixed at the value you pick (0,1). Note that if you pick 1 itll be unsupervised (ie no reward)
parser.add_argument('--dpp_kernel', '-ke', type=str, default='rbf')
parser.add_argument('--states', '-ss', type=str, default='random-20') # 'random-X' X is how many
parser.add_argument('--update_states', '-us', type=int, default=20) # how often to update.. we only used 20
args = parser.parse_args()
params = vars(args)
params = get_experiment(params)
ray.init()
os.environ['RAY_USE_NEW_GCS'] = 'True'
state_word = [str(params['states'].split('-')[0]) if params['w_nov'] > 0 else ''][0]
params['dir'] = params['env_name'] + '_Net' + str(params['layers']) + 'x' + str(params['h_dim']) + '_Agents' + str(params['num_agents']) + '_Novelty' + str(params['w_nov']) + state_word + 'kernel_' + params['dpp_kernel'] + '_lr' + str(params['learning_rate']) + '_' + params['filename'] + params['ob_filter']
if not(os.path.exists('data/'+params['dir'])):
os.makedirs('data/'+params['dir'])
os.makedirs('data/'+params['dir']+'/weights')
os.makedirs('data/'+params['dir']+'/results')
train(params)
R = 0.12*W_ref
canvas = ROOT.TCanvas('canvas', 'canvas', 50, 50, W, H)
canvas.SetFillColor(0)
canvas.SetBorderMode(0)
canvas.SetFrameFillStyle(0)
canvas.SetFrameBorderMode(0)
canvas.SetLeftMargin( L/W )
canvas.SetRightMargin( R/W )
canvas.SetTopMargin( T/H )
canvas.SetBottomMargin( B/H )
canvas.SetTickx(0)
canvas.SetTicky(0)
parser = argparse.ArgumentParser()
parser.add_argument('file', help='JSON file you want to draw')
parser.add_argument('output', help='Output filename (pdf extension will be added)')
args = parser.parse_args()
data = {}
with open(args.file, 'r') as f:
data = json.load(f)
if data['dimension'] != 2:
raise Exception("Only 2-d scale-factors / efficiencies are supported")
if 'formula' in data and data['formula']:
raise Exception("Formula are not supported")
x_min = data['binning']['x'][0]
return received
### Logging Config ###
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
fh = logging.FileHandler('sfc_controller.log')
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
fh.setFormatter(formatter)
logger.addHandler(fh)
#configurations
parser = argparse.ArgumentParser() #handler for arguments passed
parser.add_argument("-s", "--server",help="pass the local server ip. If not, it finds it automatically",type=str) # option configurations, needs to be required
parser.add_argument("-i", "--brint",help="pass the connection of br-int to br-tun port, or use default '2' ",type=str)
parser.add_argument("-p", "--provider",help="pass the connection of br-provider to br-int port, or use default '2' ",type=str)
parser.add_argument("-t", "--tun",help="pass the connection of br-tun to br-int port, or use default '2' ",type=str) # TODO number of nodes. and port corresponding to nodes
args = parser.parse_args() # pass the arguments to the parser
# default values for ports
brintTun = "2"
brintport = "2"
brprovider = "2"
logger.info("")
logger.info("===SONATA PROJECT===")
logger.info("Starting SFC Agent")
options = Config.options(section)
for option in options:
try:
dict_conf[option] = Config.get(section, option)
if dict_conf[option] == -1:
DebugPrint("skip: %s" % option)
except:
print("exception on %s!" % option)
dict_conf[option] = None
return dict_conf
# ./capture.py -a ../config/system.conf -b ../config/pipeline.conf -c 0 -d 0 -e 0 -f 1
if __name__ == "__main__":
parser = argparse.ArgumentParser(description='To capture data from given beam (with given part if the data arrives with multiple parts) with a docker container')
parser.add_argument('-a', '--system_conf', type=str, nargs='+',
help='The configuration of PAF system')
parser.add_argument('-b', '--pipeline_conf', type=str, nargs='+',
help='The configuration of pipeline')
parser.add_argument('-c', '--beam', type=int, nargs='+',
help='The beam id from 0')
parser.add_argument('-d', '--part', type=int, nargs='+',
help='The part id from 0')
parser.add_argument('-e', '--hdr', type=int, nargs='+',
help='Record packet header or not')
parser.add_argument('-f', '--bind', type=int, nargs='+',
help='Bind threads to cpu or not')
args = parser.parse_args()
system_conf = args.system_conf[0]
pipeline_conf = args.pipeline_conf[0]
beam = args.beam[0]
# Parsing command line argument in normal file.
import json
import parser
import argparse
parser = argparse.ArgumentParser()
#parser.add_argument("name") #If you are using this option then no need to put '--name' option while giving
#commandline arguments.
# while executing the program, you need to specify '--name anyname'(space)'--age integer'(space)'--id integer'
parser.add_argument("--name")
parser.add_argument("--age")
parser.add_argument("--id")
args = parser.parse_args()
print "Hello " + args.name
print "your age is :" + args.age
print "and your ID is :" + args.id
from mnist_m import MNISTM
from torchvision import transforms
from syn_digits import Loadsyn
from torchvision.utils import save_image
from model.InterpolationGAN_v3 import InterpolationGAN
from domain_style_transfer import minibatch_transfer
import numpy as np
import torchvision
import parser
import argparse
parser = argparse.ArgumentParser(description='Domain generalization')
parser.add_argument('--image_size', type=int, default=32)
parser.add_argument('--g_conv_dim', type=int, default=64)
parser.add_argument('--d_conv_dim', type=int, default=64)
parser.add_argument('--num_classes', type=int, default=10)
parser.add_argument('--lambda_cycle', type=float, default=10.0)
parser.add_argument('--n_res_blocks', type=int, default=3)
args = parser.parse_args()
device = torch.device('cuda')
trans = transforms.Compose([
transforms.Resize(size=[32, 32]),
transforms.ToTensor(),
transforms.Lambda(lambda x: x.repeat(3, 1, 1)),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
def post(self):
try:
parser = reqparse.RequestParser()
parser.add_argument('analytic_name',
type=str,
location="json",
required=True)
parser.add_argument('method',
type=str,
location="json",
required=True)
parser.add_argument('request_id',
type=str,
location="json",
required=True)
args = parser.parse_args()
path = server_path + "/" + args.get(
"request_id") + "/" + "preprocess"
file = os.listdir(path)
df = pandas.read_csv(path + "/" + file[0])
module_name = "analytics." + args.get('analytic_name')
module = importlib.import_module(module_name)
analytic_class = getattr(module, args.get("analytic_name"))
if args.get("method") == "train":
result = analytic_class.train(df)
if result["status"] == "success":
path = server_path + "/" + args.get(
"request_id") + "/" + args.get("analytic_name")
if os.path.exists(path):
pass
else:
os.mkdir(path)
file_name = os.path.join(path, "model.json")
fp = open(file_name, "w")
json.dump(result, fp)
fp.close()
return result
elif args.get("method") == "score":
path = server_path + "/" + args.get(
"request_id") + "/" + args.get("analytic_name")
model_file = os.path.join(path, "model.json")
fp = open(model_file, "r")
dct_model = json.load(fp)
fp.close()
result, df_out, error = analytic_class.score(
df, dct_model["coeff"])
if result == "success":
if os.path.exists(path):
pass
else:
os.mkdir(path)
file_name = os.path.join(path, "output.csv")
df_out.to_csv(file_name, index=False)
return {"status": "success"}
else:
return {"status": "failed", "error": error}
except Exception as e:
return {"status": "failed", "error": str(e)}
profile, LoadBalancerName, DNSName, OtherPolicies_name,
ConnectionDrainingStatus, CrossZoneLoadBalancingStatus,
AccessLogStatus, region, elb_owner, elb_env, elb_asv,
tag_count
])
f.close()
if __name__ == '__main__':
# Define command line argument parser
parser = argparse.ArgumentParser(
description=
'Creates a CSV report about EBS volumes and tracks snapshots on them.')
parser.add_argument(
'--regions',
default=AWS_REGIONS,
help=
'AWS regions to create the report on, can add multiple with | as separator. Default will assume all regions'
)
parser.add_argument(
'--profile',
default=AWS_PROFILE,
help=
'AWS profile to create the report on, can add multiple with | as separator. Default will assume all profile'
)
parser.add_argument('--file',
required=True,
help='Path for output CSV file')
args = parser.parse_args()
# creates the report
retval = create_rds_report(args.regions, args.profile, args.file)
if retval:
plt.colorbar()
plt.axis('off')
name = int(np.random.uniform()*1e10)
plt.savefig(\
output_dir+str(name)+'.png',
bbox_inches='tight',
dpi = 2*512,
)
return
if __name__ == '__main__':
parser = argparse.ArgumentParser("testing MOM MRM LF2")
parser.add_argument('-n', '--n-images', type=int, default = -1, help='number of images to process; -1 to process all the images')
args = parser.parse_args()
array_dir = '../FLAT/trans_render/static/'
data_dir = '../FLAT/kinect/'
# initialize the camera model
tof_cam = kinect_real_tf()
# input the folder that trains the data
# only use the files listed
f = open('../FLAT/kinect/list/test_dyn.txt','r')
message = f.read()
files = message.split('\n')
tests = files[0:-1]
if args.n_images!=-1:
# np.where(data["mutation_type"].str.contains("-"), "deletion",
# np.where(data['mutation_type'].isin(['GA', 'AG', 'CT', 'TC']),
# 'transition', 'transversion')))
# data = data[data["mutation_class"] != "deletion"]
# grouped = data.groupby(["source", "Pos"], as_index=False)["counts_for_position"].agg("sum")
# data = pd.merge(data, grouped, on=["source", "Pos"])
# data["adjusted_freq"] = (np.where(1 > data["counts_for_position_x"], 1, data["counts_for_position_x"]) / data[
# "counts_for_position_y"])
#
# gamma_distributions = []
# gamma_distributions.extend(learn_gammas(data[data["source"] == label_control]))
#
# to_call = data[data["source"] == label_sample].copy()
# to_call.loc[:, "to_call"] = to_call.apply(
# lambda row: call_by_gamma(row["adjusted_freq"], row["mutation_type"], row["prev"], row["next"],
# gamma_distributions), axis=1)
#
# output_to_file(to_call[(to_call["source"] == label_sample)], args.output)
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("sample", type=str, help="input sample .freqs file")
parser.add_argument("control", type=str, help="input control .freqs file")
parser.add_argument("-c", "--coverage", type=int, help="minimum position coverage to fit and call variants",
required=False, default=100000)
parser.add_argument("-o", "--output", type=str, help="output variant file", required=False,
default="output.var.csv")
args = parser.parse_args(sys.argv[1:])
main(args)
delta_std=params['delta_std'],
logdir=logdir,
rollout_length=params['rollout_length'],
shift=params['shift'],
params=params,
seed = params['seed'])
ARS.train(params['n_iter'])
return
if __name__ == '__main__':
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--env_name', type=str, default='HalfCheetah-v1')
parser.add_argument('--n_iter', '-n', type=int, default=1000)
parser.add_argument('--n_directions', '-nd', type=int, default=8)
parser.add_argument('--deltas_used', '-du', type=int, default=8)
parser.add_argument('--step_size', '-s', type=float, default=0.02)
parser.add_argument('--delta_std', '-std', type=float, default=.03)
parser.add_argument('--n_workers', '-e', type=int, default=18)
parser.add_argument('--rollout_length', '-r', type=int, default=1000)
# for Swimmer-v1 and HalfCheetah-v1 use shift = 0
# for Hopper-v1, Walker2d-v1, and Ant-v1 use shift = 1
# for Humanoid-v1 used shift = 5
parser.add_argument('--shift', type=float, default=0)
parser.add_argument('--seed', type=int, default=237)
parser.add_argument('--policy_type', type=str, default='linear')
parser.add_argument('--dir_path', type=str, default='data')
import torchvision
import torchvision.transforms as transforms
import numpy as np
import os, sys
import copy as cp
import argparse
import importlib
from utils import progress_bar
import parser
#===============================================================================
parser = argparse.ArgumentParser(description='semi-supervised Training')
parser.add_argument('--resume',
'-r',
action='store_true',
help='resume from checkpoint')
parser.add_argument('--path', '-p', help='path to model where to resume')
args = parser.parse_args()
device = 'cuda' if torch.cuda.is_available() else 'cpu'
best_acc = 0 # best test accuracy
start_epoch = 0 # start from epoch 0 or last checkpoint epoch
cfg = config.Config
architecture, type = cfg.net_arch.rsplit(".", 1)
arch = importlib.import_module(architecture)
network = getattr(arch, type)
path_to_dataset = os.path.join(cfg.dataset_dir, cfg.dataset)
dataset = importlib.import_module(cfg.dataset)
