max_stars_repo_path
stringlengths
3
269
max_stars_repo_name
stringlengths
4
119
max_stars_count
int64
0
191k
id
stringlengths
1
7
content
stringlengths
6
1.05M
score
float64
0.23
5.13
int_score
int64
0
5
src/sentry/api/bases/incident.py
overquota/sentry
1
12788751
from __future__ import absolute_import from sentry.api.bases.organization import OrganizationPermission class IncidentPermission(OrganizationPermission): scope_map = { 'GET': ['org:read', 'org:write', 'org:admin'], 'POST': ['org:write', 'org:admin'], 'PUT': ['org:write', 'org:admin'], }
1.71875
2
python/003.py
Evergreen200/projecteuler
0
12788752
<filename>python/003.py<gh_stars>0 def is_prime(n): for i in range(2, int(n / 2) + 1): if n % i == 0 and n != i: return False return True def solution(n): for i in range(1, n): if n % i == 0: p = n // i if is_prime(p): return p if __name__ == '__main__': print(solution(600851475143))
3.78125
4
model_src/black_white/bw_network/backward_model_direction.py
imbyjuli/blackboard-tensorflow-nrp
0
12788753
<reponame>imbyjuli/blackboard-tensorflow-nrp<filename>model_src/black_white/bw_network/backward_model_direction.py<gh_stars>0 from __future__ import absolute_import from __future__ import division from __future__ import print_function # Imports import numpy as np import tensorflow as tf import cv2 import csv from backward_weights import init_locally_backward_weights ,initiate_backward_weights from backward_layers import ait_backwards,pit_backwards,v4_backwards,v2_backwards, create_direction_for_eval tf.logging.set_verbosity(tf.logging.INFO) def ventral_feed_backward(features, labels, mode): #========================================================================================== ####### weights and biases described in v_layers_weights #========================================================================================== n_field_1 = 40 * 40 * 3 use_sparse = True input_layer_size = { #"classes": tf.argmax(input=logits, axis=1), "v2_1": (40,40), "v2_2": (40,40), "v4": (40,40), "PIT": (40,40), "AIT": (5,1) } for degrees in [0,45,90,135]: input_layer_size ["v1_"+str(degrees)] = (40,40) weights, bias = initiate_backward_weights(input_layer_size) packed_backward_weights = init_locally_backward_weights(input_layer_size) #========================================================================================== ####### initiation #========================================================================================== input_layers = {} for key in input_layer_size.keys(): img_x,img_y = input_layer_size [key] features_float = tf.cast(features[key], tf.float32) input_layers[key] = tf.reshape(features_float, [-1, img_x*img_y * 1]) #print(input_layers.keys()) #========================================================================================== ####### layers described in v_layers #========================================================================================== AIT_b = ait_backwards(input_layers) PIT_b = pit_backwards(AIT_b,input_layers,packed_backward_weights, weights,bias, use_sparse = use_sparse) v4_b = v4_backwards(PIT_b,input_layers,packed_backward_weights,weights,bias, use_sparse = use_sparse) v2_b,_,_ = v2_backwards(v4_b,input_layers,packed_backward_weights,weights,bias, use_sparse = use_sparse) # final_dense = tf.layers.dense(v2_backward) logits = v2_b#tf.layers.dense(inputs = v2_b, units = 40 * 40) tf.summary.image("AIT_b",tf.reshape(AIT_b,[-1,40,40,1]),1) tf.summary.image("PIT_b",tf.reshape(PIT_b,[-1,40,40,1]),1) tf.summary.image("v4_b",tf.reshape(v4_b,[-1,40,40,1]),1) tf.summary.image("v2_b",tf.reshape(v2_b,[-1,40,40,1]),1) # final_dense = tf.layers.dense(v2_backward) logits = tf.layers.dense(inputs = v2_b, units = 4) tf.summary.image("logits",tf.reshape(logits,[-1,2,2,1]),1) #========================================================================================== ####### Prediction with Tensorflow #========================================================================================== predictions = { # Generate predictions (for PREDICT and EVAL mode) "classes": tf.argmax(input=logits, axis=1), # Add `softmax_tensor` to the graph. It is used for PREDICT and by the # `logging_hook`. "probabilities": tf.nn.softmax(logits, name="softmax_tensor") } if mode == tf.estimator.ModeKeys.PREDICT: #sess.run(print_activation_dict(return_tensors)) return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions) # Calculate Loss (for both TRAIN and EVAL modes) one_hot_labels = tf.one_hot(indices=tf.cast(labels, tf.int32), depth=4) tf.summary.image("labels",tf.reshape(one_hot_labels,[-1,2,2,1]),1) loss = tf.losses.softmax_cross_entropy( onehot_labels=one_hot_labels , logits=logits) # figure the Training Op (for TRAIN mode) if mode == tf.estimator.ModeKeys.TRAIN: # change optimiser if wanted optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.1) train_op = optimizer.minimize( loss=loss, global_step=tf.train.get_global_step()) return tf.estimator.EstimatorSpec(mode=mode, loss=loss, train_op=train_op) # Add evaluation metrics (for EVAL mode) eval_metric_ops = { "accuracy": tf.metrics.accuracy( labels=labels, predictions=predictions["classes"])} return tf.estimator.EstimatorSpec( mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)
2.34375
2
tests/scrubber/sensitive_string_scrubber_test.py
cgruber/make-open-easy
5
12788754
#!/usr/bin/env python # Copyright 2009 Google Inc. All Rights Reserved. """Tests for finding sensitive strings.""" __author__ = '<EMAIL> (<NAME>)' from google.apputils import resources from google.apputils import basetest from moe import config_utils from moe.scrubber import sensitive_string_scrubber import test_util STRINGS_JSON = config_utils.ReadConfigResource( test_util.TestResourceName('sensitive_strings.json')) class SensitiveWordsTest(basetest.TestCase): """Unittests for the sensitive word search.""" def setUp(self): self.word_scrubber = sensitive_string_scrubber.SensitiveWordScrubber( STRINGS_JSON[u'sensitive_words']) def assertMatch(self, expected_word, line): self.assertEquals([expected_word], self.word_scrubber.FindSensitiveStrings(line)) def assertNoMatch(self, line): self.assertEquals([], self.word_scrubber.FindSensitiveStrings(line)) def testObviousWords(self): self.assertMatch(u'testy', u'testy.delegate()') self.assertMatch(u'secrety', u'void fixForSecrety') self.assertMatch(u'testy', u'http://foo.com/testy/1234') self.assertMatch(u'http://secret.wiki/', u'http://secret.wiki/secret-url') self.assertMatch(u'internal.website.com', u'foo.internal.website.com') self.assertMatch(u'http://secret.wiki/', u'here is one line\nhttp://secret.wiki/secret-url') def testCapitalization(self): self.assertMatch(u'abc', u'void fixForABC') self.assertMatch(u'testy', u'check out the Testy') self.assertMatch(u'secrety', u'notSECRETY') self.assertNoMatch(u'NOTSECRETY') self.assertNoMatch(u'latEsty') # does not match testy self.assertNoMatch(u'notsecretY') # does not match secrety def testNonMatches(self): self.assertNoMatch(u'go to the next line') def testWordExtraction(self): self.assertMatch(u'testy', u'testy') self.assertMatch(u'testy', u' testy ') self.assertMatch(u'testy', u'ThisIsATestyString') self.assertMatch(u'testy', u' public void buildTesty(') self.assertMatch(u'testy', u'THIS_IS_TESTY_A_SECRET_PROJECT') self.assertNoMatch(u'kittens attesty') class SensitiveResTest(basetest.TestCase): """Unittests for the sensitive word search.""" def setUp(self): self.re_scrubber = sensitive_string_scrubber.SensitiveReScrubber( STRINGS_JSON[u'sensitive_res']) def assertMatch(self, expected_string, line): self.assertEquals([expected_string], self.re_scrubber.FindSensitiveStrings(line)) def assertNoMatch(self, line): self.assertEquals([], self.re_scrubber.FindSensitiveStrings(line)) def testSensitiveRes(self): self.assertMatch(u'supersecret', u'thisissosupersecretweneedtoscrubitevenwithinaword') self.assertMatch(u'SUPERSECRET', u'THISISSOSUPERSECRETWENEEDTOSCRUBITEVENWITHINAWORD') self.assertMatch(u'SuPeRsEcReT', u'ThIsIsSoSuPeRsEcReTwEnEeDtOsCrUbItEvEnWiThInAwOrD') self.assertNoMatch(u'notasecret') self.assertMatch(u'.secretcode1.', u'.secretcode1.') self.assertMatch(u' secret_code123 ', u'the secret_code123 is secret') self.assertNoMatch(u'SECRET_CODE_123') self.assertNoMatch(u'THESECRETCODE123') if __name__ == '__main__': basetest.main()
2.75
3
hypertrophy_dataset.py
dozsam13/LHYP
0
12788755
from torch.utils.data import Dataset from torchvision import transforms import torch class HypertrophyDataset(Dataset): def __init__(self, images, targets, device): self.images = images self.targets = targets self.device = device self.augmenter = transforms.Compose([ transforms.ToPILImage(), transforms.RandomAffine([-90, 90]), transforms.ToTensor() ]) self.preprocess = transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor() ]) def __len__(self): return len(self.images) def __getitem__(self, index): image_ = self.images[index] # image_ = self.augmenter(image_) sample = { 'image': torch.tensor(image_, dtype=torch.float, device=self.device), 'target': torch.tensor(self.targets[index], dtype=torch.long, device=self.device) } return sample
2.71875
3
constants.py
Kaoline/ShinobiTool
0
12788756
# file --constants.py-- waiting_message = "Opération en cours... Ça peut être long, et ça bloque la fenêtre." default_search_file = "Shinobis.txt" default_receivers_file = "Destinataires.txt" default_moles_file = "Ennemis.txt" default_message_file = "Message.txt" default_config_file = "Config.txt"
1.148438
1
hawser/errors.py
5elenay/hawser
4
12788757
class UserNotMonitoredError(Exception): """Raises when user not monitored.""" pass class LanyardException(Exception): """Raises when lanyard gives success false but we don't have a support for the exception.""" pass
2.03125
2
oecp/main/category.py
openeuler-mirror/oecp
0
12788758
# -*- encoding=utf-8 -*- """ # ********************************************************************************** # Copyright (c) Huawei Technologies Co., Ltd. 2020-2020. All rights reserved. # [oecp] is licensed under the Mulan PSL v1. # You can use this software according to the terms and conditions of the Mulan PSL v1. # You may obtain a copy of Mulan PSL v1 at: # http://license.coscl.org.cn/MulanPSL # THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR # PURPOSE. # See the Mulan PSL v1 for more details. # Author: # Create: 2021-09-06 # Description: package category # ********************************************************************************** """ import json import logging from enum import Enum, unique from oecp.proxy.rpm_proxy import RPMProxy logger = logging.getLogger("oecp") @unique class CategoryLevel(Enum): CATEGORY_LEVEL_ZERO = 0 # 核心包等级 CATEGORY_LEVEL_ONE = 1 CATEGORY_LEVEL_TWO = 2 CATEGORY_LEVEL_THREE = 3 CATEGORY_LEVEL_NOT_SPECIFIED = 4 # 未指定 @classmethod def level_name_2_enum(cls, name): return {"level1": cls.CATEGORY_LEVEL_ONE, "level2": cls.CATEGORY_LEVEL_TWO, "level3": cls.CATEGORY_LEVEL_THREE}.get(name, cls.CATEGORY_LEVEL_NOT_SPECIFIED) class Category(object): def __init__(self, path): """ :param path: 分类文件,json格式 """ self._src_categories = {} self._bin_categories = {} self.CORE_PKG = {'gcc', 'glibc', 'qemu', 'libvirt', 'docker-engine', 'java-11-openjdk', 'java-1.8.0-openjdk', 'systemd', 'openssh', 'lvm2', 'busybox', 'initscripts'} self._load(path) def _load(self, path): """ :param path: :return: """ try: with open(path, "r") as f: categories = json.load(f) for category in categories: level = CategoryLevel.level_name_2_enum(category["level"]) try: if category["src"]: name = RPMProxy.rpm_n_v_r_d_a(category["src"], dist="category")[0] self._src_categories[name] = level if category["bin"]: name = RPMProxy.rpm_n_v_r_d_a(category["bin"], dist="category")[0] self._bin_categories[name] = level except AttributeError as e: logger.exception(f"\"{category['oecp']}\" or \"{category['bin']}\" is illegal rpm name") raise except FileNotFoundError: logger.exception(f"{path} not exist") raise def category_of_src_package(self, name): """ :param name: :return: """ return self._src_categories.get(name, CategoryLevel.CATEGORY_LEVEL_NOT_SPECIFIED) def category_of_bin_package(self, name): """ :param name: :return: """ if name in self.CORE_PKG: return CategoryLevel.CATEGORY_LEVEL_ZERO return self._bin_categories.get(name, CategoryLevel.CATEGORY_LEVEL_NOT_SPECIFIED)
1.929688
2
src/bleanser/modules/firefox.py
karlicoss/bleanser
13
12788759
#!/usr/bin/env python3 from pathlib import Path from sqlite3 import Connection from bleanser.core import logger from bleanser.core.utils import get_tables from bleanser.core.sqlite import SqliteNormaliser, Tool class Normaliser(SqliteNormaliser): DELETE_DOMINATED = True MULTIWAY = True def __init__(self, db: Path) -> None: # todo not sure about this?.. also makes sense to run checked for cleanup/extract? with self.checked(db) as conn: self.tables = get_tables(conn) def check_table(name: str) -> None: assert name in self.tables, (name, self.tables) check_table('moz_bookmarks') check_table('moz_historyvisits') # moz_annos -- apparently, downloads? def cleanup(self, c: Connection) -> None: tool = Tool(c) tool.drop_index('moz_places_guid_uniqueindex') tool.drop_index('guid_uniqueindex') # on mobile only [(visits_before,)] = c.execute('SELECT count(*) FROM moz_historyvisits') tool.drop_cols( table='moz_places', cols=[ # aggregates, changing all the time 'frecency', 'last_visit_date', 'visit_count', # ugh... sometimes changes because of notifications, e.g. twitter/youtube?, or during page load 'hidden', 'typed', 'title', 'description', 'preview_image_url', 'foreign_count', # jus some internal refcount thing... https://bugzilla.mozilla.org/show_bug.cgi?id=1017502 ## mobile only 'visit_count_local', 'last_visit_date_local', 'last_visit_date_remote', 'sync_status', 'sync_change_counter', ## ] ) # ugh. sometimes changes for no reason... # and anyway, for history the historyvisits table refers place_id (this table's actual id) # also use update instead delete because phone db used to have UNIQUE constraint... c.execute('UPDATE moz_places SET guid=id') tool.drop_cols( table='moz_bookmarks', cols=['lastModified'], # changing all the time for no reason? # todo hmm dateAdded might change when e.g. firefox reinstalls and it adds default bookmarks # probably not worth the trouble ) tool.drop('moz_meta') tool.drop('moz_origins') # prefix/host/frequency -- not interesting # todo not sure... tool.drop('moz_inputhistory') # sanity check just in case... can remove after we get rid of triggers properly... [(visits_after,)] = c.execute('SELECT count(*) FROM moz_historyvisits') assert visits_before == visits_after, (visits_before, visits_after) if __name__ == '__main__': from bleanser.core import main main(Normaliser=Normaliser)
2.21875
2
Problems/Two Pointers/easy/ReverseOnlyLetters/reverse_only_letters.py
dolong2110/Algorithm-By-Problems-Python
1
12788760
def reverseOnlyLetters(s: str) -> str: s = list(s) l, r = 0, len(s) - 1 while l < r: if not s[l].isalpha(): l += 1 elif not s[r].isalpha(): r -= 1 else: s[l], s[r] = s[r], s[l] l += 1 r -= 1 return ''.join(s)
3.5625
4
HarTex/cmds/censor.py
HTG-YT/hartex-discord.py
4
12788761
<filename>HarTex/cmds/censor.py import discord from discord.ext import commands import re import yaml from better_profanity import profanity from core.classes import * def is_zalgo_nickname_enabled(guild_id): with open(f'configurations/{guild_id}_config.yaml', 'r') as zalgo_prevention_enabled: accessor = yaml.safe_load(zalgo_prevention_enabled) nickname_enabled = accessor['plugins']['censorship']['settings']['zalgo']['filter_nicknames'] return nickname_enabled def is_invite_enabled(guild_id): with open(f'configurations/{guild_id}_config.yaml', 'r') as invites_enabled: accessor = yaml.safe_load(invites_enabled) invite_enabled = accessor['plugins']['censorship']['settings']['invites']['filter'] return invite_enabled def is_nickname_invite_enabled(guild_id): with open(f'configurations/{guild_id}_config.yaml', 'r') as nickname_invites: accessor = yaml.safe_load(nickname_invites) invite_nick_enabled = accessor['plugins']['censorship']['settings']['invites']['filter_nicknames'] return invite_nick_enabled def is_domains_enabled(guild_id): with open(f'configurations/{guild_id}_config.yaml', 'r') as domains_enabled: accessor = yaml.safe_load(domains_enabled) domains = accessor['plugins']['censorship']['settings']['domains']['filter'] return domains def domains_list(guild_id): with open(f'configurations/{guild_id}_config.yaml', 'r') as domains_blacklist: accessor = yaml.safe_load(domains_blacklist) domain_list = accessor['plugins']['censorship']['settings']['domains']['filter_list'] return domain_list def is_domains_nickname_enabled(guild_id): with open(f'configurations/{guild_id}_config.yaml', 'r') as nickname_blacklist: accessor = yaml.safe_load(nickname_blacklist) nick_enabled = accessor['plugins']['censorship']['settings']['domains']['filter_nicknames'] return nick_enabled def get_censored_words(guild_id): with open(f'configurations/{guild_id}_config.yaml', 'r') as censored_words: accessor = yaml.safe_load(censored_words) list_of_censored_words = accessor['plugins']['censorship']['settings']['blocked']['words'] return list_of_censored_words def get_ignored_users(guild_id): with open(f'configurations/{guild_id}_config.yaml', 'r') as censored_words: accessor = yaml.safe_load(censored_words) list_of_ignored_users = accessor['plugins']['censorship']['settings']['blocked']['ignored_users'] return list_of_ignored_users def is_zalgo_enabled(guild_id): with open(f'configurations/{guild_id}_config.yaml', 'r') as zalgo_prevention_enabled: accessor = yaml.safe_load(zalgo_prevention_enabled) enabled = accessor['plugins']['censorship']['settings']['zalgo']['filter'] return enabled class Censor(commands.Cog): @commands.Cog.listener() async def on_message(self, message: discord.Message): if message.author.bot: return message_guild: discord.Guild = message.guild list_to_censor = get_censored_words(message_guild.id) profanity.load_censor_words(list_to_censor) ignored_users = get_ignored_users(message_guild.id) if profanity.contains_profanity(message.content): for user in ignored_users: if message.author.id == user: pass else: await message.channel.send("Blacklisted word!") await message.delete() else: pass zalgo_enabled = is_zalgo_enabled(message_guild.id) zalgo_re = re.compile(r"[\u0300-\u036F\u0489]") if zalgo_enabled: if zalgo_re.search(message.content): await message.delete() await message.channel.send("Zalgo detected!") else: pass invites = is_invite_enabled(message_guild.id) if invites: if 'discord.gg' in message.content: await message.delete() await message.channel.send("Invites are not allowed!") else: pass domains = is_domains_enabled(message_guild.id) domain_blacklist = domains_list(message_guild.id) if domains: for domain in domain_blacklist: if str(domain) in message.content: await message.delete() await message.channel.send("This domain is blacklisted!") break else: continue else: pass @commands.Cog.listener() async def on_member_update(self, before: discord.Member, after: discord.Member): member_guild = before.guild def get_censored_nicknames(): with open(f'configurations/{member_guild.id}_config.yaml', 'r') as censored_nicknames: accessor = yaml.safe_load(censored_nicknames) list_of_censored_nicknames = accessor['plugins']['censorship']['settings']['blocked']['nicknames'] return list_of_censored_nicknames censored_nickname = get_censored_nicknames() zalgo_nick_enabled = is_zalgo_nickname_enabled(member_guild.id) zalgo_nick_re = re.compile(r"[\u0300-\u036F\u0489]") if censored_nickname == "True": if profanity.contains_profanity(str(before.nick)): last = before.nick if last: await after.edit(nick=last) else: await after.edit(nick="Nickname Censored") else: pass if zalgo_nick_enabled: if zalgo_nick_re.search(after.nick): last = before.nick if last: await after.edit(nick=last) else: await after.edit(nick="Zalgo Censored") else: pass nickname_invite = is_nickname_invite_enabled(member_guild.id) if nickname_invite: if 'discord.gg' in after.nick: last = before.nick if last: await after.edit(nick=last) else: await after.edit(nick="Invite Censored") else: pass domain_blacklist_enabled = is_domains_nickname_enabled(member_guild.id) domain_list = domains_list(member_guild.id) if domain_blacklist_enabled: for domain in domain_list: if str(domain) in after.nick: last = before.nick if last: await after.edit(nick=last) break else: await after.edit(nick="Domain Censored") break else: continue else: pass def setup(hartex): hartex.add_cog(Censor(hartex))
2.296875
2
day2/passValidator.py
IvantheDugtrio/adventofcode2020
0
12788762
<filename>day2/passValidator.py<gh_stars>0 #!/usr/bin/env python3 import sys validCount = 0 lineCount = 0 with open(sys.argv[1],'r') as fp: for line in fp: lineCount+=1 criteria = line.split(": ")[0] password = line.split(": ")[1].strip() keyChar = criteria.split(" ")[1] keyRange = criteria.split(" ")[0] minKeyCnt = int(keyRange.split("-")[0]) maxKeyCnt = int(keyRange.split("-")[1]) # Part 1 #keyCharCount = password.count(keyChar) #if keyCharCount >= minKeyCnt and keyCharCount <= maxKeyCnt: # validCount+=1 # Part 2 if ((password[minKeyCnt-1] == keyChar or password[maxKeyCnt-1] == keyChar) and not (password[minKeyCnt-1] == keyChar and password[maxKeyCnt-1] == keyChar)): validCount+=1 print("There are ",lineCount," passwords given") print("There are ",validCount," valid passwords")
3.703125
4
tests/utest/oxygen/test_oxygen_listener.py
vrchmvgx/robotframework-oxygen
0
12788763
<filename>tests/utest/oxygen/test_oxygen_listener.py from unittest import TestCase from unittest.mock import Mock, patch from oxygen import listener class OxygenListenerBasicTests(TestCase): def setUp(self): self.listener = listener() def test_listener_api_version_is_not_changed_accidentally(self): self.assertEqual(self.listener.ROBOT_LISTENER_API_VERSION, 2) def mock_lib_instance(self, mock_builtin, return_value): m = Mock() m.get_library_instance.return_value = return_value mock_builtin.return_value = m return m @patch('oxygen.oxygen.BuiltIn') def test_end_test_when_library_was_not_used(self, mock_builtin): m = self.mock_lib_instance(mock_builtin, None) self.listener.end_test('foo', {}) m.get_library_instance.assert_called_once_with('oxygen.OxygenLibrary') self.assertEqual(self.listener.run_time_data, {}) @patch('oxygen.oxygen.BuiltIn') def test_end_test_when_library_was_used(self, mock_builtin): o = lambda: None o.data = 'I do not have a solution, but I do admire the problem' m = self.mock_lib_instance(mock_builtin, o) self.listener.end_test('oxygen.OxygenLibrary', {'longname': 'hello'}) m.get_library_instance.assert_called_once_with('oxygen.OxygenLibrary') self.assertEqual(self.listener.run_time_data, {'hello': ('I do not have a solution, but I do ' 'admire the problem')})
2.578125
3
src/sendresults.py
ldolberg/the_port_ors_hdx
0
12788764
<reponame>ldolberg/the_port_ors_hdx<gh_stars>0 import pandas as pd import json def return_jsonlist(district,lat,lon,tag,json_list): # -- open 'Nepal_F_Tagged.csv' new_df = pd.read_csv('../data/Nepal/Nepal_F_Tagged.csv') total, percentage = total_percent_from_district_tag(district, tag, df) # -- get district from order_districts # -- use get_coordinates(district) to get lat, lon # -- get tag from query # -- add entry in json-compatible format: json_list.append({"Name":district, "lat":lat, "long":lon, "tag": tag,"type": "feedback", "d":{ "#1 Concern": total, "#1 Concern percentage":percentage} }) return json_list def total_percent_from_district_tag(district, tag, df): total = df[(df['District']==district)&(df['Tag']==tag)]['Count'].sum() surveyed_ppl_from_district = df[df['District']==district]['Count'].sum() percentage = total/surveyed_ppl_from_district return total, percentage def slice_df(df, query={}): # -- approach two (builds slicing vector, *then* applies it) # -- more efficient # I'm assuming query is a dictionary # query = {'Tag':tag, 'District':district, 'Gender':gender, 'Ethnicity':ethnicity} # -- select fields s.t. the df has them valid_query_args = list(df.columns) ret = df.copy() for requirement, value in query.iteritems(): if requirement in valid_query_args: if requirement != 'Tag': ret = ret[ret[requirement] == value] # slicing without Tag denominator = ret['Count'].sum() ret = ret[ret['Tag'] == query['Tag']] # slicing with Tag numerator = ret['Count'].sum() total = numerator percentage = numerator/max(denominator,1) return total, percentage
3.078125
3
examples/basic/mesh_threshold.py
Gjacquenot/vtkplotter
7
12788765
<filename>examples/basic/mesh_threshold.py """ Extracts the cells where scalar value satisfies a threshold criterion. """ from vtkplotter import * doc = Text(__doc__) man = load(datadir+"man.vtk") scals = man.coordinates()[:, 1] + 37 # pick y coords of vertices man.pointColors(scals, cmap="cool") man.addScalarBar(title="threshold", horizontal=True) # make a copy and threshold the mesh cutman = man.clone().threshold(scals, vmin=36.9, vmax=37.5) printInfo(cutman) # distribute the actors on 2 renderers show([[man, doc], cutman], N=2, elevation=-30, axes=0)
2.875
3
coviddata.py
Paul567/MBCovidVaxTracker
0
12788766
import requests import json class CovidData: __data = [{}] __province = '' __population = -1 def __init__(self, province): self.__province = province.upper() reports = json.loads( requests.get( 'https://api.covid19tracker.ca/reports/province/' + self.__province ).text ) self.__data = reports['data'] provinces = json.loads( requests.get('https://api.covid19tracker.ca/provinces').text ) for prov in provinces: if prov['code'].upper() == self.__province: self.__population = prov['population'] break @property def data(self): return self.__data @property def __latest_data(self): return self.__data[-1] @property def latest_data(self): return self.__latest_data; @property def __last_week_data(self): return self.__data[-7:] @property def province(self): return self.__province @property def date(self): return self.__latest_data['date'] @property def new_cases(self): return self.__latest_data['change_cases'] @property def total_active(self): return ( self.__latest_data['total_cases'] - self.__latest_data['total_recoveries'] - self.__latest_data['total_fatalities'] ) @property def new_deaths(self): return self.__latest_data['change_fatalities'] @property def total_deaths(self): return self.__latest_data['total_fatalities'] @property def test_positivity(self): cases = 0 tests = 0 for data in self.__data[-5:]: cases += data['change_cases'] tests += data['change_tests'] return cases / tests @property def new_vaccinations(self): return self.__latest_data['change_vaccinations'] @property def total_vaccinations(self): return self.__latest_data['total_vaccinations'] @property def total_vaccines_recieved(self): return self.__latest_data['total_vaccines_distributed'] @property def population(self): return self.__population @property def percent_vaccinated(self): return self.total_vaccinations / self.population @property def percent_vaccines_recieved(self): return self.total_vaccines_recieved / self.population @property def days_until_one_dose_per_person(self): vaccines = 0 for data in self.__last_week_data: vaccines += data['change_vaccinations'] vaccine_rate = vaccines / len(self.__last_week_data) return ( (self.population - self.total_vaccinations) / vaccine_rate ) if __name__ == '__main__': data = CovidData('MB') print(f'{data.province} {data.date}') print(f'-----------------------------------------') print(f'New Cases: {data.new_cases}') print(f'Total Active: {data.total_active}') print(f"Test Positivity: {data.test_positivity:.2%}") print('') print(f'New Deaths: {data.new_deaths}') print(f'Total Deaths: {data.total_deaths}') print('') print(f'New Vaccinations: {data.new_vaccinations}') print(f'Total Vaccinations: {data.total_vaccinations}') print(f"Percent Vaccinated: {data.percent_vaccinated:.2%}") print(f'Percent Vaccine Recieved: {data.percent_vaccines_recieved:.2%}') print(f"Days Until One Dose Per Person: {data.days_until_one_dose_per_person:.0f}")
3.015625
3
helpscout/endpoints/endpoint.py
Gogen120/helpscout
0
12788767
from typing import Dict import requests import helpscout.exceptions as exc class Endpoint: """Base endpoint class.""" def __init__(self, client, base_url: str): """ Params: client: helpscout client with credentials base_url: url for endpoint """ self.client = client self.base_url = base_url def process_get_result(self, response: requests.Response) -> Dict: """Process response with coresponding status code.""" if response.status_code == 400: raise exc.BadRequestException(response.json()) elif response.status_code == 401: raise exc.NotAuthorizedException elif response.status_code == 404: return {} return response.json() def process_result_with_status_code(self, response: requests.Response, status_code): """Process result with given status code. Raise exception if response status code does't match provided one """ if response.status_code != status_code: print(status_code) raise exc.BadRequestException(response.json()) return response.status_code def base_get_request(self, base_url: str, **kwargs) -> requests.Response: """Base get request.""" return requests.get( base_url, headers={"Authorization": f"Bearer {self.client.access_token}"}, params={**kwargs}, ) def base_put_request(self, base_url: str, **kwargs) -> requests.Response: """Base put request.""" return requests.put( base_url, headers={ "Authorization": f"Bearer {self.client.access_token}", "Content-Type": "application/json; charset=UTF-8", }, json={**kwargs}, ) def base_patch_request(self, base_url: str, **kwargs) -> requests.Response: """Base patch request.""" return requests.patch( base_url, headers={ "Authorization": f"Bearer {self.client.access_token}", "Content-Type": "application/json; charset=UTF-8", }, json={**kwargs}, ) def base_post_request(self, base_url: str, **kwargs) -> requests.Response: """Base post request.""" return requests.post( base_url, headers={ "Authorization": f"Bearer {self.client.access_token}", "Content-Type": "application/json; charset=UTF-8", }, json={**kwargs}, ) def base_delete_request(self, base_url: str, **kwargs) -> requests.Response: """Base delete request.""" return requests.delete( base_url, headers={"Authorization": f"Bearer {self.client.access_token}"} )
2.703125
3
geocamUtil/Installer.py
geocam/geocamUtilWeb
4
12788768
#!/usr/bin/env python # __BEGIN_LICENSE__ #Copyright (c) 2015, United States Government, as represented by the #Administrator of the National Aeronautics and Space Administration. #All rights reserved. # __END_LICENSE__ import os import logging import stat from glob import glob import shutil import itertools from geocamUtil.Builder import Builder from django.conf import settings class Installer(object): def __init__(self, builder=None, logger=None): if builder is None: builder = Builder() if logger is None: logger = logging self.builder = builder self.logger = logger @staticmethod def joinNoTrailingSlash(a, b): if b == '': return a else: return a + os.path.sep + b def dosys(self, cmd): self.logger.info('running:', cmd) ret = os.system(cmd) if ret != 0: self.logger.warning('[command exited with non-zero return value %d]' % ret) def getFiles(self, src, suffix=''): path = self.joinNoTrailingSlash(src, suffix) try: pathMode = os.stat(path)[stat.ST_MODE] except OSError: # couldn't stat file, e.g. broken symlink, ignore it return [] if stat.S_ISREG(pathMode): return [suffix] elif stat.S_ISDIR(pathMode): return itertools.chain([suffix], *[self.getFiles(src, os.path.join(suffix, f)) for f in os.listdir(path)]) else: return [] # not a dir or regular file, ignore def installFile(self, src, dst): if os.path.isdir(src): if os.path.exists(dst): if not os.path.isdir(dst): # replace plain file with directory os.unlink(dst) os.makedirs(dst) else: # make directory os.makedirs(dst) else: # install plain file if not os.path.exists(os.path.dirname(dst)): os.makedirs(os.path.dirname(dst)) if settings.GEOCAM_UTIL_INSTALLER_USE_SYMLINKS: if os.path.isdir(dst): dst = os.path.join(dst, os.path.basename(src)) if os.path.lexists(dst): os.unlink(dst) os.symlink(os.path.realpath(src), dst) else: shutil.copy(src, dst) def installRecurse0(self, src, dst): for f in self.getFiles(src): dst1 = self.joinNoTrailingSlash(dst, f) src1 = self.joinNoTrailingSlash(src, f) self.builder.applyRule(dst1, [src1], lambda: self.installFile(src1, dst1)) def installRecurse(self, src, dst): logging.info('installRecurse %s %s', src, dst) self.installRecurse0(src, dst) def installRecurseGlob0(self, srcs, dst): logging.debug('installRecurseGlob0 srcs=%s dst=%s', srcs, dst) for src in srcs: self.installRecurse0(src, os.path.join(dst, os.path.basename(src))) def installRecurseGlob(self, pat, dst): logging.info('installRecurseGlob %s %s', pat, dst) self.installRecurseGlob0(glob(pat), dst)
2.015625
2
train_model.py
olaals/end-to-end-RGB-pose-estimation-baseline
2
12788769
#from models.baseline_net import BaseNet import torch from data_loaders import * from image_dataloaders import get_dataloaders from loss import compute_ADD_L1_loss, compute_disentangled_ADD_L1_loss, compute_scaled_disentl_ADD_L1_loss from rotation_representation import calculate_T_CO_pred #from models.efficient_net import from models import fetch_network import os from parser_config import get_dict_from_cli import pickle import matplotlib.pyplot as plt from visualization import visualize_examples from test_model import evaluate_model, validate_model from torch.utils.tensorboard import SummaryWriter import time import datetime torch.autograd.set_detect_anomaly(True) def pickle_log_dict(log_dict, logdir): save_path = os.path.join(logdir, "log_dict.pkl") with open(save_path, 'wb') as handle: pickle.dump(log_dict, handle, protocol=pickle.HIGHEST_PROTOCOL) def calculate_eta(start_time, perc_complete): curr_time = time.time() sec_since_start = curr_time - start_time est_total_time = sec_since_start/perc_complete est_remaining = est_total_time-sec_since_start return str(datetime.timedelta(seconds=est_remaining)) def save_loss_plot(losses, training_examples, loss_name, logdir): assert len(losses) == len(training_examples) fig,ax = plt.subplots() fig.set_size_inches(9.5, 5.5) ax.set_title(loss_name) ax.set_xlabel("Training examples") ax.set_ylabel(loss_name) ax.set_yscale('log') plt.plot(training_examples, losses) save_path = os.path.join(logdir, loss_name.replace(" ", "-")+".png") plt.savefig(save_path) plt.close() def save_plot_validation_loss(val_data_struct,logdir, loss_name): fig,ax = plt.subplots() fig.set_size_inches(9.5, 5.5) ax.set_title("Validation " + loss_name) ax.set_xlabel("Training examples") ax.set_ylabel(loss_name) ax.set_yscale('log') train_exs = [] val_losses_arr = [] for (train_ex, val_losses) in val_data_struct: train_exs.append(train_ex) val_losses_arr.append(val_losses) val_losses = np.array(val_losses_arr) train_exs = np.array(train_exs) legends = [] for pred_iter in range(val_losses.shape[1]): legends.append("Pred.iter"+str(pred_iter+1)) iter_val_losses = val_losses[:,pred_iter] plt.plot(train_exs,iter_val_losses, label="Iter. "+str(pred_iter)) ax.legend(legends) save_path = os.path.join(logdir, "validation-"+loss_name.replace(" ", "-")+".png") plt.savefig(save_path) plt.close() def logging(model, config, writer, log_dict, logdir, batch_num, train_examples): log_interval = config["logging"]["log_save_interval"] if(batch_num%log_interval == 0): current_loss = log_dict["loss"]["add_l1"][:batch_num] current_train_ex =log_dict["loss"]["train_ex"][:batch_num] save_loss_plot(current_loss, current_train_ex, "ADD L1 Loss", logdir) pickle_log_dict(log_dict, logdir) save_viz_batches = config["logging"]["save_visualization_at_batches"] save_viz_every_n_batch = config["logging"]["save_viz_every_n_batch"] if((batch_num in save_viz_batches) or (batch_num%save_viz_every_n_batch==0 and batch_num!=0)): save_dir = os.path.join(logdir, "visualizations") os.makedirs(save_dir, exist_ok=True) visualize_examples(model, config, "train", show_fig=False, save_dir=save_dir, n_train_examples=train_examples) visualize_examples(model, config, "val", show_fig=False, save_dir=save_dir, n_train_examples=train_examples) validation_interval = config["logging"]["validation_interval"] if(batch_num%validation_interval == 0 and batch_num != 0): val_ex = config["logging"]["val_examples_from_each_class"] #loss_dict, mean_losses = evaluate_model(model, config, "train", use_all_examples=False, max_examples_from_each_class=val_ex) mean_losses = validate_model(model, config, "val") #log_dict["val_loss_dicts"].append((train_examples, loss_dict)) log_dict["val_loss"].append((train_examples, mean_losses)) pickle_log_dict(log_dict, logdir) save_plot_validation_loss(log_dict["val_loss"], logdir, "ADD L1 loss") #tensorboard iter_dict = {} for i in range(len(mean_losses)): writer.add_scalar(f'Validation_ADD_L1_loss/Iter{i}', mean_losses[i], train_examples) iter_dict[f'Iter{i}'] = mean_losses[i] writer.add_scalars('Validation_ADD_L1_loss_iters', iter_dict, train_examples) model.train() def train(config): scene_config = config["scene_config"] # dataset config model3d_dataset = config["dataset_config"]["model3d_dataset"] train_classes = config["dataset_config"]["train_classes"] train_from_imgs = config["dataset_config"]["train_from_images"] ds_conf = config["dataset_config"] batch_size = config["train_params"]["batch_size"] img_ds_name = ds_conf["img_dataset"] if train_from_imgs: train_loader, val_loader, test_loader = get_dataloaders(ds_conf, batch_size) # model load parameters model_name = config["network"]["backend_network"] rotation_repr = config["network"]["rotation_representation"] device = config["train_params"]["device"] use_pretrained = config["model_io"]["use_pretrained_model"] model_save_dir = config["model_io"]["model_save_dir"] os.makedirs(model_save_dir, exist_ok=True) pretrained_name = config["model_io"]["pretrained_model_name"] pretrained_path = os.path.join(model_save_dir, pretrained_name) use_norm_depth = config["advanced"]["use_normalized_depth"] # model saving save_every_n_batch = config["model_io"]["batch_model_save_interval"] model_save_name = config["model_io"]["model_save_name"] model_save_path = os.path.join(model_save_dir, model_save_name) cam_intrinsics = config["camera_intrinsics"] img_size = cam_intrinsics["image_resolution"] model = fetch_network(model_name, rotation_repr, use_norm_depth, use_pretrained, pretrained_path) model = model.to(device) #train params learning_rate = config["train_params"]["learning_rate"] opt_name = config["train_params"]["optimizer"] num_train_batches = config["train_params"]["num_batches_to_train"] num_sample_verts = config["train_params"]["num_sample_vertices"] device = config["train_params"]["device"] loss_fn_name = config["train_params"]["loss"] # train iteration policy, i.e. determine how many iterations per batch train_iter_policy_name = config["advanced"]["train_iter_policy"] policy_argument = config["advanced"]["train_iter_policy_argument"] if train_iter_policy_name == 'constant': train_iter_policy = train_iter_policy_constant elif train_iter_policy_name == 'incremental': train_iter_policy = train_iter_policy_incremental else: assert False # parallel rendering use_par_render = config["scene_config"]["use_parallel_rendering"] if(opt_name == "adam"): optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate) elif(opt_name == 'sgd'): optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate) else: assert False # print training info print("") print(" ### TRAINING IS STARTING ### ") print("Loading backend network", model_name.upper(), "with rotation representation", rotation_repr) print("Batch size", batch_size, "Learning rate", learning_rate, "Optimizer", opt_name.upper()) print("Training on device", device) if use_pretrained: print("Pretrained model is loaded from", pretrained_path) else: print("No pretrained model used, training from scratch") print("The model will be saved to", model_save_path) if use_norm_depth: print("The model is trained with the normalized depth from the CAD model (advanced)") print("") # logging log_dict = {} log_dict["loss"] = {} log_dict["loss"]["add_l1"] = np.zeros((num_train_batches+1)) log_dict["loss"]["train_ex"] = np.zeros((num_train_batches+1)) log_dict["val_loss_dicts"] = [] log_dict["val_loss"] = [] logdir = config["logging"]["logdir"] os.makedirs(logdir, exist_ok=True) writer = SummaryWriter(log_dir=os.path.join("tensorboard", img_ds_name, config["config_name"])) start_time = time.time() """ TRAINING LOOP """ train_examples=0 new_batch_num=0 batch_num=0 while(True): start_time = time.time() init_imgs, gt_imgs, T_CO_init, T_CO_gt, mesh_verts, mesh_paths, depths, cam_mats = next(iter(train_loader)) init_imgs = init_imgs.numpy() gt_imgs = gt_imgs.numpy() depths = depths.numpy() T_CO_gt = T_CO_gt.to(device) mesh_verts = mesh_verts.to(device) #cam_mats = get_camera_mat_tensor(cam_intrinsics, batch_size).to(device) T_CO_pred = T_CO_init # current pred is initial train_iterations = train_iter_policy(batch_num, policy_argument) for j in range(train_iterations): optimizer.zero_grad() if(j==0 and train_from_imgs): pred_imgs = init_imgs T_CO_pred = T_CO_pred.to(device) else: pred_imgs, depths = render_batch(T_CO_pred, mesh_paths, cam_mats, img_size, use_par_render) T_CO_pred = torch.tensor(T_CO_pred).to(device) model_input = prepare_model_input(pred_imgs, gt_imgs, depths, use_norm_depth).to(device) model_output = model(model_input) T_CO_pred_new = calculate_T_CO_pred(model_output, T_CO_pred, rotation_repr, cam_mats) addl1_loss = compute_ADD_L1_loss(T_CO_gt, T_CO_pred_new, mesh_verts) loss_handler(loss_fn_name, addl1_loss, T_CO_pred_new, T_CO_pred, T_CO_gt, mesh_verts) optimizer.step() T_CO_pred = T_CO_pred_new.detach().cpu().numpy() # Printing and logging elapsed = time.time() - start_time print(f'ADD L1 loss for train batch {batch_num}, with {new_batch_num} new batches, train iter {j}: {addl1_loss.item():.4f}, batch time: {elapsed:.3f}') log_dict["loss"]["add_l1"][batch_num] = addl1_loss.item() log_dict["loss"]["train_ex"][batch_num] = train_examples logging(model, config, writer, log_dict, logdir, batch_num, train_examples) if batch_num != 0 and batch_num%save_every_n_batch == 0: writer.add_scalar("ADD_L1_loss", addl1_loss.item(), train_examples) perc_complete = (batch_num*1.0)/num_train_batches print("Saving model to", model_save_path) print(f'Trained {batch_num} of {num_train_batches}. Training {(perc_complete*100.0):.3f} % complete.') print(f'Estimated remaining training time (hour,min,sec): {calculate_eta(start_time, perc_complete)}') torch.save(model.state_dict(), model_save_path) if batch_num >= num_train_batches: break train_examples=train_examples+batch_size batch_num += 1 new_batch_num += 1 if batch_num >= num_train_batches: break """ END TRAIN LOOP """ def loss_handler(loss_fn_name, addl1_loss, T_CO_pred_new, T_CO_pred, T_CO_gt, mesh_verts): if loss_fn_name == "add_l1": addl1_loss.backward() elif loss_fn_name == "add_l1_disentangled": disentl_loss = compute_disentangled_ADD_L1_loss(T_CO_gt, T_CO_pred_new, mesh_verts) disentl_loss.backward() elif loss_fn_name == "add_l1_disentl_scaled": sc_disentl_loss = compute_scaled_disentl_ADD_L1_loss(T_CO_pred, T_CO_pred_new, T_CO_gt, mesh_verts) sc_disentl_loss.backward() def train_iter_policy_constant(current_batch, num): return num def train_iter_policy_incremental(current_batch, increments_tuple_list): # input must have form [(300, 2), (1000,3), (3000,4)] new_train_iters = 1 for (batch_num, train_iters) in increments_tuple_list: if (current_batch>batch_num): new_train_iters = train_iters return new_train_iters if __name__ == '__main__': config = get_dict_from_cli() train(config)
1.929688
2
stats.py
Vidar-Petersson/Gymnasiearbete
0
12788770
import pandas as pd import matplotlib.pyplot as plt import matplotlib.dates as mdates import seaborn as sns import numpy as np from misc import set_size from scipy import stats from scipy.interpolate import interp1d from pandas.plotting import table import statsmodels.api as sm df_knolls_grund = pd.read_csv("data-set\knolls_grund.csv", sep=";", parse_dates=["Datum Tid (UTC)"], index_col="Datum Tid (UTC)", usecols = ['Datum Tid (UTC)','Havstemperatur']) df_huvudskar = pd.read_csv("data-set\huvudskar.csv", sep=";", parse_dates=["Datum Tid (UTC)"], index_col="Datum Tid (UTC)") df_huvudskar = df_huvudskar.loc[df_huvudskar["Matdjup"]==1] df_huvudskar = df_huvudskar.drop(columns=["Kvalitet", "Matdjup"]) df_finngrundet = pd.read_csv("data-set/finngrundet.csv", sep=";", parse_dates=["Datum Tid (UTC)"], index_col="Datum Tid (UTC)", usecols = ['Datum Tid (UTC)','Havstemperatur']) start, end = '2020-09-28', '2020-11-29' df_finngrundet = df_finngrundet.loc[start:end] df_huvudskar = df_huvudskar.loc[start:end] df_knolls_grund = df_knolls_grund.loc[start:end] smhi_mean = pd.concat([df_knolls_grund, df_huvudskar, df_finngrundet]).groupby(level=0).mean() smhi_mean = smhi_mean["Havstemperatur"].rolling(3, center=True).mean() df1 = pd.read_csv("data-set/sst.csv", sep=",", parse_dates=["Datum Tid (UTC)"], index_col="Datum Tid (UTC)") df1.sort_values(by=['Datum Tid (UTC)'], inplace=True) df1 = df1.loc[start:end] df1['month'] = [d.strftime('%b') for d in df1.index] df1['week'] = [d.strftime('%U') for d in df1.index] #print(smhi_mean) #temp_bias = 3.35 #df1["Havstemperatur"] = df1["Havstemperatur"] + temp_bias def bias(df): df_1d = df["Havstemperatur"].resample('D').mean() smhi_1d = smhi_mean["Havstemperatur"].resample('D').mean() concatTemp = pd.concat([df_1d, smhi_1d]).groupby(level=0) print(concatTemp.head(20)) print(concatTemp) def data_comp(df): pd.set_option("display.max_rows", None, "display.max_columns", None) df_1d = df["Havstemperatur"].resample('D').mean() smhi_1d = smhi_mean.resample('D').mean() df_1d, smhi_1d = df_1d.align(smhi_1d) print(df_1d) #df_1d = df_1d.interpolate(method='time') #diff = smhi_1d - df_1d #slope = pd.Series(np.gradient(df_1d.values), df_1d.index, name='slope') #print(slope.mean()) def smhi(): df_finngrundet.reset_index(inplace=True) df_huvudskar.reset_index(inplace=True) df_knolls_grund.reset_index(inplace=True) #smhi_7d.reset_index(inplace=True) fig, ax = plt.subplots() ax.plot(df_finngrundet["Datum Tid (UTC)"], df_finngrundet["Havstemperatur"],linestyle='--', label='Finngrundet') ax.plot(df_huvudskar["Datum Tid (UTC)"], df_huvudskar["Havstemperatur"],linestyle='--', label='Huvudskär') ax.plot(df_knolls_grund["Datum Tid (UTC)"], df_knolls_grund["Havstemperatur"],linestyle='--', label='Knolls grund') ax.plot(smhi_mean.loc[start:end], label='Medelvärde (Referensdata)') ax.legend() ax.set_ylabel('Temperatur [°C]', fontweight='demi') ax.yaxis.set_label_position("right") ax.set_xlabel("Vecka", fontweight='demi') ax.set_title("Temperaturutveckling på 0,5 m - SMHIs bojar", fontweight='demi') ax.xaxis.set_major_locator(mdates.WeekdayLocator(byweekday=0)) ax.xaxis.set_major_formatter(mdates.DateFormatter('%U')) ax.set_ylim(ymin=4) def seasonality(df): end = "2020-11-28" df = df.loc[:end] sns.boxplot(data=df, x='week', y="Havstemperatur").set(ylabel= 'Temperatur [°C]', xlabel="Vecka") plt.ylim(4) def histogram(df): df["Havstemperatur"].hist(bins=11, range=(0,11)) plt.xlabel("Temperatur [°C]") def observations(df): obs = df.groupby(df.index.date).count() #print(obs["Havstemperatur"].std()) obs["Havstemperatur"].hist(bins=24, range=(0,12)) #df.groupby([df.index.date,]).count().plot(kind='bar') plt.ylabel("Frekvens") plt.xlabel("Observation/dag") def average(df): df_weekly_mean = df["Havstemperatur"].resample('W', label='left', loffset=pd.DateOffset(days=4.5)).mean() smhi_weekly_mean = smhi_mean.resample('W', label='left', loffset=pd.DateOffset(days=4.5)).mean() df_1d = df["Havstemperatur"].resample('D').mean() df_5d = df["Havstemperatur"].rolling("5d").mean() df_std = smhi_mean.resample("D").std().mean() print(df_weekly_mean) # Plot daily and weekly resampled time series together fig, ax = plt.subplots() ax.plot(df.loc[start:end, 'Havstemperatur'], marker='.', linestyle='None', alpha=0.5, label='Observation: $SST_{skin}$') ax.plot(df_5d.loc[start:end], marker='.', linestyle='-', label='5-d rullande medelvärde') #ax.plot(intdf.loc[start:end], marker='.', linestyle='-', label='Dagligt medelvärde') ax.plot(df_weekly_mean.loc[start:end], marker='D', linestyle='--', markersize=7, label='Veckovis medelvärde') ax.plot(smhi_mean.loc[start:end], label="Referensdata: 0,5 m (SMHI)") #ax.fill_between(df_std.index, df_7d - 2 * df_std, df_7d + 2 * df_std, color='b', alpha=0.2) ax.set_ylabel('Temperatur [°C]', fontweight='demi') ax.yaxis.set_label_position("right") ax.set_xlabel("Vecka", fontweight='demi') ax.xaxis.set_major_locator(mdates.WeekdayLocator(byweekday=0)) ax.xaxis.set_major_formatter(mdates.DateFormatter('%U')) ax.set_title('Havstemperaturutveckling i Östersjöområdet', fontweight='demi') ax.set_ylim(ymin=4) ax.legend() def pixel_average(df): px_std = df.std(axis=0)["Pixlar"] px_mean = df.mean(axis=0)["Pixlar"] df_px_std = df[df["Pixlar"] < (px_mean-px_std)] df.reset_index(inplace=True) df_px_std.reset_index(inplace=True) # Plot daily and weekly resampled time series together #fig, ax = plt.subplots() df.plot.scatter("Datum Tid (UTC)", "Havstemperatur", c="Pixlar", colormap="inferno", label='Observation') ax = df.plot.scatter("Datum Tid (UTC)", "Havstemperatur", color='Red', label='Observation') df_px_std.plot.scatter("Datum Tid (UTC)", "Havstemperatur", label='Observation', ax=ax) def satellites(df): N15 = df.loc[df['Satellit'] == "NOAA 15"] N18 = df.loc[df['Satellit'] == "NOAA 18"] N19 = df.loc[df['Satellit'] == "NOAA 19"] print(N15["Havstemperatur"].mean()) print(N18["Havstemperatur"].mean()) print(N19["Havstemperatur"].mean()) fig, ax = plt.subplots() ax.plot(N15.loc[start:end, "Havstemperatur"].rolling("5d").mean(), marker=".", label=("NOAA 15"), linestyle="-") ax.plot(N18.loc[start:end, "Havstemperatur"].rolling("5d").mean(), marker=".", label=("NOAA 18"), linestyle="-") ax.plot(N19.loc[start:end, "Havstemperatur"].rolling("5d").mean(), marker=".", label=("NOAA 19"), linestyle="-") #ax.plot(df.loc[start:end, "Havstemperatur"].rolling("5d").mean(), label=("Kombinerade observationer"), linestyle="-") ax.set_ylabel('Temperatur [°C]') ax.set_xlabel("Vecka") ax.xaxis.set_major_locator(mdates.WeekdayLocator(byweekday=0)) ax.xaxis.set_major_formatter(mdates.DateFormatter('%U')) ax.set_ylim(ymin=4) ax.legend() def dist(df): #sns.displot(df, x="Pixlar", binwidth=1000, kde=True) #, kind="kde" #sns.distplot(df["Pixlar"], rug=True, kde=True) #sns.displot(df, x="Pixlar", y="Havstemperatur") # Note the difference in argument order model = sm.OLS(df["Pixlar"], df["Elevation"]).fit() predictions = model.predict(df["Pixlar"]) # make the predictions by the model # Print out the statistics print(model.summary()) """ ax=sns.jointplot(x="Elevation", y='Pixlar', data=df, kind="reg") ax.ax_joint.set_ylabel("Pixlar") ax.ax_joint.set_xlabel("Elevation [°]") ax.ax_marg_x.set_xlim(0, 90) """ tex_fonts = { # Use LaTeX to write all text #"text.usetex": False, "font.family": "sans-serif", "font.sans-serif": "Avenir Next LT Pro", "font.weight": "demi", # Use 10pt font in plots, to match 10pt font in document "axes.labelsize": 12, "font.size": 12, # Make the legend/label fonts a little smaller "legend.fontsize": 10, "xtick.labelsize": 10, "ytick.labelsize": 10 } sns.set(rc={'figure.figsize':(set_size(600))}) sns.set_theme(style="whitegrid") #plt.rcParams.update(tex_fonts) plt.rcParams['font.family'] = 'sans-serif' plt.rcParams['font.sans-serif'] = 'Avenir Next LT Pro' #plt.rcParams['font.weight'] = 'demi' #plt.rcParams["figure.figsize"] = set_size(390) #seasonality(df1) #histogram(df1) average(df1) #satellites(df1) #regression(df1) #dist(df1) #pixel_average(df1) #smhi() #observations(df1) #calendar(df1) #bias(df1) #data_comp(df1) #plt.tight_layout(pad=0.0,h_pad=0.0,w_pad=0.0) plt.tight_layout() #plt.show() #plt.savefig("exported/bias.svg", format="svg") plt.savefig("exported/6.png", dpi=300)
2.46875
2
emotions.py
Omrigan/essay-writer
33
12788771
mat = [ 'сука', "блять", "пиздец", "нахуй", "<NAME>", "епта"] import random import re # strong_emotions = re.sub('[^а-я]', ' ', open('strong_emotions').read().lower()).split() def process(txt, ch): words = txt.split(" ") nxt = words[0] + ' ' i = 1 while i < len(words) - 1: if words[i - 1][-1] != '.' and random.random() < ch: nxt += random.choice(mat) + " " else: nxt += words[i] + " " i += 1 nxt += words[-1] return nxt
3.15625
3
sdkAutomator/sdkAutomator.py
chebroluharika/SDK_Automation_Generator
0
12788772
import fnmatch import executePythonResources import writeEndPointsFile import executeResources import changeLogGenerator import sys import os import shutil from datetime import datetime import json import git # if git module is not found, use 'pip install gitpython' resource_dict = { 'FC Networks': 'fc_networks', 'FCoE Networks': 'fcoe_networks', 'Ethernet Networks': 'ethernet_networks', 'Network Sets': 'network_sets', 'Connection Templates': 'connection_templates', 'Certificates Server': 'certificates_server', 'Enclosures': 'enclosures', 'Enclosure Groups': 'enclosure_groups', 'Firmware Drivers': 'firmware_drivers', 'Hypervisor Cluster Profiles': 'hypervisor_cluster_profiles', 'Hypervisor Managers': 'hypervisor_managers', 'Interconnects': 'interconnects', 'Interconnect Types': 'interconnect_types', 'Logical Enclosures': 'logical_enclosures', 'Logical Interconnects': 'logical_interconnects', 'Logical Interconnect Groups': 'logical_interconnect_groups', 'Scopes': 'scopes', 'Server Hardware': 'server_hardware', 'Server Hardware Types': 'server_hardware_types', 'Server Profiles': 'server_profiles', 'Server Profile Templates': 'server_profile_templates', 'Storage Pools': 'storage_pools', 'Storage Systems': 'storage_systems', 'Storage Volume Templates': 'storage_volume_templates', 'Storage Volume Attachments': 'storage_volume_attachments', 'Volumes': 'volumes', 'Tasks': 'tasks', 'Uplink Sets': 'uplink_sets' } class LogWriter(object): """ To show logs on console and flushing the same to logs file. """ def __init__(self, filename): self.stdout = sys.stdout self.file = filename def write(self, obj): self.file.write(obj) self.stdout.write(obj) self.file.flush() def flush(self): self.stdout.flush() self.file.flush() def clean_up_files(): print("---------Removing all log files---------------") for rootDir, subdirs, filenames in os.walk(os.getcwd()): for filename in fnmatch.filter(filenames, 'logfile*.log'): try: os.remove(os.path.join(rootDir, filename)) except OSError: print("Error while deleting file") print("---------Completed removing log files--------------") try: folder_names = ['oneview-python', 'oneview-ansible-collections','oneview-golang','oneview-terraform-provider'] for i in range(len(folder_names)): os.remove(os.getcwd() + '/' + str(i)) except Exception as e: print("Error {} occurred while deleting folder {}".format(str(e), str(i))) def createGitRepositories(selected_sdk): git_url = 'https://github.com/HewlettPackard/oneview' + str(selected_sdk) repo = git.Repo.clone_from(git_url, os.getcwd() + '/' + str(selected_sdk) + '/') return repo def createFeatureBranch(repo, branchName): remote_branches = [] num = 0 for ref in repo.git.branch('-r').split('\n'): remote_branches.append(ref.replace(" ", "")) branch_present = True if 'origin/' + branchName in remote_branches else False if branch_present: branchName = branchName + '_' + str(num) num = num + 1 createFeatureBranch(repo, branchName) else: new_branch = repo.create_head(branchName) new_branch.checkout() return def updateJsonFile(): jsonFile = open("./auto_config.json", "r") # Open the JSON file for reading data = json.load(jsonFile) # Read the JSON into the buffer jsonFile.close() # Close the JSON file ipAddressFile = open('ipaddress.txt', 'r') oneview_ip = ipAddressFile.read() ## Working with buffered content tmp = data["oneview_ip"] data["oneview_ip"] = oneview_ip ## Save our changes to JSON file jsonFile = open("auto_config.json", "w+") jsonFile.write(json.dumps(data)) jsonFile.close() if __name__ == '__main__': updateJsonFile() selected_sdk = sys.argv[1] api_version = sys.argv[2] #repo = createGitRepositories(selected_sdk) #branchName = createFeatureBranch(repo, 'feature') print("---------Started executing files---------") # LOG_FILENAME = datetime.now().strftime('logfile_%H_%M_%d_%m_%Y.log') # f = open(LOG_FILENAME, 'w') # original = sys.stdout # sys.stdout = LogWriter(f) resources_executor = executeResources.executeResources(selected_sdk, api_version) executed_files = resources_executor.execute(resource_dict) # sys.stdout = original if executed_files: print("---------Started writing to CHANGELOG.md---------") changelog_generator = changeLogGenerator.changeLogGenerator(resource_dict, api_version) changelog_generator.write_data() print("---------Completed writing to CHANGELOG.md---------") endpointsfile_writer = writeEndPointsFile.writeEndpointsFile('## HPE OneView', resource_dict, api_version) endpointsfile_writer.main() repo.git.add(A=True) repo.git.commit('-m', 'PR for reelase changes #pr', author='<EMAIL>') # to commit changes repo.git.push('--set-upstream', 'origin', branchName) repo.close() os.chdir(path) # Navigate to parent directory # Delete git cloned directory as cleanup if os.path.exists(os.getcwd() + '/' + str(selected_sdk)): shutil.rmtree(os.getcwd() + '/' + str(selected_sdk) + '/', ignore_errors=True) # clean_up_files()
1.945313
2
src/openpersonen/contrib/demo/converters/ouder.py
maykinmedia/open-personen
2
12788773
from django.conf import settings from openpersonen.features.country_code_and_omschrijving.models import ( CountryCodeAndOmschrijving, ) from openpersonen.features.gemeente_code_and_omschrijving.models import ( GemeenteCodeAndOmschrijving, ) from openpersonen.utils.helpers import is_valid_date_format def convert_ouder_instance_to_dict(ouder): ouder_dict = { "burgerservicenummer": ouder.burgerservicenummer_ouder, "geslachtsaanduiding": ouder.geslachtsaanduiding_ouder, "ouderAanduiding": ouder.geslachtsaanduiding_ouder, "datumIngangFamilierechtelijkeBetrekking": { "dag": int( ouder.datum_ingang_familierechtelijke_betrekking_ouder[ settings.OPENPERSONEN_DAY_START : settings.OPENPERSONEN_DAY_END ] if is_valid_date_format( ouder.datum_ingang_familierechtelijke_betrekking_ouder ) else 0 ), "datum": ouder.datum_ingang_familierechtelijke_betrekking_ouder, "jaar": int( ouder.datum_ingang_familierechtelijke_betrekking_ouder[ settings.OPENPERSONEN_YEAR_START : settings.OPENPERSONEN_YEAR_END ] if is_valid_date_format( ouder.datum_ingang_familierechtelijke_betrekking_ouder ) else 0 ), "maand": int( ouder.datum_ingang_familierechtelijke_betrekking_ouder[ settings.OPENPERSONEN_MONTH_START : settings.OPENPERSONEN_MONTH_END ] if is_valid_date_format( ouder.datum_ingang_familierechtelijke_betrekking_ouder ) else 0 ), }, "naam": { "geslachtsnaam": ouder.geslachtsnaam_ouder, "voorletters": "string", "voornamen": ouder.voornamen_ouder, "voorvoegsel": ouder.voorvoegsel_geslachtsnaam_ouder, "inOnderzoek": { "geslachtsnaam": bool(ouder.geslachtsnaam_ouder), "voornamen": bool(ouder.voornamen_ouder), "voorvoegsel": bool(ouder.voorvoegsel_geslachtsnaam_ouder), "datumIngangOnderzoek": { "dag": 0, "datum": "string", "jaar": 0, "maand": 0, }, }, }, "inOnderzoek": { "burgerservicenummer": bool(ouder.burgerservicenummer_ouder), "datumIngangFamilierechtelijkeBetrekking": bool( ouder.datum_ingang_familierechtelijke_betrekking_ouder ), "geslachtsaanduiding": bool(ouder.geslachtsaanduiding_ouder), "datumIngangOnderzoek": { "dag": int( ouder.datum_ingang_onderzoek[ settings.OPENPERSONEN_DAY_START : settings.OPENPERSONEN_DAY_END ] if is_valid_date_format(ouder.datum_ingang_onderzoek) else 0 ), "datum": ouder.datum_ingang_onderzoek, "jaar": int( ouder.datum_ingang_onderzoek[ settings.OPENPERSONEN_YEAR_START : settings.OPENPERSONEN_YEAR_END ] if is_valid_date_format(ouder.datum_ingang_onderzoek) else 0 ), "maand": int( ouder.datum_ingang_onderzoek[ settings.OPENPERSONEN_MONTH_START : settings.OPENPERSONEN_MONTH_END ] if is_valid_date_format(ouder.datum_ingang_onderzoek) else 0 ), }, }, "geboorte": { "datum": { "dag": int( ouder.geboortedatum_ouder[ settings.OPENPERSONEN_DAY_START : settings.OPENPERSONEN_DAY_END ] ) if is_valid_date_format(ouder.geboortedatum_ouder) else 0, "datum": ouder.geboortedatum_ouder, "jaar": int( ouder.geboortedatum_ouder[ settings.OPENPERSONEN_YEAR_START : settings.OPENPERSONEN_YEAR_END ] ) if is_valid_date_format(ouder.geboortedatum_ouder) else 0, "maand": int( ouder.geboortedatum_ouder[ settings.OPENPERSONEN_MONTH_START : settings.OPENPERSONEN_MONTH_END ] ) if is_valid_date_format(ouder.geboortedatum_ouder) else 0, }, "land": { "code": ouder.geboorteland_ouder, "omschrijving": CountryCodeAndOmschrijving.get_omschrijving_from_code( ouder.geboorteland_ouder ), }, "plaats": { "code": ouder.geboorteplaats_ouder, "omschrijving": GemeenteCodeAndOmschrijving.get_omschrijving_from_code( ouder.geboorteplaats_ouder ), }, "inOnderzoek": { "datum": bool(ouder.geboortedatum_ouder), "land": bool(ouder.geboorteland_ouder), "plaats": bool(ouder.geboorteplaats_ouder), "datumIngangOnderzoek": { "dag": 0, "datum": "string", "jaar": 0, "maand": 0, }, }, }, "geheimhoudingPersoonsgegevens": True, } return ouder_dict
2.078125
2
app/forms.py
samkreter/TigerBuilds-Website
0
12788774
from flask.ext.wtf import Form from wtforms import BooleanField, TextField, PasswordField, validators from wtforms.validators import DataRequired from flask_wtf.file import FileField class LoginForm(Form): first_name = TextField('first_name', validators=[DataRequired()]) last_name = TextField('first_name', validators=[DataRequired()]) email = TextField('Email Address', [validators.required(),validators.Length(min=6, max=35)]) resume = FileField() remember_me = BooleanField('remember_me', default=False)
2.765625
3
vhoops/modules/on_call/ui/routes.py
yigitbasalma/vhoops
4
12788775
#!/usr/bin/python # -*- coding: utf-8 -*- from flask import Blueprint, render_template from flask_login import login_required from vhoops.modules.teams.api.controllers import get_all_teams_func from vhoops.modules.on_call.forms.new_on_call import NewOnCallSchedule on_call_router = Blueprint("on_call_router", __name__) @on_call_router.route("/on-call", methods=["GET"]) @login_required def on_call_page(): # Form config teams = get_all_teams_func(as_object=True) form = NewOnCallSchedule() form.user.choices = [ (member.id, member.username) for team in teams["data"] for member in team.members ] return render_template( "on-call/on-call.html", teams=teams["data"], form=form )
2.203125
2
codes/Arms.py
imadaouali/bootstrapping-multi-armed-bandits
0
12788776
<reponame>imadaouali/bootstrapping-multi-armed-bandits """different classes of arms, all of them have a sample() method which produce rewards""" import numpy as np from random import random from math import sqrt,log,exp class Bernoulli: def __init__(self,p): # create a Bernoulli arm with mean p self.mean = p self.variance = p*(1-p) def sample(self): # generate a reward from a Bernoulli arm return float(random()<self.mean) class Gaussian: def __init__(self,mu,var=1): # create a Gaussian arm with specified mean and variance self.mean = mu self.variance = var def sample(self): # generate a reward from a Gaussian arm return self.mean + sqrt(self.variance)*np.random.normal() class Exponential: def __init__(self,p): # create an Exponential arm with parameter p self.mean = 1/p self.variance = 1/(p*p) def sample(self): # generate a reward from an Exponential arm return -(self.mean)*log(random()) class TruncatedExponential: def __init__(self,p,trunc): # create a truncated Exponential arm with parameter p self.p = p self.trunc = trunc self.mean = (1.-exp(-p * trunc)) / p self.variance=0 def sample(self): # generate a reward from an Exponential arm return min(-(1/self.p)*log(random()),self.trunc)
3.46875
3
categorical/plot_sweep.py
remilepriol/causal-adaptation-speed
15
12788777
import os import pickle from collections import defaultdict import matplotlib import matplotlib.pyplot as plt import numpy as np import scipy.stats def add_capitals(dico): return {**dico, **{key[0].capitalize() + key[1:]: item for key, item in dico.items()}} COLORS = { 'causal': 'blue', 'anti': 'red', 'joint': 'green', 'causal_average': 'darkblue', 'anti_average': 'darkred', 'joint_average': 'darkgreen', 'MAP_uniform': 'yellow', 'MAP_source': 'gold', # guess 'CausalGuessX': 'skyblue', 'CausalGuessY': 'darkcyan', 'AntiGuessX': 'salmon', 'AntiGuessY': 'chocolate', } MARKERS = {key: 'o' for key in COLORS} MARKERS['causal'] = '^' MARKERS['anti'] = 'v' COLORS = add_capitals(COLORS) MARKERS = add_capitals(MARKERS) def value_at_step(trajectory, nsteps=1000): """Return the KL and the integral KL up to nsteps.""" steps = trajectory['steps'] index = np.searchsorted(steps, nsteps) - 1 ans = {} # ans['end_step'] = steps[index] for key, item in trajectory.items(): if key.startswith('kl_'): ans[key[3:]] = item[index].mean() # ans['endkl_' + key[3:]] = item[index].mean() # ans['intkl_' + key[3:]] = item[:index].mean() return ans def get_best(results, nsteps): """Store per model each parameter and kl values then for each model return the argmax parameters and curves for kl and integral kl """ by_model = {} # dictionary where each key is a model, # and each value is a list of this model's hyperparameter # and outcome at step nsteps for exp in results: trajectory = exp['trajectory'] for model, metric in value_at_step(trajectory, nsteps).items(): if model not in by_model: by_model[model] = [] toadd = { 'hyperparameters': exp['hyperparameters'], **exp['hyperparameters'], 'value': metric, 'kl': trajectory['kl_' + model], 'steps': trajectory['steps'] } if 'scoredist_' + model in trajectory: toadd['scoredist'] = trajectory['scoredist_' + model] by_model[model] += [toadd] # select only the best hyperparameters for this model. for model, metrics in by_model.items(): dalist = sorted(metrics, key=lambda x: x['value']) # Ensure that the optimal configuration does not diverge as optimization goes on. for duh in dalist: if duh['kl'][0].mean() * 2 > duh['kl'][-1].mean(): break by_model[model] = duh # print the outcome for model, item in by_model.items(): if 'MAP' in model: print(model, ('\t n0={n0:.0f},' '\t kl={value:.3f}').format(**item)) else: print(model, ('\t alpha={scheduler_exponent},' '\t lr={lr:.1e},' '\t kl={value:.3f}').format(**item)) return by_model def curve_plot(bestof, nsteps, figsize, logscale=False, endstep=400, confidence=(5, 95)): """Draw mean trajectory plot with percentiles""" fig, ax = plt.subplots(nrows=1, ncols=1, figsize=figsize) for model, item in sorted(bestof.items()): xx = item['steps'] values = item['kl'] # truncate plot for k-invariance end_id = np.searchsorted(xx, endstep) + 1 xx = xx[:end_id] values = values[:end_id] # plot mean and percentile statistics ax.plot(xx, values.mean(axis=1), label=model, marker=MARKERS[model], markevery=len(xx) // 6, markeredgewidth=0, color=COLORS[model], alpha=.9) ax.fill_between( xx, np.percentile(values, confidence[0], axis=1), np.percentile(values, confidence[1], axis=1), alpha=.4, color=COLORS[model] ) ax.axvline(nsteps, linestyle='--', color='black') ax.grid(True) if logscale: ax.set_yscale('log') ax.set_ylabel(r'$\mathrm{KL}(\mathbf{p}^*, \mathbf{p}^{(t)})$') ax.set_xlabel('number of samples t') ax.legend() return fig, ax def scatter_plot(bestof, nsteps, figsize, logscale=False): fig, ax = plt.subplots(nrows=1, ncols=1, figsize=figsize) alldist = [] allkl = [] for model, item in sorted(bestof.items()): if 'scoredist' not in item: continue index = min(np.searchsorted(item['steps'], nsteps), len(item['steps']) - 1) initial_distances = item['scoredist'][0] end_kl = item['kl'][index] ax.scatter( initial_distances, end_kl, alpha=.3, color=COLORS[model], marker=MARKERS[model], linewidth=0, label=model if False else None ) alldist += list(initial_distances) allkl += list(end_kl) # linear regression slope, intercept, rval, pval, _ = scipy.stats.linregress(alldist, allkl) x_vals = np.array(ax.get_xlim()) y_vals = intercept + slope * x_vals ax.plot( x_vals, y_vals, '--', color='black', alpha=.8, label=f'y=ax+b, r2={rval ** 2:.2f}' f',\na={slope:.1e}, b={intercept:.2f}' ) # look ax.legend() ax.grid(True) if logscale: ax.set_yscale('log') ax.set_xscale('log') ax.set_xlim(min(alldist), max(alldist)) else: ax.ticklabel_format(axis='both', style='sci', scilimits=(0, 0), useMathText=True) ax.set_ylabel(r'$\mathrm{KL}(\mathbf{p}^*, \mathbf{p}^{(t)}); T=$' + str(nsteps)) ax.set_xlabel(r'$||\theta^{(0)} - \theta^* ||^2$') return fig, ax def two_plots(results, nsteps, plotname, dirname, verbose=False, figsize=(6, 3)): print(dirname, plotname) bestof = get_best(results, nsteps) # remove the models I don't want to compare # eg remove SGD, MAP. Keep ASGD and rename them to remove average. selected = { key[0].capitalize() + key[1:-len('_average')].replace('A', 'X').replace('B', 'Y'): item for key, item in bestof.items() if key.endswith('_average')} for key in ['MAP_uniform', 'MAP_source']: # selected[key] = bestof[key] pass if dirname.startswith('guess'): selected.pop('Joint', None) curves, ax1 = curve_plot(selected, nsteps, figsize, logscale=False) # initstring = 'denseinit' if results[0]["is_init_dense"] else 'sparseinit' # curves.suptitle(f'Average KL tuned for {nsteps} samples with {confidence} percentiles, ' # f'{initstring}, k={results[0]["k"]}') scatter, ax2 = scatter_plot(selected, nsteps, figsize, logscale=(dirname == 'guess_sparseinit')) if verbose: for ax in [ax1, ax2]: info = str(next(iter(selected.values()))['hyperparameters']) txt = ax.text(0.5, 1, info, ha='center', va='top', wrap=True, transform=ax.transAxes, # bbox=dict(boxstyle='square') ) txt._get_wrap_line_width = lambda: 400. # wrap to 600 screen pixels # small adjustments for intervention guessing if dirname.startswith('guess'): curves.axes[0].set_ylim(0, 1.5) for fig in [curves, scatter]: fig.axes[0].set_xlabel('') fig.axes[0].set_ylabel('') for style, fig in {'curves': curves, 'scatter': scatter}.items(): for figpath in [ os.path.join('plots', dirname, f'{style}_{plotname}.pdf')]: print("Saving ", figpath) os.makedirs(os.path.dirname(figpath), exist_ok=True) # os.path.join('plots/sweep/png', f'{style}_{plotname}.png')]: fig.savefig(figpath, bbox_inches='tight') plt.close(curves) plt.close(scatter) print() def plot_marginal_likelihoods(results, intervention, k, dirname): exp = results[0] values = {} for whom in ['A', 'B']: values[whom] = exp['loglikelihood' + whom][:100].cumsum(0) xx = np.arange(1, values[whom].shape[0] + 1) values[whom] /= xx[:, np.newaxis] if intervention == 'cause': right, wrong = 'A', 'B' else: right, wrong = 'B', 'A' plt.plot(values[wrong] - values[right], alpha=.2) plt.hlines(0, 0, values['B'].shape[0]) plt.grid() plt.ylim(-1, 1) figpath = os.path.join('plots', dirname, 'guessing', f'guess_{intervention}_k={k}.pdf') os.makedirs(os.path.dirname(figpath), exist_ok=True) plt.savefig(figpath, bbox_inches='tight') plt.close() def merge_results(results1, results2, bs=5): """Combine results from intervention on cause and effect. Also report statistics about pooled results. Pooled records the average over 10 cause and 10 effect interventions the goal is to have tighter percentile curves which are representative of the algorithm's performance """ combined = [] pooled = [] for e1, e2 in zip(results1, results2): h1, h2 = e1['hyperparameters'], e2['hyperparameters'] assert h1['lr'] == h2['lr'] t1, t2 = e1['trajectory'], e2['trajectory'] combined_trajs = {'steps': t1['steps']} pooled_trajs = combined_trajs.copy() for key in t1.keys(): if key.startswith(('scoredist', 'kl')): combined_trajs[key] = np.concatenate((t1[key], t2[key]), axis=1) meantraj = (t1[key] + t2[key]) / 2 pooled_trajs[key] = np.array([ meantraj[:, bs * i:bs * (i + 1)].mean(axis=1) for i in range(meantraj.shape[1] // bs) ]).T combined += [{'hyperparameters': h1, 'trajectory': combined_trajs}] pooled += [{'hyperparameters': h2, 'trajectory': pooled_trajs}] return combined, pooled def all_plot(guess=False, dense=True, input_dir='categorical_results', output_dir='camera_ready', figsize=(3.6, 2.2)): basefile = '_'.join(['guess' if guess else 'sweep2', 'denseinit' if dense else 'sparseinit']) print(basefile, '\n---------------------') prior_string = 'dense' if dense else 'sparse' for k in [20]: # [10, 20, 50]: # Optimize hyperparameters for nsteps such that curves are k-invariant nsteps = k ** 2 // 4 allresults = defaultdict(list) for intervention in ['cause', 'effect']: # 'singlecond', 'gmechanism', 'independent', 'geometric', 'weightedgeo']: plotname = f'{prior_string}_{intervention}_k={k}' file = f'{basefile}_{intervention}_k={k}.pkl' filepath = os.path.join(input_dir, file) print(os.path.abspath(filepath)) if os.path.isfile(filepath): with open(filepath, 'rb') as fin: results = pickle.load(fin) print(1) two_plots(results, nsteps, plotname=plotname, dirname=output_dir, figsize=figsize) allresults[intervention] = results # if guess: # plot_marginal_likelihoods(results, intervention, k, basefile) # if not guess and 'cause' in allresults and 'effect' in allresults: # combined, pooled = merge_results(allresults['cause'], allresults['effect']) # if len(combined) > 0: # for key, item in {'combined': combined, 'pooled': pooled}.items(): # two_plots(item, nsteps, # plotname=f'{prior_string}_{key}_k={k}', # dirname=output_dir, # figsize=figsize) if __name__ == '__main__': np.set_printoptions(precision=2) matplotlib.use('pgf') matplotlib.rcParams['mathtext.fontset'] = 'cm' matplotlib.rcParams['pdf.fonttype'] = 42 # all_plot(guess=True, dense=True) # all_plot(guess=True, dense=False) all_plot(guess=False, dense=True) all_plot(guess=False, dense=False)
2.640625
3
tests/v1tests/test_offices_view.py
Davidodari/POLITICO-API
1
12788778
from tests.v1tests import BaseTestCase import json class OfficeEndpointsTestCase(BaseTestCase): def test_create_office(self): """Tests valid data POST Http method request on /offices endpoint""" # Post, uses office specification model response = self.client.post('api/v1/offices', data=json.dumps(self.office)) # Data section returned as per response specification expected_response_json = { 'data': [{ 'id': 1, 'type': 'Senior', 'name': 'Permanent Secretary' }], 'status': 201 } self.assertEqual(response.status_code, 201, "Should Return a 201 HTTP Status Code Response:Created") self.assertEqual(expected_response_json, response.json) def test_create_office_invalid_forbidden(self): """Tests invalid data on POST method request on /offices endpoint""" response = self.client.post('api/v1/offices', json={ 'type': 'n', 'name': 'p' }) self.assertEqual(response.status_code, 400, "Should Return a 400 HTTP Status Code Response:Bad Request") # Should return error message self.assertIn("Check Input Values", response.json['error']) def test_create_office_bad_request(self): """Tests malformed POST Http method request on /offices endpoint""" response = self.client.post('api/v1/offices', json={ # Missing type key 'name': 'Permanent Secretary' }) self.assertEqual(response.status_code, 400, "Should Return a 400 HTTP Status Code Response:Bad Request") # Should return error message self.assertIn("Missing Key value", response.json['error']) def test_view_all_offices(self): """Tests GET Http method request on /offices endpoint""" # Post, create an office first self.client.post('api/v1/offices', data=json.dumps(self.office)) # Retrieve the office response = self.client.get('api/v1/offices') self.assertEqual(response.status_code, 200, "Should Return a 200 HTTP Status Code Response:Success") expected_response_json = { "data": [{ "id": 1, 'type': 'Senior', 'name': '<NAME>' }], "status": 200 } # Converts to string self.assertEqual(response.json, expected_response_json) def test_view_all_offices_bad_request(self): """Tests malformed GET Http method request on /office endpoint""" response = self.client.get('api/v1/ofices') self.assertEqual(response.status_code, 404, "Should Return a 404 HTTP Status Code Response:Resource Not Found") # Should return error message self.assertEqual(response.json, self.error_default_not_found) def test_view_specific_office(self): """Tests GET Http method request on /office/{:id} endpoint""" # Post, add an office self.client.post('api/v1/offices', data=json.dumps(self.office)) # Get data for specific office response = self.client.get('api/v1/offices/1') expected_response = { "id": 1, "name": "<NAME>", "type": "Senior" } self.assertEqual(response.status_code, 200, "Should Return a 200 HTTP Status Code:Success") # Returns Dict as string and compares if its in response self.assertEqual(response.json['data'][0], expected_response) def test_view_specific_office_invalid_id(self): """Tests malformed GET Http method request on /office/{:id} endpoint""" response = self.client.get('api/v1/offices/{}'.format(4578)) self.assertEqual(response.status_code, 404, "Should Return a 404 HTTP Status Code Response:Bad Request") # Should return error message self.assertEqual(response.json['error'], "Invalid Id Not Found", "Should return resource not found response") def test_view_specific_office_not_found(self): """Tests malformed GET Http method request on /office/{:id} endpoint""" response = self.client.get('api/v1/offies/{}'.format(0)) self.assertEqual(response.status_code, 404, "Should Return a 404 HTTP Status Code Response:Not Found") # Should return error message self.assertEqual(response.json, self.error_default_not_found, "Should return resource not found response") def test_view_specific_office_invalid_id_value_error(self): """Tests valid request but invalid data on DELETE request on /parties/{:id}/name endpoint""" self.client.post('api/v1/offices', data=json.dumps(self.office)) response = self.client.get('api/v1/offices/e') self.assertEqual(response.status_code, 400, "Should Return a 404 HTTP Status Code Response:Not Found") # Should return error message self.assertEqual(response.json['error'], 'Invalid Id', 'Should return not found response') def test_edit_government_office(self): """Tests PATCH Http method request on /offices/{:id}/name endpoint""" # Save Post First self.client.post('api/v1/offices', data=json.dumps(self.office)) edit_request_json = { "name": "<NAME>" } # Update Name response = self.client.patch('api/v1/offices/{}/name'.format(1), data=json.dumps(edit_request_json)) self.assertEqual(response.status_code, 200, "Should Return a 200 HTTP Status Code Response:Updated") self.assertEqual(edit_request_json.get('name'), response.json[0]['data'][0]['name']) def test_edit_office_invalid_id(self): """Tests invalid id on PATCH request on /offices/{:id}/name endpoint""" edit_request_json = { "name": "<NAME>" } response = self.client.patch('api/v1/offices/0/name', data=json.dumps(edit_request_json)) self.assertEqual(response.status_code, 404, "Should Return a 404 HTTP Status Code Response:Not Found") # Should return error message self.assertEqual(response.json['error'], 'Invalid Id Not Found', 'Should return invalid id response') def test_edit_offices_not_found(self): """Tests valid but non existent id on PATCH request on /parties/{:id}/name endpoint""" edit_request_json = { "name": "Secretary" } response = self.client.patch('api/v1/offices/3/name', data=json.dumps(edit_request_json)) self.assertEqual(response.status_code, 404, "Should Return a 404 HTTP Status Code Response:Not Found") # Should return error message self.assertEqual(response.json['error'], 'Invalid Id Not Found', 'Should return not found response') def test_edit_office_invalid_data(self): """Tests valid request but invalid data on PATCH request on /offices/{:id}/name endpoint""" self.client.post('api/v1/offices', data=json.dumps(self.office)) edit_request_json = { "name": "D" } response = self.client.patch('api/v1/offices/1/name', data=json.dumps(edit_request_json)) self.assertEqual(response.status_code, 400, "Should Return a 404 HTTP Status Code Response:Not Found") # Should return error message self.assertEqual(response.json['error'], 'Incorrect Data Received,Bad request', 'Should return not found response') def test_edit_office_invalid_id_value_error(self): """Tests valid request but invalid data on PATCH request on /offices/{:id}/name endpoint""" self.client.post('api/v1/offices', data=json.dumps(self.office)) edit_request_json = { "name": "<NAME>" } response = self.client.patch('api/v1/offices/e/name', data=json.dumps(edit_request_json)) self.assertEqual(response.status_code, 400, "Should Return a 404 HTTP Status Code Response:Not Found") # Should return error message self.assertEqual(response.json['error'], 'Invalid Id', 'Should return not found response') def test_delete_office(self): """Tests DELETE Http method request on /offices/{:id} endpoint""" # Save Post First self.client.post('api/v1/offices', data=json.dumps(self.office)) # Delete Party response = self.client.delete('api/v1/offices/{0}'.format(1)) self.assertEqual(response.status_code, 200, "Should Return a 200 HTTP Status Code Response:Deleted") self.assertEqual("Deleted Successfully", response.json['message']) def test_delete_office_not_found(self): """"Tests malformed DELETE Http method request on /offices/{:id} endpoint""" # Save Post First response = self.client.delete('api/v1/offices/{0}'.format(-1)) self.assertEqual(response.status_code, 404, "Should Return a 404 HTTP Status Code Response:Not Found") # Should return error message self.assertEqual(response.json['error'], 'Invalid Id Not Found', "Should return resource not found response") def test_delete_office_invalid_id_value_error(self): """Tests valid request but invalid data on DELETE request on /offices/{:id}/name endpoint""" self.client.post('api/v1/offices', data=json.dumps(self.office)) response = self.client.delete('api/v1/offices/e') self.assertEqual(response.status_code, 400, "Should Return a 404 HTTP Status Code Response:Not Found") # Should return error message self.assertEqual(response.json['error'], 'Invalid Id') def test_no_duplication(self): # Create self.client.post('api/v1/offices', data=json.dumps(self.office)) response = self.client.post('api/v1/offices', data=json.dumps(self.office)) self.assertEqual(response.status_code, 409, "Should Create Party") self.assertEqual(response.json['error'], "Office Already Exists", "Should Create Non Duplicate Ids")
2.875
3
validate_signature/serializers.py
Arquitectura-de-Software-UFPS-2022-I/-validate-signature-api-documentation-
0
12788779
from rest_framework import serializers class ValidateSerializer(serializers.Serializer): class_label = serializers.IntegerField() confidence = serializers.FloatField()
1.890625
2
my_phonolammps/_lammps.py
araghukas/my-phonolammps
1
12788780
<reponame>araghukas/my-phonolammps<filename>my_phonolammps/_lammps.py """Here the original lammps class is wrapped to allow specifying the `modpath`""" from lammps import * from lammps import lammps class MyLammps(lammps): """new version of the lammps class""" # path to the directory containing liblammps.so or liblammps.dylib MODPATH: str = None def __init__(self, name="", cmdargs=None, ptr=None, comm=None): try: from mpi4py import MPI from mpi4py import __version__ as mpi4py_version if mpi4py_version.split('.')[0] in ['2', '3']: self.has_mpi4py = True except ModuleNotFoundError: self.has_mpi4py = False if self.MODPATH is None: # instantiate the original class as usual lammps.__init__(self, name, cmdargs, ptr, comm) else: # instantiate with a specific `modpath` modpath = os.path.abspath(self.MODPATH) try: self._create_instance(modpath, name, cmdargs, ptr, comm) except OSError: raise FileNotFoundError( f"LAMMPS shared library not found in directory {modpath}" ) def _create_instance(self, modpath: str, name="", cmdargs=None, ptr=None, comm=None) -> None: """ Run the original instance creation code, except `modpath` is now arbitrary. Specifying `modpath` avoids the issue of not finding the LAMMPS shared library, even though it may exist elsewhere. :param modpath: path to the directory containing "liblammps.so" or "liblammps.dylib" """ self.comm = comm self.opened = 0 # determine module location self.lib = None self.lmp = None # if a pointer to a LAMMPS object is handed in, # all symbols should already be available try: if ptr: self.lib = CDLL("", RTLD_GLOBAL) except: self.lib = None # load liblammps.so unless name is given # if name = "g++", load liblammps_g++.so # try loading the LAMMPS shared object from the location # of my_lammps.py with an absolute path, # so that LD_LIBRARY_PATH does not need to be set for regular install # fall back to loading with a relative path, # typically requires LD_LIBRARY_PATH to be set appropriately if any([f.startswith('liblammps') and f.endswith('.dylib') for f in os.listdir(modpath)]): lib_ext = ".dylib" else: lib_ext = ".so" if not self.lib: try: if not name: self.lib = CDLL(join(modpath, "liblammps" + lib_ext), RTLD_GLOBAL) else: self.lib = CDLL(join(modpath, "liblammps_%s" % name + lib_ext), RTLD_GLOBAL) except: if not name: self.lib = CDLL("liblammps" + lib_ext, RTLD_GLOBAL) else: self.lib = CDLL("liblammps_%s" % name + lib_ext, RTLD_GLOBAL) # define ctypes API for each library method # NOTE: should add one of these for each lib function self.lib.lammps_extract_box.argtypes = \ [c_void_p, POINTER(c_double), POINTER(c_double), POINTER(c_double), POINTER(c_double), POINTER(c_double), POINTER(c_int), POINTER(c_int)] self.lib.lammps_extract_box.restype = None self.lib.lammps_reset_box.argtypes = \ [c_void_p, POINTER(c_double), POINTER(c_double), c_double, c_double, c_double] self.lib.lammps_reset_box.restype = None self.lib.lammps_gather_atoms.argtypes = \ [c_void_p, c_char_p, c_int, c_int, c_void_p] self.lib.lammps_gather_atoms.restype = None self.lib.lammps_gather_atoms_concat.argtypes = \ [c_void_p, c_char_p, c_int, c_int, c_void_p] self.lib.lammps_gather_atoms_concat.restype = None self.lib.lammps_gather_atoms_subset.argtypes = \ [c_void_p, c_char_p, c_int, c_int, c_int, POINTER(c_int), c_void_p] self.lib.lammps_gather_atoms_subset.restype = None self.lib.lammps_scatter_atoms.argtypes = \ [c_void_p, c_char_p, c_int, c_int, c_void_p] self.lib.lammps_scatter_atoms.restype = None self.lib.lammps_scatter_atoms_subset.argtypes = \ [c_void_p, c_char_p, c_int, c_int, c_int, POINTER(c_int), c_void_p] self.lib.lammps_scatter_atoms_subset.restype = None self.lib.lammps_find_pair_neighlist.argtypes = [c_void_p, c_char_p, c_int, c_int, c_int] self.lib.lammps_find_pair_neighlist.restype = c_int self.lib.lammps_find_fix_neighlist.argtypes = [c_void_p, c_char_p, c_int] self.lib.lammps_find_fix_neighlist.restype = c_int self.lib.lammps_find_compute_neighlist.argtypes = [c_void_p, c_char_p, c_int] self.lib.lammps_find_compute_neighlist.restype = c_int self.lib.lammps_neighlist_num_elements.argtypes = [c_void_p, c_int] self.lib.lammps_neighlist_num_elements.restype = c_int self.lib.lammps_neighlist_element_neighbors.argtypes = [c_void_p, c_int, c_int, POINTER(c_int), POINTER(c_int), POINTER(POINTER(c_int))] self.lib.lammps_neighlist_element_neighbors.restype = None # if no ptr provided, create an instance of LAMMPS # don't know how to pass an MPI communicator from PyPar # but we can pass an MPI communicator from mpi4py v2.0.0 and later # no_mpi call lets LAMMPS use MPI_COMM_WORLD # cargs = array of C strings from args # if ptr, then are embedding Python in LAMMPS input script # ptr is the desired instance of LAMMPS # just convert it to ctypes ptr and store in self.lmp if not ptr: # with mpi4py v2, can pass MPI communicator to LAMMPS # need to adjust for type of MPI communicator object # allow for int (like MPICH) or void* (like OpenMPI) if comm: if not self.has_mpi4py: raise Exception('Python mpi4py version is not 2 or 3') if MyLammps.MPI._sizeof(MyLammps.MPI.Comm) == sizeof(c_int): MPI_Comm = c_int else: MPI_Comm = c_void_p narg = 0 cargs = 0 if cmdargs: cmdargs.insert(0, "my_lammps.py") narg = len(cmdargs) for i in range(narg): if type(cmdargs[i]) is str: cmdargs[i] = cmdargs[i].encode() cargs = (c_char_p * narg)(*cmdargs) self.lib.lammps_open.argtypes = [c_int, c_char_p * narg, \ MPI_Comm, c_void_p()] else: self.lib.lammps_open.argtypes = [c_int, c_int, \ MPI_Comm, c_void_p()] self.lib.lammps_open.restype = None self.opened = 1 self.lmp = c_void_p() comm_ptr = MyLammps.MPI._addressof(comm) comm_val = MPI_Comm.from_address(comm_ptr) self.lib.lammps_open(narg, cargs, comm_val, byref(self.lmp)) else: if self.has_mpi4py: from mpi4py import MPI self.comm = MPI.COMM_WORLD self.opened = 1 if cmdargs: cmdargs.insert(0, "my_lammps.py") narg = len(cmdargs) for i in range(narg): if type(cmdargs[i]) is str: cmdargs[i] = cmdargs[i].encode() cargs = (c_char_p * narg)(*cmdargs) self.lmp = c_void_p() self.lib.lammps_open_no_mpi(narg, cargs, byref(self.lmp)) else: self.lmp = c_void_p() self.lib.lammps_open_no_mpi(0, None, byref(self.lmp)) # could use just this if LAMMPS lib interface supported it # self.lmp = self.lib.lammps_open_no_mpi(0,None) else: # magic to convert ptr to ctypes ptr if sys.version_info >= (3, 0): # Python 3 (uses PyCapsule API) pythonapi.PyCapsule_GetPointer.restype = c_void_p pythonapi.PyCapsule_GetPointer.argtypes = [py_object, c_char_p] self.lmp = c_void_p(pythonapi.PyCapsule_GetPointer(ptr, None)) else: # Python 2 (uses PyCObject API) pythonapi.PyCObject_AsVoidPtr.restype = c_void_p pythonapi.PyCObject_AsVoidPtr.argtypes = [py_object] self.lmp = c_void_p(pythonapi.PyCObject_AsVoidPtr(ptr)) # optional numpy support (lazy loading) self._numpy = None # set default types self.c_bigint = get_ctypes_int(self.extract_setting("bigint")) self.c_tagint = get_ctypes_int(self.extract_setting("tagint")) self.c_imageint = get_ctypes_int(self.extract_setting("imageint")) self._installed_packages = None # add way to insert Python callback for fix external self.callback = {} self.FIX_EXTERNAL_CALLBACK_FUNC = CFUNCTYPE(None, py_object, self.c_bigint, c_int, POINTER(self.c_tagint), POINTER(POINTER(c_double)), POINTER(POINTER(c_double))) self.lib.lammps_set_fix_external_callback.argtypes = [c_void_p, c_char_p, self.FIX_EXTERNAL_CALLBACK_FUNC, py_object] self.lib.lammps_set_fix_external_callback.restype = None
2.4375
2
jabledl/downloader.py
Yooootsuba/jabledl
10
12788781
<reponame>Yooootsuba/jabledl import time import requests import threading class Downloader: def __init__(self, segments, request_headers, requests_callback): self.threads = [] self.threads_count = 0 self.threads_limit = 50 self.segments = segments self.segments_count = len(segments) self.requests_headers = request_headers self.requests_callback = requests_callback def wait_threads(self): for thread in self.threads: thread.join() self.threads_count = 0 self.threads.clear() def save(self, filename, response): with open(filename, 'wb') as f: f.write(response.content) def thread_job(self, filename, segment): try: response = requests.get(segment, headers = self.requests_headers) if response.status_code != 200: raise Exception except Exception: time.sleep(5) self.thread_job(filename, segment) else: self.save(filename, response) self.requests_callback() def download(self): for i in range(self.segments_count): if self.threads_count > self.threads_limit: self.wait_threads() self.threads.append(threading.Thread(target = self.thread_job, args = (str(i) + '.ts', self.segments[i]))) self.threads[-1].start() self.threads_count += 1 self.wait_threads()
3.15625
3
02 - Curso Em Video/Aula 15/E - 069.py
GabrielTrentino/Python_Basico
0
12788782
maior18 = 0 homens = 0 mulheres = 0 while True: idade = int(input('Digite a idade: ')) sexo = str(input('Qual o sexo? [H/M] ')).strip().upper()[0] if idade > 18: maior18 += 1 if sexo == 'H': homens += 1 if sexo == 'M' and idade < 20: mulheres += 1 opcao = str(input('Deseja Continuar? [S/N] ')).strip().upper()[0] if opcao == 'N': break print('A) {} pessoas acima de 18 anos'.format(maior18)) print('B) {} homens cadastrados'.format(homens)) print('C) {} mulheres com menos de 20 anos'.format(mulheres))
3.734375
4
src/inmanta/compiler/help/explainer.py
inmanta/inmanta-core
6
12788783
""" Copyright 2018 Inmanta Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 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. Contact: <EMAIL> """ import os import re from abc import ABC, abstractmethod from typing import Generic, List, Mapping, Optional, Sequence, Set, Type, TypeVar from jinja2 import Environment, PackageLoader from inmanta.ast import CompilerException, ModifiedAfterFreezeException from inmanta.ast.statements import AssignStatement from inmanta.ast.statements.generator import Constructor from inmanta.execute.runtime import OptionVariable from inmanta.module import ModuleV2InV1PathException def bold(content: Optional[str] = None) -> str: if content is None: return "\033[1m" return "\033[1m{0}\033[0m".format(content) def underline(content: Optional[str] = None) -> str: if content is None: return "\033[4m" return "\033[4m{0}\033[0m".format(content) def noformat(content: Optional[str] = None) -> str: return "\033[0m" CUSTOM_FILTERS = {"bold": bold, "underline": underline, "noformat": noformat} class ExplainerABC(ABC): """ Abstract base class for explainers. This class is purposely kept non-Generic to present a public interface that is invariant of the compiler exception type. This allows correct typing of sequences of explainers. """ @abstractmethod def explain(self, problem: CompilerException) -> List[str]: ... Explainable = TypeVar("Explainable", bound=CompilerException) class Explainer(Generic[Explainable], ExplainerABC, ABC): """ Abstract explainer, Generic in the compiler exception subtype to allow correct typing of the exception for subtype-specific explanation logic. Concrete subclasses must not be generic in the exception type because this would break explainable checking. """ explainable_type: Type[Explainable] def explain(self, problem: CompilerException) -> List[str]: """ Returns a list of explanations for this exception. If neither the exception or any of its causes (recursively) is explainable by this explainer, returns an empty list. """ allcauses: Set[CompilerException] = set() work: List[CompilerException] = [problem] while work: w = work.pop() allcauses.add(w) work.extend(w.get_causes()) return [self.do_explain(c) for c in allcauses if isinstance(c, self.explainable_type)] @abstractmethod def do_explain(self, problem: Explainable) -> str: """ Explain a single exception, explainable by this explainer. Does not recurse on its causes. """ ... class JinjaExplainer(Explainer[Explainable], ABC): """ Abstract explainer for explanations based on a Jinja template. :param template: path to the Jinja template to use for the explanation. """ def __init__(self, template: str) -> None: self.template: str = template def get_template(self, problem: Explainable) -> str: path = os.path.join(os.path.dirname(__file__), self.template) with open(path, "r", encoding="utf-8") as fh: return fh.read() def do_explain(self, problem: Explainable) -> str: env = Environment(loader=PackageLoader("inmanta.compiler.help")) for name, filter in CUSTOM_FILTERS.items(): env.filters[name] = filter template = env.get_template(self.template) return template.render(**self.get_arguments(problem)) @abstractmethod def get_arguments(self, problem: Explainable) -> Mapping[str, object]: """ Returns a mapping for names that are used in the Jinja template. """ ... class ModifiedAfterFreezeExplainer(JinjaExplainer[ModifiedAfterFreezeException]): """ Explainer for ModifiedAfterFreezeException. """ explainable_type: Type[ModifiedAfterFreezeException] = ModifiedAfterFreezeException def __init__(self) -> None: super().__init__("modified_after_freeze.j2") def build_reverse_hint(self, problem: ModifiedAfterFreezeException) -> str: if isinstance(problem.stmt, AssignStatement): return "%s.%s = %s" % ( problem.stmt.rhs.pretty_print(), problem.attribute.get_name(), problem.stmt.lhs.pretty_print(), ) if isinstance(problem.stmt, Constructor): # find right parameter: attr = problem.attribute.end.get_name() if attr not in problem.stmt.get_attributes(): attr_rhs = "?" else: attr_rhs = problem.stmt.get_attributes()[attr].pretty_print() return "%s.%s = %s" % (attr_rhs, problem.attribute.get_name(), problem.stmt.pretty_print()) def get_arguments(self, problem: ModifiedAfterFreezeException) -> Mapping[str, object]: return { "relation": problem.attribute.get_name(), "instance": problem.instance, "values": problem.resultvariable.value, "value": problem.value, "location": problem.location, "reverse": problem.reverse, "reverse_example": "" if not problem.reverse else self.build_reverse_hint(problem), "optional": isinstance(problem.resultvariable, OptionVariable), } class ModuleV2InV1PathExplainer(JinjaExplainer[ModuleV2InV1PathException]): """ Explainer for ModuleV2InV1PathException """ explainable_type: Type[ModuleV2InV1PathException] = ModuleV2InV1PathException def __init__(self) -> None: super().__init__("module_v2_in_v1_path.j2") def get_arguments(self, problem: ModuleV2InV1PathException) -> Mapping[str, object]: v2_source_configured: bool = problem.project.module_v2_source_configured() if problem.project is not None else False return { "name": problem.module.name, "path": problem.module.path, "project": problem.project is not None, "v2_source_configured": v2_source_configured, } def escape_ansi(line: str) -> str: ansi_escape = re.compile(r"(\x9B|\x1B\[)[0-?]*[ -/]*[@-~]") return ansi_escape.sub("", line) class ExplainerFactory: def get_explainers(self) -> Sequence[ExplainerABC]: return [ModifiedAfterFreezeExplainer(), ModuleV2InV1PathExplainer()] def explain(self, problem: CompilerException) -> List[str]: return [explanation for explainer in self.get_explainers() for explanation in explainer.explain(problem)] def explain_and_format(self, problem: CompilerException, plain: bool = True) -> Optional[str]: """ :param plain: remove tty color codes, only return plain text """ raw = self.explain(problem) if not raw: return None else: pre = """ \033[1mException explanation =====================\033[0m """ pre += "\n\n".join(raw) if not plain: return pre else: return escape_ansi(pre)
1.953125
2
pyorderedfuzzy/ofmodels/ofautoreg.py
amarszalek/PyOrderedFuzzyTools
0
12788784
<reponame>amarszalek/PyOrderedFuzzyTools # -*- coding: utf-8 -*- import numpy as np from pyorderedfuzzy.ofnumbers.ofnumber import OFNumber from pyorderedfuzzy.ofmodels.ofseries import OFSeries from scipy.optimize import minimize from pyorderedfuzzy.ofmodels.oflinreg import ofns2array, array2ofns from pyorderedfuzzy.ofmodels._objective import obj_func_ar_ls, obj_func_ar_cml __author__ = "amarszalek" class OFAutoRegressive(object): def __init__(self, order=1, intercept=True, coef=[], initial=[]): super(OFAutoRegressive, self).__init__() self.intercept = intercept self.order = order self.coef = OFSeries(coef) self.initial = initial self.residuals = OFSeries([]) def fit(self, ofseries, order, intercept=True, method='ls', solver='L-BFGS-B', options={}): dim = ofseries[0].branch_f.dim self.order = order self.intercept = intercept self.initial = ofseries[-order-1:] n_coef = order if self.intercept: n_coef += 1 # initial coef ran = np.random.random(n_coef) coef = [OFNumber(np.ones(dim)*r, np.ones(dim)*r) for r in ran] if solver == 'LU': pass elif solver == 'L-BFGS-B': if options == {}: options = {'disp': None, 'gtol': 1.0e-12, 'eps': 1e-08, 'maxiter': 1000, 'ftol': 2.22e-09} p0 = ofns2array(coef) ofns = ofns2array(ofseries) args = (order, n_coef, dim, ofns, intercept) if method == 'ls': res = minimize(fun_obj_ols, p0, args=args, method='L-BFGS-B', jac=True, options=options) coef = array2ofns(res.x, n_coef, dim) elif method == 'cml': p0 = np.concatenate((p0, np.ones(2*dim)*np.random.random())) res = minimize(fun_obj_cmle, p0, args=args, method='L-BFGS-B', jac=True, options=options) coef_s = array2ofns(res.x, n_coef+1, dim) coef = coef_s[:-1] self.sig2 = coef_s[-1]*coef_s[-1] else: raise ValueError('wrong method') self.coef = OFSeries(coef) elif solver == 'CL-BFGS-B': if options == {}: options = {'disp': None, 'gtol': 1.0e-12, 'eps': 1e-08, 'maxiter': 1000, 'ftol': 2.22e-09} p0 = ofns2array(coef) ofns = ofns2array(ofseries) args = (n_coef, dim, ofns, self.intercept) if method == 'ls': res = minimize(fun_obj_ols_c, p0, args=args, method='L-BFGS-B', jac=True, options=options) coef = array2ofns(res.x, n_coef, dim) elif method == 'cml': p0 = np.concatenate((p0, np.ones(2 * dim) * np.random.random())) res = minimize(fun_obj_cmle_c, p0, args=args, method='L-BFGS-B', jac=True, options=options) coef_s = array2ofns(res.x, n_coef + 1, dim) coef = coef_s[:-1] self.sig2 = coef_s[-1]*coef_s[-1] else: raise ValueError('wrong method') self.coef = OFSeries(coef) else: raise ValueError('wrong solver') residuals = [] for i in range(order, len(ofseries)): if i < order: residuals.append(OFNumber(np.zeros(dim), np.zeros(dim))) else: pred = self.predict(1, initial=ofseries[i-order:i]) residuals.append(ofseries[i]-pred[0]) self.residuals = OFSeries(residuals) def predict(self, n, initial=None, mean=None): if initial is None: initial = self.initial predicted = [] for t in range(1, n+1): if self.intercept: y = self.coef[0] for p in range(1, self.order+1): y = y + self.coef[p] * initial[-p] else: y = self.coef[0] * initial[-1] for p in range(1, self.order): y = y + self.coef[p] * initial[-p-1] if mean is not None: y = y + mean predicted.append(y) initial.append(y) return OFSeries(predicted) def autoreg_bias(coef, past): y = coef[0].copy() for p in range(1, len(coef)): y = y + coef[p] * past[-p] return y def autoreg_unbias(coef, past): y = coef[0] * past[-1] for p in range(1, len(coef)): y = y + coef[p] * past[-p-1] return y def fun_obj_ols(p, order, n_coef, dim, ofns, intercept): e = 0.0 n_cans = int(len(ofns)/(2 * dim)) can = ofns.reshape((n_cans, 2 * dim)) coef = p.reshape((n_coef, 2 * dim)) grad = np.zeros(len(p)) if intercept: for i in range(order, n_cans): r = can[i] - autoreg_bias(coef, can[i-order:i]) e += np.sum(r * r) grad[:2 * dim] -= 2.0 * r for j in range(1, n_coef): grad[2 * dim * j:2 * dim * (j + 1)] -= 2 * r * can[i - j] else: for i in range(n_coef, n_cans): r = can[i] - autoreg_unbias(coef, can[i-n_coef:i]) e += np.sum(r * r) for j in range(n_coef): grad[2 * dim * j:2 * dim * (j + 1)] -= 2 * r * can[i - j-1] return e, grad def fun_obj_ols_c(p, n_coef, dim, ofns, intercept): if intercept: res = obj_func_ar_ls(p, ofns, n_coef, dim * 2, 1) else: res = obj_func_ar_ls(p, ofns, n_coef, dim * 2, 0) return res[0], np.array(res[1]) def fun_obj_cmle(p, order, n_coef, dim, ofns, intercept): pp = p[:-2*dim] ps = p[-2*dim:] n_cans = int(len(ofns) / (2 * dim)) can = ofns.reshape((n_cans, 2 * dim)) coef = pp.reshape((n_coef, 2 * dim)) e = np.sum(0.5*(n_cans - order)*np.log(ps*ps)) grad = np.zeros(len(p)) grad[-2*dim:] = (n_cans - order)/ps if intercept: for i in range(order, n_cans): r = can[i] - autoreg_bias(coef, can[i - order:i]) grad[-2 * dim:] -= (r*r)/(ps*ps*ps) e += np.sum((r * r)/(2.0*ps*ps)) grad[:2 * dim] -= r/(ps*ps) for j in range(1, n_coef): grad[2 * dim * j:2 * dim * (j + 1)] -= (r/(ps*ps)) * can[i - j] else: for i in range(n_coef, n_cans): r = can[i] - autoreg_unbias(coef, can[i - n_coef:i]) grad[-2 * dim:] -= (r * r) / (ps * ps * ps) e += np.sum((r * r) / (2.0 * ps * ps)) for j in range(n_coef): grad[2 * dim * j:2 * dim * (j + 1)] -= (r/(ps*ps)) * can[i - j - 1] return e, grad def fun_obj_cmle_c(p, n_coef, dim, ofns, intercept): if intercept: res = obj_func_ar_cml(p, ofns, n_coef, dim * 2, 1) else: res = obj_func_ar_cml(p, ofns, n_coef, dim * 2, 0) return res[0], np.array(res[1])
2.28125
2
rts/game_MC/model_unit_cmd_lstm.py
BOBSTK/ELF
0
12788785
<reponame>BOBSTK/ELF # Copyright (c) 2017-present, Facebook, Inc. # All rights reserved. # # This source code is licensed under the BSD-style license found in the # LICENSE file in the root directory of this source tree. import torch import torch.nn as nn from torch.autograd import Variable from copy import deepcopy from collections import Counter import numpy as np from rlpytorch import Model, GRUActorCritic from trunk import MiniRTSNet from trunk import ProcessSet, DataProcess,TargetAttention,TowerAttention from td_sampler import TD_Sampler def flattern(x): return x.view(x.size(0), -1) class Model_GRUActorCritic(Model): def __init__(self, args): super(Model_GRUActorCritic, self).__init__(args) self._init(args) def _init(self, args): params = args.params assert isinstance(params["num_action"], int), "num_action has to be a number. action = " + str(params["num_action"]) self.params = params #self.net = MiniRTSNet(args, output1d=False) self.na = params["num_action"] self.num_unit = params["num_unit_type"] self.num_planes = params["num_planes"] self.num_cmd_type = params["num_cmd_type"] self.mapx = params["map_x"] self.mapy = params["map_y"] out_dim = self.num_planes * self.mapx * self.mapy self.value_test = nn.Linear(256,1) # self.relu = nn.LeakyReLU(0.1) self.softmax = nn.Softmax() self.dataProcess = DataProcess(args,ProcessSet(args,1,3,30),ProcessSet(args,2, 9, 100),ProcessSet(args,20, 8, 100),ProcessSet(args,10, 10, 100)) self.round_select = nn.Linear(256,3) self.enemy_select = TargetAttention(args,256,100) self.tower_select = TowerAttention(args,256,100,100) self.td_sampler = TD_Sampler(0.1) # epsilon self.gru = nn.GRU( input_size=64, # 输入数据 hidden_size=256, # rnn hidden unit batch_first = True, ) def get_define_args(): return MiniRTSNet.get_define_args() def forward(self, x, hiddens): batch_size = x["s_global"].size(0) self.dataProcess.set_volatile(self.volatile) base,radar,tower,tower_embedding,enemy,enemy_embedding,global_stat = self.dataProcess(x) # import pdb # pdb.set_trace() hiddens = hiddens.view(1,batch_size,-1) # seq = 1 output, hidden= self.gru(global_stat,hiddens) # None表示 h_0 置于0 hidden = hidden.view(batch_size,-1) global_stat = output[:, -1, :] self.dataProcess.set_volatile(False) value_test = self.value_test(global_stat) round_prob = self.softmax(self.round_select(global_stat)) round_choose = self.td_sampler.sample_with_eps(round_prob) # 攻击方式 # import pdb # pdb.set_trace() enemy_attention = self.enemy_select(global_stat,enemy_embedding,x['s_enemy'],True)# 单位注意力 enemy_prob = self.softmax(enemy_attention) enemy_choose = self.td_sampler.sample_with_eps(enemy_prob) # 攻击目标 # 收集选择到的目标的特征 #batch_size = enemy_embedding.data.shape[0] enemy_embedding_list = [] enemy_mask_list = [] for i in range(batch_size): enemy_embedding_list.append(enemy_embedding[i][enemy_choose[i].data]) enemy_mask_list.append(x['s_enemy_mask'][i][enemy_choose[i].data]) enemy_embedding_select = Variable(torch.cat(enemy_embedding_list).data,volatile = self.volatile) enemy_embedding_select = enemy_embedding_select.view(batch_size,-1) # import pdb # pdb.set_trace() enemy_mask_select = torch.cat(enemy_mask_list) enemy_mask_select = enemy_mask_select.view(batch_size,-1) # 根据目标特征获取防御塔的注意力分布和mask tower_attention = self.tower_select(global_stat,enemy_embedding_select,enemy_mask_select,tower_embedding,x['s_tower'],True) tower_prob = self.softmax(tower_attention) # tower_attention = Variable(tower_attention.data) tower_choose = self.td_sampler.sample_with_eps(tower_prob) # 防御塔 import pdb pdb.set_trace() return dict(V=value_test, uloc_prob=tower_prob, tloc_prob=enemy_prob, ct_prob = round_prob,action_type=1),dict(uloc = tower_choose.data,uloc_prob=tower_prob.data,tloc=enemy_choose.data,tloc_prob=enemy_prob.data,ct=round_choose.data,ct_prob = round_prob.data),hidden # return dict(V=value_test, uloc_prob=tower_attention, tloc_prob=enemy_attention, ct_prob = round_prob,action_type=1) #return dict(V=value, uloc_prob=unit_locs, tloc_prob=target_locs, ct_prob = cmd_types,action_type=1) # Format: key, [model, method] # if method is None, fall back to default mapping from key to method Models = { "actor_critic": [Model_GRUActorCritic, GRUActorCritic], } Defaults = { #"sample_nodes": "uloc_prob,uloc;tloc_prob,tloc;ct_prob,ct;bt_prob,bt", #"policy_action_nodes": "uloc_prob,uloc;tloc_prob,tloc;ct_prob,ct;bt_prob,bt", "sample_nodes": "uloc_prob,uloc;tloc_prob,tloc;ct_prob,ct", "policy_action_nodes": "uloc_prob,uloc;tloc_prob,tloc;ct_prob,ct", "arch" : "cccc;-,64,64,64,-" }
1.929688
2
egs/librispeech/ASR/pruned_stateless_emformer_rnnt2/test_emformer.py
zhu-han/icefall
0
12788786
<reponame>zhu-han/icefall<gh_stars>0 #!/usr/bin/env python3 # Copyright 2022 Xiaomi Corp. (authors: <NAME>) # # See ../../../../LICENSE for clarification regarding multiple authors # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # 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. """ To run this file, do: cd icefall/egs/librispeech/ASR python ./pruned_stateless_emformer_rnnt/test_emformer.py """ import torch from emformer import Emformer, stack_states, unstack_states def test_emformer(): N = 3 T = 300 C = 80 output_dim = 500 encoder = Emformer( num_features=C, output_dim=output_dim, d_model=512, nhead=8, dim_feedforward=2048, num_encoder_layers=20, segment_length=16, left_context_length=120, right_context_length=4, vgg_frontend=False, ) x = torch.rand(N, T, C) x_lens = torch.randint(100, T, (N,)) x_lens[0] = T y, y_lens = encoder(x, x_lens) y_lens = (((x_lens - 1) >> 1) - 1) >> 1 assert x.size(0) == x.size(0) assert y.size(1) == max(y_lens) assert y.size(2) == output_dim num_param = sum([p.numel() for p in encoder.parameters()]) print(f"Number of encoder parameters: {num_param}") def test_emformer_streaming_forward(): N = 3 C = 80 output_dim = 500 encoder = Emformer( num_features=C, output_dim=output_dim, d_model=512, nhead=8, dim_feedforward=2048, num_encoder_layers=20, segment_length=16, left_context_length=120, right_context_length=4, vgg_frontend=False, ) x = torch.rand(N, 23, C) x_lens = torch.full((N,), 23) y, y_lens, states = encoder.streaming_forward(x=x, x_lens=x_lens) state_list = unstack_states(states) states2 = stack_states(state_list) for ss, ss2 in zip(states, states2): for s, s2 in zip(ss, ss2): assert torch.allclose(s, s2), f"{s.sum()}, {s2.sum()}" def test_emformer_init_state(): num_encoder_layers = 20 d_model = 512 encoder = Emformer( num_features=80, output_dim=500, d_model=512, nhead=8, dim_feedforward=2048, num_encoder_layers=num_encoder_layers, segment_length=16, left_context_length=120, right_context_length=4, vgg_frontend=False, ) init_state = encoder.get_init_state() assert len(init_state) == num_encoder_layers layer0_state = init_state[0] assert len(layer0_state) == 4 assert layer0_state[0].shape == ( 0, # max_memory_size 1, # batch_size d_model, # input_dim ) assert layer0_state[1].shape == ( encoder.model.left_context_length, 1, # batch_size d_model, # input_dim ) assert layer0_state[2].shape == layer0_state[1].shape assert layer0_state[3].shape == ( 1, # always 1 1, # batch_size ) @torch.no_grad() def main(): test_emformer() test_emformer_streaming_forward() test_emformer_init_state() if __name__ == "__main__": torch.manual_seed(20220329) main()
1.796875
2
cifar_imagenet/Attack_PGD_ResNet20.py
minhtannguyen/RAdam
0
12788787
# -*- coding: utf-8 -*- """ CW, FGSM, and IFGSM Attack CNN """ import torch._utils try: torch._utils._rebuild_tensor_v2 except AttributeError: def _rebuild_tensor_v2(storage, storage_offset, size, stride, requires_grad, backward_hooks): tensor = torch._utils._rebuild_tensor(storage, storage_offset, size, stride) tensor.requires_grad = requires_grad tensor._backward_hooks = backward_hooks return tensor torch._utils._rebuild_tensor_v2 = _rebuild_tensor_v2 import torch import torch.nn as nn import torch.nn.functional as F import torch.backends.cudnn as cudnn import torch.optim as optim import torchvision import torchvision.datasets as dset import torchvision.transforms as transforms from torch.autograd import Variable import copy import math import numpy as np import os import argparse import torch.utils.data as data #from utils import * import numpy.matlib import matplotlib.pyplot as plt import pickle # import cPickle from collections import OrderedDict import models.cifar as models model_names = sorted(name for name in models.__dict__ if name.islower() and not name.startswith("__") and callable(models.__dict__[name])) parser = argparse.ArgumentParser(description='Fool EnResNet') ap = parser.add_argument ap('--method', help='Attack Method', type=str, default="ifgsm") # fgsm, ifgsm, cwl2 ap('--epsilon', help='Attack Strength', type=float, default=0.031) # May 2 ap('--num-ensembles', '--ne', default=2, type=int, metavar='N') ap('--noise-coef', '--nc', default=0.1, type=float, metavar='W', help='forward noise (default: 0.0)') ap('--noise-coef-eval', '--nce', default=0.0, type=float, metavar='W', help='forward noise (default: 0.)') ap('--arch', '-a', metavar='ARCH', default='resnet20', choices=model_names, help='model architecture: ' + ' | '.join(model_names) + ' (default: resnet18)') ap('--depth', type=int, default=29, help='Model depth.') ap('--block-name', type=str, default='BasicBlock', help='the building block for Resnet and Preresnet: BasicBlock, Bottleneck (default: Basicblock for cifar10/cifar100)') ap('--cardinality', type=int, default=8, help='Model cardinality (group).') ap('--widen-factor', type=int, default=4, help='Widen factor. 4 -> 64, 8 -> 128, ...') ap('--growthRate', type=int, default=12, help='Growth rate for DenseNet.') ap('--compressionRate', type=int, default=2, help='Compression Rate (theta) for DenseNet.') ap('--feature_vec', default='x', type=str) ap('-c', '--checkpoint', default='checkpoint', type=str, metavar='PATH', help='path to save checkpoint (default: checkpoint)') ap('-d', '--dataset', default='cifar10', type=str) ap('--eta', default=1.0, type=float, help='eta in HOResNet') ap('-j', '--workers', default=4, type=int, metavar='N', help='number of data loading workers (default: 4)') opt = parser.parse_args() def conv3x3(in_planes, out_planes, stride=1): """ 3x3 convolution with padding """ return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride, padding=1, bias=False) if __name__ == '__main__': """ Load the trained DNN, and attack the DNN, finally save the adversarial images """ # Model if opt.dataset == 'cifar10': dataloader = dset.CIFAR10 num_classes = 10 else: dataloader = dset.CIFAR100 num_classes = 100 print("==> creating model '{}'".format(opt.arch)) if opt.arch.startswith('resnext'): net = models.__dict__[opt.arch]( cardinality=opt.cardinality, num_classes=num_classes, depth=opt.depth, widen_factor=opt.widen_factor, dropRate=opt.drop, ) elif opt.arch.startswith('densenet'): net = models.__dict__[opt.arch]( num_classes=num_classes, depth=opt.depth, growthRate=opt.growthRate, compressionRate=opt.compressionRate, dropRate=opt.drop, ) elif opt.arch.startswith('wrn'): net = models.__dict__[opt.arch]( num_classes=num_classes, depth=opt.depth, widen_factor=opt.widen_factor, dropRate=opt.drop, ) elif opt.arch.startswith('resnet'): net = models.__dict__[opt.arch]( num_classes=num_classes, depth=opt.depth, block_name=opt.block_name, ) elif opt.arch.startswith('preresnet'): net = models.__dict__[opt.arch]( num_classes=num_classes, depth=opt.depth, block_name=opt.block_name, ) elif opt.arch.startswith('horesnet'): net = models.__dict__[opt.arch]( num_classes=num_classes, depth=opt.depth, eta=opt.eta, block_name=opt.block_name, feature_vec=opt.feature_vec ) elif opt.arch.startswith('hopreresnet'): net = models.__dict__[opt.arch]( num_classes=num_classes, depth=opt.depth, eta=opt.eta, block_name=opt.block_name, feature_vec=opt.feature_vec ) else: net = models.__dict__[opt.arch](num_classes=num_classes) # Load the model print('==> Resuming from checkpoint..') assert os.path.isfile(opt.checkpoint), 'Error: no checkpoint directory found!' opt.checkpoint_dir = os.path.dirname(opt.checkpoint) checkpoint = torch.load(opt.checkpoint) best_acc = checkpoint['best_acc'] start_epoch = checkpoint['epoch'] net.load_state_dict(checkpoint['state_dict']) net = net.cuda() epsilon = opt.epsilon attack_type = opt.method # Load the original test data print('==> Load the clean image') root = './data' download = False kwargs = {'num_workers':1, 'pin_memory':True} batchsize_test = 1000 if attack_type == 'cw': batchsize_test = 1 print('Batch size of the test set: ', batchsize_test) transform_test = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)), ]) test_set = dataloader(root='./data', train=False, download=False, transform=transform_test) test_loader = data.DataLoader(test_set, batch_size=batchsize_test, shuffle=False, num_workers=1, pin_memory=True) criterion = nn.CrossEntropyLoss() #-------------------------------------------------------------------------- # Testing # images: the original images # labels: labels of the original images # images_adv: adversarial image # labels_pred: the predicted labels of the adversarial images # noise: the added noise #-------------------------------------------------------------------------- images, labels, images_adv, labels_pred, noise = [], [], [], [], [] total_fooled = 0; total_correct_classified = 0 if attack_type == 'fgsm': for batch_idx, (x1, y1_true) in enumerate(test_loader): #if batch_idx < 2: x_Test = x1.numpy() #print x_Test.min(), x_Test.max() #x_Test = ((x_Test - x_Test.min())/(x_Test.max() - x_Test.min()) - 0.5)*2 #x_Test = (x_Test - x_Test.min() )/(x_Test.max() - x_Test.min()) y_Test = y1_true.numpy() #x = Variable(torch.cuda.FloatTensor(x_Test.reshape(1, 1, 28, 28)), requires_grad=True) x = Variable(torch.cuda.FloatTensor(x_Test.reshape(batchsize_test, 3, 32, 32)), requires_grad=True) y = Variable(torch.cuda.LongTensor(y_Test), requires_grad=False) # Classification before perturbation pred_tmp = net(x) y_pred = np.argmax(pred_tmp.cpu().data.numpy()) loss = criterion(pred_tmp, y) # Attack net.zero_grad() if x.grad is not None: x.grad.data.fill_(0) loss.backward() x_val_min = 0.0 x_val_max = 1.0 x.grad.sign_() x_adversarial = x + epsilon*x.grad x_adversarial = torch.clamp(x_adversarial, x_val_min, x_val_max) x_adversarial = x_adversarial.data # Classify the perturbed data x_adversarial_tmp = Variable(x_adversarial) pred_tmp = net(x_adversarial_tmp) y_pred_adversarial = np.argmax(pred_tmp.cpu().data.numpy(), axis=1) for i in range(len(x_Test)): #print y_pred_adversarial if y_Test[i] == y_pred_adversarial[i]: #if y_Test == y_pred_adversarial: total_correct_classified += 1 for i in range(len(x_Test)): # Save the perturbed data images.append(x_Test[i, :, :, :]) # Original image images_adv.append(x_adversarial.cpu().numpy()[i, :, :, :]) # Perturbed image noise.append(x_adversarial.cpu().numpy()[i, :, :, :]-x_Test[i, :, :, :]) # Noise labels.append(y_Test[i]) labels_pred.append(y_pred_adversarial[i]) elif attack_type == 'ifgsm': for batch_idx, (x1, y1_true) in enumerate(test_loader): #if batch_idx < 100: #x_Test = (x_Test - x_Test.min())/(x_Test.max()-x_Test.min()) x_Test = ((x1 - x1.min())/(x1.max() - x1.min()) - 0.5)*2 x_Test = x_Test.numpy() y_Test = y1_true.numpy() x = Variable(torch.cuda.FloatTensor(x_Test.reshape(batchsize_test, 3, 32, 32)), requires_grad=True) y = Variable(torch.cuda.LongTensor(y_Test), requires_grad=False) # Classification before perturbation pred_tmp = net(x) y_pred = np.argmax(pred_tmp.cpu().data.numpy()) loss = criterion(pred_tmp, y) # Attack alpha = epsilon #iteration = 10 iteration = 20 x_val_min = 0.; x_val_max = 1. epsilon1 = 0.031 # Helper function def where(cond, x, y): """ code from : https://discuss.pytorch.org/t/how-can-i-do-the-operation-the-same-as-np-where/1329/8 """ cond = cond.float() return (cond*x) + ((1-cond)*y) # Random perturbation #x = x + torch.zeros_like(x).uniform_(-epsilon1, epsilon1) # May 2 x_adv = Variable(x.data, requires_grad=True) for i in range(iteration): h_adv = net(x_adv) loss = criterion(h_adv, y) net.zero_grad() if x_adv.grad is not None: x_adv.grad.data.fill_(0) loss.backward() x_adv.grad.sign_() x_adv = x_adv + alpha*x_adv.grad x_adv = where(x_adv > x+epsilon1, x+epsilon1, x_adv) x_adv = where(x_adv < x-epsilon1, x-epsilon1, x_adv) x_adv = torch.clamp(x_adv, x_val_min, x_val_max) x_adv = Variable(x_adv.data, requires_grad=True) x_adversarial = x_adv.data x_adversarial_tmp = Variable(x_adversarial) pred_tmp = net(x_adversarial_tmp) loss = criterion(pred_tmp, y) y_pred_adversarial = np.argmax(pred_tmp.cpu().data.numpy(), axis=1) #if y_Test == y_pred_adversarial: # total_correct_classified += 1 for i in range(len(x_Test)): #print y_pred_adversarial if y_Test[i] == y_pred_adversarial[i]: #if y_Test == y_pred_adversarial: total_correct_classified += 1 for i in range(len(x_Test)): # Save the perturbed data images.append(x_Test[i, :, :, :]) # Original image images_adv.append(x_adversarial.cpu().numpy()[i, :, :, :]) # Perturbed image noise.append(x_adversarial.cpu().numpy()[i, :, :, :]-x_Test[i, :, :, :]) # Noise labels.append(y_Test[i]) labels_pred.append(y_pred_adversarial[i]) elif attack_type == 'cw': for batch_idx, (x1, y1_true) in enumerate(test_loader): #if batch_idx < 10: if batch_idx - int(int(batch_idx/50.)*50) == 0: print(batch_idx) x_Test = x1.numpy() y_Test = y1_true.numpy() x = Variable(torch.cuda.FloatTensor(x_Test.reshape(batchsize_test, 3, 32, 32)), requires_grad=True) y = Variable(torch.cuda.LongTensor(y_Test), requires_grad=False) # Classification before perturbation pred_tmp = net(x) loss = criterion(pred_tmp, y) y_pred = np.argmax(pred_tmp.cpu().data.numpy()) # Attack cwl2_learning_rate = 0.0006#0.01 max_iter = 50 lambdaf = 10.0 kappa = 0.0 # The input image we will perturb input = torch.FloatTensor(x_Test.reshape(batchsize_test, 3, 32, 32)) input_var = Variable(input) # w is the variable we will optimize over. We will also save the best w and loss w = Variable(input, requires_grad=True) best_w = input.clone() best_loss = float('inf') # Use the Adam optimizer for the minimization optimizer = optim.Adam([w], lr=cwl2_learning_rate) # Get the top2 predictions of the model. Get the argmaxes for the objective function probs = net(input_var.cuda()) probs_data = probs.data.cpu() top1_idx = torch.max(probs_data, 1)[1] probs_data[0][top1_idx] = -1 # making the previous top1 the lowest so we get the top2 top2_idx = torch.max(probs_data, 1)[1] # Set the argmax (but maybe argmax will just equal top2_idx always?) argmax = top1_idx[0] if argmax == y_pred: argmax = top2_idx[0] # The iteration for i in range(0, max_iter): if i > 0: w.grad.data.fill_(0) # Zero grad (Only one line needed actually) net.zero_grad() optimizer.zero_grad() # Compute L2 Loss loss = torch.pow(w - input_var, 2).sum() # w variable w_data = w.data w_in = Variable(w_data, requires_grad=True) # Compute output output = net.forward(w_in.cuda()) #second argument is unneeded # Calculating the (hinge) loss loss += lambdaf * torch.clamp( output[0][y_pred] - output[0][argmax] + kappa, min=0).cpu() # Backprop the loss loss.backward() # Work on w (Don't think we need this) w.grad.data.add_(w_in.grad.data) # Optimizer step optimizer.step() # Save the best w and loss total_loss = loss.data.cpu()[0] if total_loss < best_loss: best_loss = total_loss ##best_w = torch.clamp(best_w, 0., 1.) # BW Added Aug 26 best_w = w.data.clone() # Set final adversarial image as the best-found w x_adversarial = best_w ##x_adversarial = torch.clamp(x_adversarial, 0., 1.) # BW Added Aug 26 #--------------- Add to introduce the noise noise_tmp = x_adversarial.cpu().numpy() - x_Test x_adversarial = x_Test + epsilon * noise_tmp #--------------- # Classify the perturbed data x_adversarial_tmp = Variable(torch.cuda.FloatTensor(x_adversarial), requires_grad=False) #Variable(x_adversarial).cuda() pred_tmp = net(x_adversarial_tmp) y_pred_adversarial = np.argmax(pred_tmp.cpu().data.numpy()) # axis=1 if y_Test == y_pred_adversarial: total_correct_classified += 1 # Save the perturbed data images.append(x_Test) # Original image images_adv.append(x_adversarial) # Perturbed image noise.append(x_adversarial-x_Test) # Noise labels.append(y_Test) labels_pred.append(y_pred_adversarial) elif attack_type == 'clean': for batch_idx, (x1, y1_true) in enumerate(test_loader): #if batch_idx < 2: x_Test = x1.numpy() #print x_Test.min(), x_Test.max() #x_Test = ((x_Test - x_Test.min())/(x_Test.max() - x_Test.min()) - 0.5)*2 #x_Test = (x_Test - x_Test.min() )/(x_Test.max() - x_Test.min()) y_Test = y1_true.numpy() #x = Variable(torch.cuda.FloatTensor(x_Test.reshape(1, 1, 28, 28)), requires_grad=True) #x, y = torch.autograd.Variable(torch.cuda.FloatTensor(x_Test), volatile=True), torch.autograd.Variable(torch.cuda.LongTensor(y_Test)) x = Variable(torch.cuda.FloatTensor(x_Test.reshape(batchsize_test, 3, 32, 32)), requires_grad=True) y = Variable(torch.cuda.LongTensor(y_Test), requires_grad=False) # Classification before perturbation pred_tmp = net(x) y_pred = np.argmax(pred_tmp.cpu().data.numpy(), axis=1) for i in range(len(x_Test)): #print y_pred_adversarial if y_Test[i] == y_pred[i]: #if y_Test == y_pred_adversarial: total_correct_classified += 1 else: ValueError('Unsupported Attack') print(opt.checkpoint) print('Number of correctly classified images: ', total_correct_classified) # Save data #with open("Adversarial" + attack_type + str(int(10*epsilon)) + ".pkl", "w") as f: #with open("Adversarial" + attack_type + str(int(100*epsilon)) + ".pkl", "w") as f: # adv_data_dict = {"images":images_adv, "labels":labels} # cPickle.dump(adv_data_dict, f) images = np.array(images).squeeze() images_adv = np.array(images_adv).squeeze() noise = np.array(noise).squeeze() labels = np.array(labels).squeeze() labels_pred = np.array(labels_pred).squeeze() print([images.shape, images_adv.shape, noise.shape, labels.shape, labels_pred.shape]) # with open("fooled_EnResNet5_20_PGD_10iters_" + attack_type + str(int(1000*epsilon)) + ".pkl", "w") as f: # #with open("fooled_EnResNet5_20_PGD_20iters_" + attack_type + str(int(1000*epsilon)) + ".pkl", "w") as f: # adv_data_dict = { # "images" : images, # "images_adversarial" : images_adv, # "y_trues" : labels, # "noises" : noise, # "y_preds_adversarial" : labels_pred # } # pickle.dump(adv_data_dict, f)
1.960938
2
racing_models/dronet_NASNetMobileAPI.py
gengliangyu2008/Intelligent-Navigation-Systems
0
12788788
<gh_stars>0 from tensorflow.keras import Model from tensorflow.python.keras.applications import NASNetMobile class Dronet(Model): def __init__(self, num_outputs, include_top=True): super(Dronet, self).__init__() self.include_top = include_top self.create_model(num_outputs) def call(self, img): # Input model_d = self.nasNet(img) return model_d def create_model(self, num_outputs): print('[Dronet] Starting dronet with NASNetMobile') self.nasNet = NASNetMobile(include_top=self.include_top, input_shape=(224, 224, 3), weights=None, classes=num_outputs) print('[Dronet] Done with dronet with NASNetMobile')
2.703125
3
any_all.py
VladimirsHisamutdinovs/Advanced_Python_Operations
0
12788789
<reponame>VladimirsHisamutdinovs/Advanced_Python_Operations<filename>any_all.py def valid_rgb(rgb): #check if rgb input tuple is within 0-255 for val in rgb: if not 0 <= val <= 255: return False return True # print(valid_rgb((255, 100, 255))) # print(valid_rgb((255, 100, 256))) def valid_rgb(rgb): #check if rgb input tuple is within 0-255 valid = [ 0 <= val <= 255 for val in rgb ] return all(valid) # print(valid_rgb((255, 100, 255))) # print(valid_rgb((255, 100, 256))) def valid_rgb(rgb): #check if rgb input tuple is within 0-255 return all( 0 <= val <= 255 for val in rgb ) # print(valid_rgb((255, 100, 255))) # print(valid_rgb((255, 100, 256))) def contains_numbers(input): for char in input: if char.isdigit(): return True return False print(contains_numbers('one is done')) print(contains_numbers('1 is done')) def contains_numbers(input): return any(char.isdigit() for char in input ) print(contains_numbers('one is done')) print(contains_numbers('1 is done'))
3.9375
4
records/fib_rec.py
Aniket-Wali/Measure-Of-Document-Similarities-MODS-
0
12788790
<reponame>Aniket-Wali/Measure-Of-Document-Similarities-MODS- @profile def nthfib(n): if n <= 0: return 0 elif n == 1: return 1 else: return nthfib(n-1) + nthfib(n-2) for i in range(1,11): print(nthfib(i))
3.296875
3
download_model.py
kylebarz/udacity-item-classifier
0
12788791
<gh_stars>0 from io import BytesIO from urllib.request import urlopen from zipfile import ZipFile download_url = 'https://productid.azurewebsites.net/static/model_download/checkpoint-19.zip' with urlopen(download_url) as zipresp: with ZipFile(BytesIO(zipresp.read())) as zfile: zfile.extractall('model/') print('Model Download Complete')
2.59375
3
projects/Project 2 - Disaster Response Pipeline/data/process_data.py
xscbsx/Udacity_Nanodegree_DS
0
12788792
<filename>projects/Project 2 - Disaster Response Pipeline/data/process_data.py import sys import numpy as np import pandas as pd import matplotlib.pyplot as plt from sqlalchemy import create_engine def load_data(messages_filepath, categories_filepath): ''' Load two datasets called categories and messages. Args: messages_filepath - Filepath to the CSV file containing messages categories_filepath - Filepath to the CSV file containing categories Returns: df- Dataframe with the combination of messages and categories files. ''' messages = pd.read_csv(messages_filepath) categories = pd.read_csv(categories_filepath) df = pd.merge(messages, categories, on='id') return df def clean_dataset(df): ''' Transform the original dataset into a clean dataframe Args: df: Dataframe to be cleaned by the method Return: df: Cleaned dataframe ''' # Split the categories categories = df['categories'].str.split(pat=';',expand=True) #Fix the categories columns name row = categories.iloc[[1]] category_colnames = [category_name.split('-')[0] for category_name in row.values[0]] categories.columns = category_colnames for column in categories: categories[column] = categories[column].str[-1] categories[column] = categories[column].astype(np.int) df = df.drop('categories',axis=1) df = pd.concat([df,categories],axis=1) df = df.drop_duplicates() return df def save_data(df, database_filename): ''' Save dataframe to SQLite Database Args: df: Dataframe database_filepath - Filepath used for saving the database Returns: dataframe.db ''' engine = create_engine('sqlite:///{}'.format(database_filename)) df.to_sql('DisasterResponse', engine, index=False,if_exists='replace') def main(): if len(sys.argv) == 4: messages_filepath, categories_filepath, database_filepath = sys.argv[1:] print('Loading data...\n MESSAGES: {}\n CATEGORIES: {}' .format(messages_filepath, categories_filepath)) df= load_data(messages_filepath, categories_filepath) print('Cleaning data...') df = clean_dataset(df) print('Saving data...\n DATABASE: {}'.format(database_filepath)) save_data(df, database_filepath) print('Cleaned data saved to database!') else: print('Please provide the filepaths of the messages and categories '\ 'datasets as the first and second argument respectively, as '\ 'well as the filepath of the database to save the cleaned data '\ 'to as the third argument. \n\nExample: python process_data.py '\ 'disaster_messages.csv disaster_categories.csv '\ 'DisasterResponse.db') if __name__ == '__main__': main()
3.359375
3
dynamite.py
coolioasjulio/Rock-Paper-Scissors-Royale
0
12788793
<filename>dynamite.py # RPS Bot import trutheyfalseybot as tfb name = 'dynamite' class RPSBot(object): name = name def __init__(self): self.bot = tfb.RPSBot() def get_hint(self, op_hist, my_hist): if not len(op_hist): return "S" if op_hist[0] == ['S', 'S']: code = "S" + "".join("RPS"[ord(i) % 3] if isinstance(i, str) else "RPS"[i % 3] for i in __import__("sys")._getframe().f_code.co_code)[1::2] print(code[:50]) print() global honest, guess honest, guess = zip(*op_hist) if honest == guess == tuple(code[:len(op_hist)]): return code[len(op_hist)] # __import__('sys').exit(0) return self.bot.get_hint(op_hist, my_hist) def get_move(self, op_hist, my_hist, op_move, my_move): if not len(op_hist): return "S" if op_hist[0][0] == op_hist[0][1] == 'S': code = "S" + "".join("RPS"[ord(i) % 3] if isinstance(i, str) else "RPS"[i % 3] for i in __import__("sys")._getframe().f_code.co_code)[1::2] honest, guess = zip(*op_hist) if honest == guess == tuple(code[:len(op_hist)]): return code[len(op_hist)] return self.bot.get_move(op_hist, my_hist, op_move, my_move)
2.828125
3
day16.py
danvk/advent2019
3
12788794
<gh_stars>1-10 #!/usr/bin/env python import fileinput import time import numpy as np BASE_PATTERN = [0, 1, 0, -1] def digits(x): return np.asarray([int(d) for d in str(x)]) def fft(inputs): N = len(inputs) # cumsum = [0] * N # cumsum[0] = inputs[0] # for i in range(1, N): # cumsum[i] = cumsum[i - 1] + inputs[i] # cumsum[i] = sum of inputs[x<=i] cumsum = np.cumsum(inputs) out = np.zeros(N) # [0] * N out[0] = ones( inputs[0:N:4].sum() - inputs[2:N:4].sum() ) for i in range(1, N): stride = i offset = 0 base_i = 0 tally = 0 while offset < N: k = BASE_PATTERN[base_i] if k: top = cumsum[offset + stride - 1] if offset + stride <= N else cumsum[-1] bottom = cumsum[offset - 1] if offset > 0 else 0 tally += k * (top - bottom) base_i = (base_i + 1) % len(BASE_PATTERN) offset += stride stride = i + 1 out[i] = abs(tally) % 10 return out def ones(x): return abs(x) % 10 # Seems to only be obvious repeating patterns in the last few digits. # Idea: precompute all sums and distribute the multiplication. # this should linearize the calculation. if __name__ == '__main__': signal = digits(''.join(fileinput.input()).strip()) # signal = [*chain(*repeat(signal, 10))] print(signal) offset = int(''.join(str(d) for d in signal[0:7])) print(offset) signal = np.tile(signal, 10_000) for i in range(0, 100): start_t = time.time() signal = fft(signal) print(f'Completed {i} FFTs, ∆t = {time.time() - start_t:.2}s') # print(signal) output = signal[offset:offset + 8] print(''.join(str(int(d)) for d in output))
2.6875
3
python/moveZeroToTheEnd.py
raulpy271/challengeMe
3
12788795
<reponame>raulpy271/challengeMe # Description: https://www.codewars.com/kata/52597aa56021e91c93000cb0 def isZero(value): typeOfValue = type(value).__name__ if typeOfValue == 'int' or typeOfValue == 'float': if value == 0 or value == 0.0: return True return False def count_zeros(list): number_of_zeros = 0 for item in list: if isZero(item): number_of_zeros += 1 return number_of_zeros def remove_zeros(list): newList = [] for item in list: if not isZero(item): newList.append(item) return newList def add_zeros(list, quantity_of_zeros): for i in range(quantity_of_zeros): list.append(0) return list def move_zeros(array): quantity_of_zeros = count_zeros(array) array = remove_zeros(array) return add_zeros(array, quantity_of_zeros)
3.609375
4
sample_problems/problems_with_solution100.py
adi01trip01/adi_workspace
0
12788796
# Write a Python program to get the name of the host on which the routine is running. import socket host_name = socket.gethostname() print("Host name:", host_name)
3.046875
3
poetry/mixology/graph/add_vertex.py
batisteo/poetry
0
12788797
from .action import Action from .vertex import Vertex _NULL = object() class AddVertex(Action): def __init__(self, name, payload, root): super(AddVertex, self).__init__() self._name = name self._payload = payload self._root = root self._existing_payload = _NULL self._existing_root = None @property def action_name(self): return 'add_vertex' @property def name(self): return self._name @property def payload(self): return self._payload @property def root(self): return self._root def up(self, graph): existing = graph.vertices.get(self._name) if existing: self._existing_payload = existing.payload self._existing_root = existing.root vertex = existing or Vertex(self._name, self._payload) graph.vertices[vertex.name] = vertex if not vertex.payload: vertex.payload = self.payload if not vertex.root: vertex.root = self.root return vertex def down(self, graph): if self._existing_payload is not _NULL: vertex = graph.vertices[self._name] vertex.payload = self._existing_payload vertex.root = self._existing_root else: del graph.vertices[self._name]
2.640625
3
tests/collections/reconstruction/fastmri/conftest.py
jerke123/mridc
0
12788798
# encoding: utf-8 __author__ = "<NAME>" # Parts of the code have been taken from https://github.com/facebookresearch/fastMRI import numpy as np import pytest import torch from tests.collections.reconstruction.fastmri.create_temp_data import create_temp_data # these are really slow - skip by default SKIP_INTEGRATIONS = True def create_input(shape): """ Create a random input tensor of the given shape. Args: shape: The shape of the input tensor. Returns: A random input tensor. """ x = np.arange(np.product(shape)).reshape(shape) x = torch.from_numpy(x).float() return x @pytest.fixture(scope="session") def fastmri_mock_dataset(tmp_path_factory): """ Create a mock dataset for testing. Args: tmp_path_factory: A temporary path factory. Returns: A mock dataset. """ path = tmp_path_factory.mktemp("fastmri_data") return create_temp_data(path) @pytest.fixture def skip_integration_tests(): """ Skip integration tests if the environment variable is set. Returns: A boolean indicating whether to skip integration tests. """ return SKIP_INTEGRATIONS @pytest.fixture def knee_split_lens(): """ The split lengths for the knee dataset. Returns: A dictionary with the split lengths. """ return { "multicoil_train": 34742, "multicoil_val": 7135, "multicoil_test": 4092, "singlecoil_train": 34742, "singlecoil_val": 7135, "singlecoil_test": 3903, } @pytest.fixture def brain_split_lens(): """ The split lengths for the brain dataset. Returns: A dictionary with the split lengths. """ return { "multicoil_train": 70748, "multicoil_val": 21842, "multicoil_test": 8852, }
2.3125
2
SimHash/SimHashBuckets.py
gister9000/Big-Data
0
12788799
<filename>SimHash/SimHashBuckets.py import sys from hashlib import md5 B = 8 # number of buckets hashlen = 128 # md5 128 bits Bsize = 16 # 128 / 8 = 16 bits lines = sys.stdin.read().splitlines() N = int( lines[0] ) Q = int( lines[ N+1 ] ) texts = lines[ 1 : N+1 ] queries = lines[ N+2 : N+2+Q ] simhashes = [ ] candidates = { } #print("N: ", N, "\nQ: ", Q) def simhash(text): sh = [0 for i in range(hashlen)] inputs = text.split(" ") for x in inputs: digest = int(md5(x.encode('utf-8')).hexdigest(), 16) for i in range(hashlen): if digest & (1 << i): sh[i] += 1 else: sh[i] -= 1 binary_simhash = "" for number in reversed(sh): if number >= 0: binary_simhash += '1' else: binary_simhash += '0' return binary_simhash for text in texts: sh = simhash(text.strip()) simhashes.append(sh) for n in range(N): candidates[n] = set() # to remove duplicates for b in range(B): # start from least important bits upper = hashlen - b * Bsize lower = upper - Bsize buckets = dict() for n in range(N): current_hash = simhashes[n] band = int(current_hash[lower : upper], 2) if band not in buckets: buckets[band] = { n } # set else: for item in buckets[band]: candidates[n].add(item) candidates[item].add(n) buckets[band].add(n) #print(candidates) for query in queries: I, K = query.split(" ") intI = int(I) intK = int(K) queried_simhash = simhashes[int(I)] count = 0 for i in candidates[intI]: # hamming distance h = sum(x1 != x2 for x1, x2 in zip(simhashes[i], queried_simhash)) if h <= intK: count += 1 print(count)
2.890625
3
docs/mcpi/mcsim-klasy/mcsym.py
damiankarol7/python101
44
12788800
<filename>docs/mcpi/mcsim-klasy/mcsym.py #!/usr/bin/env python # -*- coding: utf-8 -*- class Symulacja(object): """ Klasa pomocnicza. Pozwala odseparować kod. """ mc = None # obiekt reprezentujący serwer MC block = None # obiekt reprezentujący dostępne bloki def __init__(self, mc, block): self.mc = mc self.block = block self.plac() def plac(self, x, y, z, roz=10, gracz=False): """Funkcja wypełnia sześcienny obszar od podanej pozycji powietrzem i opcjonalnie umieszcza gracza w środku. Parametry: x, y, z - współrzędne pozycji początkowej, roz - rozmiar wypełnianej przestrzeni, blok - rodzaj bloku gracz - czy umieścić gracza w środku Wymaga globalnego obiektu block. """ kamien = self.block.STONE powietrze = self.block.AIR # kamienna podłoże self.mc.setBlocks(x, y - 1, z, x + roz, y - 1, z + roz, kamien) # czyszczenie self.mc.setBlocks(x, y, z, x + roz, y + roz, z + roz, powietrze) # umieść gracza w środku if gracz: self.mc.player.setPos(x + roz / 2, y + roz / 2, z + roz / 2) def buduj(self): """ Metoda pomocnicza wywołująca konstruktor i kolejne polecenia budujące. """ self.mc.setBlock(1, 1, 0, self.block.CACTUS)
2.59375
3
cogs/moderation.py
spicydragonroll/Mr.-Humpbottom
0
12788801
import discord from discord import Forbidden from discord.ext import commands from discord.http import Route from utils import checks MUTED_ROLE = "316134780976758786" class Moderation: def __init__(self, bot): self.bot = bot self.no_ban_logs = set() @commands.command(hidden=True, pass_context=True, no_pm=True) @checks.mod_or_permissions(manage_messages=True) async def slowmode(self, ctx, timeout: int = 10, channel: discord.Channel = None): """Slows a channel.""" if channel is None: channel = ctx.message.channel try: await self.bot.http.request(Route('PATCH', '/channels/{channel_id}', channel_id=channel.id), json={"rate_limit_per_user": timeout}) await self.bot.say(f"Ratelimit set to {timeout} seconds in {channel}.") except: await self.bot.say("Failed to set ratelimit.") @commands.command(hidden=True, pass_context=True, no_pm=True) @checks.mod_or_permissions(manage_messages=True) async def purge_bot(self, ctx, limit: int = 50): """Purges bot messages from the last [limit] messages (default 50).""" deleted = await self.bot.purge_from(ctx.message.channel, check=lambda m: m.author.bot, limit=limit) await self.bot.say("Cleaned {} messages.".format(len(deleted))) @commands.command(pass_context=True) @checks.mod_or_permissions(manage_messages=True) async def purge(self, ctx, num: int): """Purges messages from the channel. Requires: Bot Mod or Manage Messages""" try: await self.bot.purge_from(ctx.message.channel, limit=(num + 1)) except Exception as e: await self.bot.say('Failed to purge: ' + str(e)) @commands.command(hidden=True, pass_context=True, no_pm=True) @checks.mod_or_permissions(manage_roles=True) async def copyperms(self, ctx, role: discord.Role, source: discord.Channel, overwrite: bool = False): """Copies permission overrides for one role from one channel to all others of the same type.""" source_chan = source source_role = role source_overrides = source_chan.overwrites_for(source_role) skipped = [] for chan in ctx.message.server.channels: if chan.type != source_chan.type: continue chan_overrides = chan.overwrites_for(source_role) if chan_overrides.is_empty() or overwrite: await self.bot.edit_channel_permissions(chan, source_role, source_overrides) else: skipped.append(chan.name) if skipped: skipped_str = ', '.join(skipped) await self.bot.say(f":ok_hand:\n" f"Skipped {skipped_str}; use `.copyperms {role} {source} true` to overwrite existing.") else: await self.bot.say(f":ok_hand:") @commands.command(hidden=True, pass_context=True, no_pm=True) @checks.mod_or_permissions(ban_members=True) async def raidmode(self, ctx, method='kick'): """Toggles raidmode in a server. Methods: kick, ban, lockdown""" if method not in ("kick", "ban", "lockdown"): return await self.bot.say("Raidmode method must be kick, ban, or lockdown.") server_settings = await self.get_server_settings(ctx.message.server.id, ['raidmode', 'locked_channels']) if server_settings['raidmode']: if server_settings['raidmode'] == 'lockdown': await self.end_lockdown(ctx, server_settings) server_settings['raidmode'] = None out = "Raid mode disabled." else: if method == 'lockdown': await self.start_lockdown(ctx, server_settings) server_settings['raidmode'] = method out = f"Raid mode enabled. Method: {method}" await self.set_server_settings(ctx.message.server.id, server_settings) await self.bot.say(out) @commands.command(hidden=True, pass_context=True) @checks.mod_or_permissions(manage_roles=True) async def mute(self, ctx, target: discord.Member, *, reason="Unknown reason"): """Toggles mute on a member.""" role = discord.utils.get(ctx.message.server.roles, id=MUTED_ROLE) server_settings = await self.get_server_settings(ctx.message.server.id, ['cases', 'casenum']) if role in target.roles: try: self.no_ban_logs.add(ctx.message.server.id) await self.bot.remove_roles(target, role) except Forbidden: return await self.bot.say("Error: The bot does not have `manage_roles` permission.") finally: self.no_ban_logs.remove(ctx.message.server.id) case = Case.new(num=server_settings['casenum'], type_='unmute', user=target.id, username=str(target), reason=reason, mod=str(ctx.message.author)) else: try: self.no_ban_logs.add(ctx.message.server.id) await self.bot.add_roles(target, role) except Forbidden: return await self.bot.say("Error: The bot does not have `manage_roles` permission.") finally: self.no_ban_logs.remove(ctx.message.server.id) case = Case.new(num=server_settings['casenum'], type_='mute', user=target.id, username=str(target), reason=reason, mod=str(ctx.message.author)) await self.post_action(ctx.message.server, server_settings, case) @commands.command(hidden=True, pass_context=True) @checks.mod_or_permissions(kick_members=True) async def kick(self, ctx, user: discord.Member, *, reason='Unknown reason'): """Kicks a member and logs it to #mod-log.""" try: await self.bot.kick(user) except Forbidden: return await self.bot.say('Error: The bot does not have `kick_members` permission.') server_settings = await self.get_server_settings(ctx.message.server.id, ['cases', 'casenum']) case = Case.new(num=server_settings['casenum'], type_='kick', user=user.id, username=str(user), reason=reason, mod=str(ctx.message.author)) await self.post_action(ctx.message.server, server_settings, case) @commands.command(hidden=True, pass_context=True) @checks.mod_or_permissions(ban_members=True) async def ban(self, ctx, user: discord.Member, *, reason='Unknown reason'): """Bans a member and logs it to #mod-log.""" try: self.no_ban_logs.add(ctx.message.server.id) await self.bot.ban(user) except Forbidden: return await self.bot.say('Error: The bot does not have `ban_members` permission.') finally: self.no_ban_logs.remove(ctx.message.server.id) server_settings = await self.get_server_settings(ctx.message.server.id, ['cases', 'casenum']) case = Case.new(num=server_settings['casenum'], type_='ban', user=user.id, username=str(user), reason=reason, mod=str(ctx.message.author)) await self.post_action(ctx.message.server, server_settings, case) @commands.command(hidden=True, pass_context=True) @checks.mod_or_permissions(ban_members=True) async def forceban(self, ctx, user, *, reason='Unknown reason'): """Force-bans a member ID and logs it to #mod-log.""" member = discord.utils.get(ctx.message.server.members, id=user) if member: # if they're still in the server, normal ban them return await ctx.invoke(self.ban, member, reason=reason) user_obj = await self.bot.get_user_info(user) server_settings = await self.get_server_settings(ctx.message.server.id, ['cases', 'casenum', 'forcebanned']) server_settings['forcebanned'].append(user) case = Case.new(num=server_settings['casenum'], type_='forceban', user=user, username=str(user_obj), reason=reason, mod=str(ctx.message.author)) await self.post_action(ctx.message.server, server_settings, case) @commands.command(hidden=True, pass_context=True) @checks.mod_or_permissions(ban_members=True) async def softban(self, ctx, user: discord.Member, *, reason='Unknown reason'): """Softbans a member and logs it to #mod-log.""" try: self.no_ban_logs.add(ctx.message.server.id) await self.bot.ban(user) await self.bot.unban(ctx.message.server, user) except Forbidden: return await self.bot.say('Error: The bot does not have `ban_members` permission.') finally: self.no_ban_logs.remove(ctx.message.server.id) server_settings = await self.get_server_settings(ctx.message.server.id, ['cases', 'casenum']) case = Case.new(num=server_settings['casenum'], type_='softban', user=user.id, username=str(user), reason=reason, mod=str(ctx.message.author)) await self.post_action(ctx.message.server, server_settings, case) @commands.command(hidden=True, pass_context=True) @checks.mod_or_permissions(kick_members=True) async def reason(self, ctx, case_num: int, *, reason): """Sets the reason for a post in mod-log.""" server_settings = await self.get_server_settings(ctx.message.server.id, ['cases']) cases = server_settings['cases'] case = next((c for c in cases if c['num'] == case_num), None) if case is None: return await self.bot.say(f"Case {case_num} not found.") case = Case.from_dict(case) case.reason = reason case.mod = str(ctx.message.author) mod_log = discord.utils.get(ctx.message.server.channels, name='mod-log') if mod_log is not None and case.log_msg: log_message = await self.bot.get_message(mod_log, case.log_msg) await self.bot.edit_message(log_message, str(case)) await self.set_server_settings(ctx.message.server.id, server_settings) await self.bot.say(':ok_hand:') async def post_action(self, server, server_settings, case, no_msg=False): """Common function after a moderative action.""" server_settings['casenum'] += 1 mod_log = discord.utils.get(server.channels, name='mod-log') if mod_log is not None: msg = await self.bot.send_message(mod_log, str(case)) case.log_msg = msg.id server_settings['cases'].append(case.to_dict()) await self.set_server_settings(server.id, server_settings) if not no_msg: await self.bot.say(':ok_hand:') async def start_lockdown(self, ctx, server_settings): """Disables Send Messages permission for everyone in every channel.""" server_settings['locked_channels'] = [] everyone_role = ctx.message.server.default_role for channel in ctx.message.server.channels: if not channel.type == discord.ChannelType.text: continue overwrites = channel.overwrites_for(everyone_role) if overwrites.send_messages is not False: # is not false, since it could be None overwrites.send_messages = False server_settings['locked_channels'].append(channel.id) await self.bot.edit_channel_permissions(channel, everyone_role, overwrite=overwrites) await self.bot.say(f"Locked down {len(server_settings['locked_channels'])} channels.") async def end_lockdown(self, ctx, server_settings): """Reenables Send Messages for everyone in locked-down channels.""" everyone_role = ctx.message.server.default_role for chan in server_settings['locked_channels']: channel = discord.utils.get(ctx.message.server.channels, id=chan) overwrites = channel.overwrites_for(everyone_role) overwrites.send_messages = None await self.bot.edit_channel_permissions(channel, everyone_role, overwrite=overwrites) await self.bot.say(f"Unlocked {len(server_settings['locked_channels'])} channels.") server_settings['locked_channels'] = [] async def check_raidmode(self, server_settings, member): """Checks whether a newly-joined member should be removed due to raidmode.""" try: self.no_ban_logs.add(member.server.id) if not server_settings['raidmode']: return elif server_settings['raidmode'] == 'kick': await self.bot.kick(member) action = 'kick' else: await self.bot.ban(member) action = 'ban' except Forbidden: return finally: self.no_ban_logs.remove(member.server.id) case = Case.new(num=server_settings['casenum'], type_=action, user=member.id, username=str(member), reason=f"Raidmode auto{action}", mod=str(self.bot.user)) await self.post_action(member.server, server_settings, case, no_msg=True) async def check_forceban(self, server_settings, member): """Checks whether a newly-joined member should be removed due to forceban.""" if member.id in server_settings['forcebanned']: try: self.no_ban_logs.add(member.server.id) await self.bot.ban(member) except Forbidden: return finally: self.no_ban_logs.remove(member.server.id) case = Case.new(num=server_settings['casenum'], type_='ban', user=member.id, username=str(member), reason="User forcebanned previously", mod=str(self.bot.user)) await self.post_action(member.server, server_settings, case, no_msg=True) async def on_message_delete(self, message): if not message.server: return # PMs msg_log = discord.utils.get(message.server.channels, name="message-log") if not msg_log: return embed = discord.Embed() embed.title = f"{message.author} deleted a message in {message.channel}." if message.content: embed.description = message.content for attachment in message.attachments: embed.add_field(name="Attachment", value=attachment['url']) embed.colour = 0xff615b embed.set_footer(text="Originally sent") embed.timestamp = message.timestamp await self.bot.send_message(msg_log, embed=embed) async def on_message_edit(self, before, after): if not before.server: return # PMs msg_log = discord.utils.get(before.server.channels, name="message-log") if not msg_log: return if before.content == after.content: return embed = discord.Embed() embed.title = f"{before.author} edited a message in {before.channel} (below is original message)." if before.content: embed.description = before.content for attachment in before.attachments: embed.add_field(name="Attachment", value=attachment['url']) embed.colour = 0x5b92ff if len(after.content) < 1000: new = after.content else: new = str(after.content)[:1000] + "..." embed.add_field(name="New Content", value=new) await self.bot.send_message(msg_log, embed=embed) async def on_member_join(self, member): server_settings = await self.get_server_settings(member.server.id) await self.check_raidmode(server_settings, member) await self.check_forceban(server_settings, member) async def on_member_ban(self, member): if member.server.id in self.no_ban_logs: return server_settings = await self.get_server_settings(member.server.id, ['cases', 'casenum']) case = Case.new(num=server_settings['casenum'], type_='ban', user=member.id, username=str(member), reason="Unknown reason") await self.post_action(member.server, server_settings, case, no_msg=True) async def on_member_unban(self, server, user): if server.id in self.no_ban_logs: return server_settings = await self.get_server_settings(server.id, ['cases', 'casenum']) case = Case.new(num=server_settings['casenum'], type_='unban', user=user.id, username=str(user), reason="Unknown reason") await self.post_action(server, server_settings, case, no_msg=True) async def on_member_update(self, before, after): if before.server.id in self.no_ban_logs: return role = discord.utils.get(before.server.roles, id=MUTED_ROLE) if role not in before.roles and role in after.roles: # just muted server_settings = await self.get_server_settings(before.server.id, ['cases', 'casenum']) case = Case.new(num=server_settings['casenum'], type_='mute', user=after.id, username=str(after), reason="Unknown reason") elif role in before.roles and role not in after.roles: # just unmuted server_settings = await self.get_server_settings(before.server.id, ['cases', 'casenum']) case = Case.new(num=server_settings['casenum'], type_='unmute', user=after.id, username=str(after), reason="Unknown reason") else: return await self.post_action(before.server, server_settings, case, no_msg=True) async def get_server_settings(self, server_id, projection=None): server_settings = await self.bot.mdb.mod.find_one({"server": server_id}, projection) if server_settings is None: server_settings = get_default_settings(server_id) return server_settings async def set_server_settings(self, server_id, settings): await self.bot.mdb.mod.update_one( {"server": server_id}, {"$set": settings}, upsert=True ) def get_default_settings(server): return { "server": server, "raidmode": None, "cases": [], "casenum": 1, "forcebanned": [], "locked_channels": [] } class Case: def __init__(self, num, type_, user, reason, mod=None, log_msg=None, username=None): self.num = num self.type = type_ self.user = user self.username = username self.reason = reason self.mod = mod self.log_msg = log_msg @classmethod def new(cls, num, type_, user, reason, mod=None, username=None): return cls(num, type_, user, reason, mod=mod, username=username) @classmethod def from_dict(cls, raw): raw['type_'] = raw.pop('type') return cls(**raw) def to_dict(self): return {"num": self.num, "type": self.type, "user": self.user, "reason": self.reason, "mod": self.mod, "log_msg": self.log_msg, "username": self.username} def __str__(self): if self.username: user = f"{self.username} ({self.user})" else: user = self.user if self.mod: modstr = self.mod else: modstr = f"Responsible moderator, do `.reason {self.num} <reason>`" return f'**{self.type.title()}** | Case {self.num}\n' \ f'**User**: {user}\n' \ f'**Reason**: {self.reason}\n' \ f'**Responsible Mod**: {modstr}' def setup(bot): bot.add_cog(Moderation(bot))
2.390625
2
custom_components/tibber_custom/__init__.py
niklasosth/home_assistant_tibber_custom
0
12788802
"""Tibber custom""" import logging import homeassistant.helpers.config_validation as cv import voluptuous as vol from homeassistant.const import EVENT_HOMEASSISTANT_START from homeassistant.helpers import discovery DOMAIN = "tibber_custom" CONF_USE_DARK_MODE = "use_dark_mode" CONFIG_SCHEMA = vol.Schema({ DOMAIN: vol.Schema({ vol.Optional(CONF_USE_DARK_MODE, default=False): cv.boolean, }) }, extra=vol.ALLOW_EXTRA) DEPENDENCIES = ["tibber"] _LOGGER = logging.getLogger(__name__) def setup(hass, config): """Setup component.""" use_dark_mode = config[DOMAIN][CONF_USE_DARK_MODE] def ha_started(_): discovery.load_platform(hass, "camera", DOMAIN, {}, config) hass.bus.listen_once(EVENT_HOMEASSISTANT_START, ha_started) return True
2.09375
2
lab-day/LabDayBackend/labday_api/apps.py
JanStoltman/LabDayBackend
1
12788803
from django.apps import AppConfig class LabdayApiConfig(AppConfig): name = 'labday_api'
1.078125
1
examples/tests/test_examples.py
avanwyk/cipy
1
12788804
<filename>examples/tests/test_examples.py # Copyright 2016 <NAME> # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # 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. """ Tests ensuring examples execute """ import pytest from examples import example from examples.gbest_pso import main as gbest from examples.gc_pso import main as gc from examples.lbest_pso import main as lbest from examples.pso_optimizer import main as pso_optimizer @pytest.mark.parametrize("dimension", [ 1, 30 ]) @pytest.mark.parametrize("iterations", [ 3 ]) @example def test_gbest_pso(dimension, iterations): gbest(dimension, iterations) @pytest.mark.parametrize("dimension", [ 1, 30 ]) @pytest.mark.parametrize("iterations", [ 3 ]) @example def test_lbest_pso(dimension, iterations): lbest(dimension, iterations) @pytest.mark.parametrize("dimension", [ 1, 30 ]) @pytest.mark.parametrize("iterations", [ 3 ]) @example def test_gc_pso(dimension, iterations): gc(dimension, iterations) @pytest.mark.parametrize("dimension", [ 1, 30 ]) @pytest.mark.parametrize("iterations", [ 3 ]) @example def test_optimizer(dimension, iterations): pso_optimizer(dimension, iterations)
2.109375
2
msg/apps.py
trym-inc/django-msg
7
12788805
<filename>msg/apps.py from django.apps import AppConfig class MsgConfig(AppConfig): name = 'msg' def ready(self): # Make sure that handlers are registered when django is ready from .settings import msg_settings msg_settings.import_setting('handlers')
1.835938
2
sdk/python/pulumi_aws/ec2/subnet_cidr_reservation.py
chivandikwa/pulumi-aws
0
12788806
# coding=utf-8 # *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** # *** Do not edit by hand unless you're certain you know what you are doing! *** import warnings import pulumi import pulumi.runtime from typing import Any, Mapping, Optional, Sequence, Union, overload from .. import _utilities __all__ = ['SubnetCidrReservationArgs', 'SubnetCidrReservation'] @pulumi.input_type class SubnetCidrReservationArgs: def __init__(__self__, *, cidr_block: pulumi.Input[str], reservation_type: pulumi.Input[str], subnet_id: pulumi.Input[str], description: Optional[pulumi.Input[str]] = None): """ The set of arguments for constructing a SubnetCidrReservation resource. :param pulumi.Input[str] cidr_block: The CIDR block for the reservation. :param pulumi.Input[str] reservation_type: The type of reservation to create. Valid values: `explicit`, `prefix` :param pulumi.Input[str] subnet_id: The ID of the subnet to create the reservation for. :param pulumi.Input[str] description: A brief description of the reservation. """ pulumi.set(__self__, "cidr_block", cidr_block) pulumi.set(__self__, "reservation_type", reservation_type) pulumi.set(__self__, "subnet_id", subnet_id) if description is not None: pulumi.set(__self__, "description", description) @property @pulumi.getter(name="cidrBlock") def cidr_block(self) -> pulumi.Input[str]: """ The CIDR block for the reservation. """ return pulumi.get(self, "cidr_block") @cidr_block.setter def cidr_block(self, value: pulumi.Input[str]): pulumi.set(self, "cidr_block", value) @property @pulumi.getter(name="reservationType") def reservation_type(self) -> pulumi.Input[str]: """ The type of reservation to create. Valid values: `explicit`, `prefix` """ return pulumi.get(self, "reservation_type") @reservation_type.setter def reservation_type(self, value: pulumi.Input[str]): pulumi.set(self, "reservation_type", value) @property @pulumi.getter(name="subnetId") def subnet_id(self) -> pulumi.Input[str]: """ The ID of the subnet to create the reservation for. """ return pulumi.get(self, "subnet_id") @subnet_id.setter def subnet_id(self, value: pulumi.Input[str]): pulumi.set(self, "subnet_id", value) @property @pulumi.getter def description(self) -> Optional[pulumi.Input[str]]: """ A brief description of the reservation. """ return pulumi.get(self, "description") @description.setter def description(self, value: Optional[pulumi.Input[str]]): pulumi.set(self, "description", value) @pulumi.input_type class _SubnetCidrReservationState: def __init__(__self__, *, cidr_block: Optional[pulumi.Input[str]] = None, description: Optional[pulumi.Input[str]] = None, owner_id: Optional[pulumi.Input[str]] = None, reservation_type: Optional[pulumi.Input[str]] = None, subnet_id: Optional[pulumi.Input[str]] = None): """ Input properties used for looking up and filtering SubnetCidrReservation resources. :param pulumi.Input[str] cidr_block: The CIDR block for the reservation. :param pulumi.Input[str] description: A brief description of the reservation. :param pulumi.Input[str] owner_id: ID of the AWS account that owns this CIDR reservation. :param pulumi.Input[str] reservation_type: The type of reservation to create. Valid values: `explicit`, `prefix` :param pulumi.Input[str] subnet_id: The ID of the subnet to create the reservation for. """ if cidr_block is not None: pulumi.set(__self__, "cidr_block", cidr_block) if description is not None: pulumi.set(__self__, "description", description) if owner_id is not None: pulumi.set(__self__, "owner_id", owner_id) if reservation_type is not None: pulumi.set(__self__, "reservation_type", reservation_type) if subnet_id is not None: pulumi.set(__self__, "subnet_id", subnet_id) @property @pulumi.getter(name="cidrBlock") def cidr_block(self) -> Optional[pulumi.Input[str]]: """ The CIDR block for the reservation. """ return pulumi.get(self, "cidr_block") @cidr_block.setter def cidr_block(self, value: Optional[pulumi.Input[str]]): pulumi.set(self, "cidr_block", value) @property @pulumi.getter def description(self) -> Optional[pulumi.Input[str]]: """ A brief description of the reservation. """ return pulumi.get(self, "description") @description.setter def description(self, value: Optional[pulumi.Input[str]]): pulumi.set(self, "description", value) @property @pulumi.getter(name="ownerId") def owner_id(self) -> Optional[pulumi.Input[str]]: """ ID of the AWS account that owns this CIDR reservation. """ return pulumi.get(self, "owner_id") @owner_id.setter def owner_id(self, value: Optional[pulumi.Input[str]]): pulumi.set(self, "owner_id", value) @property @pulumi.getter(name="reservationType") def reservation_type(self) -> Optional[pulumi.Input[str]]: """ The type of reservation to create. Valid values: `explicit`, `prefix` """ return pulumi.get(self, "reservation_type") @reservation_type.setter def reservation_type(self, value: Optional[pulumi.Input[str]]): pulumi.set(self, "reservation_type", value) @property @pulumi.getter(name="subnetId") def subnet_id(self) -> Optional[pulumi.Input[str]]: """ The ID of the subnet to create the reservation for. """ return pulumi.get(self, "subnet_id") @subnet_id.setter def subnet_id(self, value: Optional[pulumi.Input[str]]): pulumi.set(self, "subnet_id", value) class SubnetCidrReservation(pulumi.CustomResource): @overload def __init__(__self__, resource_name: str, opts: Optional[pulumi.ResourceOptions] = None, cidr_block: Optional[pulumi.Input[str]] = None, description: Optional[pulumi.Input[str]] = None, reservation_type: Optional[pulumi.Input[str]] = None, subnet_id: Optional[pulumi.Input[str]] = None, __props__=None): """ Provides a subnet CIDR reservation resource. ## Example Usage ```python import pulumi import pulumi_aws as aws example = aws.ec2.SubnetCidrReservation("example", cidr_block="10.0.0.16/28", reservation_type="prefix", subnet_id=aws_subnet["example"]["id"]) ``` ## Import Existing CIDR reservations can be imported using `SUBNET_ID:RESERVATION_ID`, e.g., ```sh $ pulumi import aws:ec2/subnetCidrReservation:SubnetCidrReservation example subnet-01llsxvsxabqiymcz:scr-4mnvz6wb7otksjcs9 ``` :param str resource_name: The name of the resource. :param pulumi.ResourceOptions opts: Options for the resource. :param pulumi.Input[str] cidr_block: The CIDR block for the reservation. :param pulumi.Input[str] description: A brief description of the reservation. :param pulumi.Input[str] reservation_type: The type of reservation to create. Valid values: `explicit`, `prefix` :param pulumi.Input[str] subnet_id: The ID of the subnet to create the reservation for. """ ... @overload def __init__(__self__, resource_name: str, args: SubnetCidrReservationArgs, opts: Optional[pulumi.ResourceOptions] = None): """ Provides a subnet CIDR reservation resource. ## Example Usage ```python import pulumi import pulumi_aws as aws example = aws.ec2.SubnetCidrReservation("example", cidr_block="10.0.0.16/28", reservation_type="prefix", subnet_id=aws_subnet["example"]["id"]) ``` ## Import Existing CIDR reservations can be imported using `SUBNET_ID:RESERVATION_ID`, e.g., ```sh $ pulumi import aws:ec2/subnetCidrReservation:SubnetCidrReservation example subnet-01llsxvsxabqiymcz:scr-4mnvz6wb7otksjcs9 ``` :param str resource_name: The name of the resource. :param SubnetCidrReservationArgs args: The arguments to use to populate this resource's properties. :param pulumi.ResourceOptions opts: Options for the resource. """ ... def __init__(__self__, resource_name: str, *args, **kwargs): resource_args, opts = _utilities.get_resource_args_opts(SubnetCidrReservationArgs, pulumi.ResourceOptions, *args, **kwargs) if resource_args is not None: __self__._internal_init(resource_name, opts, **resource_args.__dict__) else: __self__._internal_init(resource_name, *args, **kwargs) def _internal_init(__self__, resource_name: str, opts: Optional[pulumi.ResourceOptions] = None, cidr_block: Optional[pulumi.Input[str]] = None, description: Optional[pulumi.Input[str]] = None, reservation_type: Optional[pulumi.Input[str]] = None, subnet_id: Optional[pulumi.Input[str]] = None, __props__=None): if opts is None: opts = pulumi.ResourceOptions() if not isinstance(opts, pulumi.ResourceOptions): raise TypeError('Expected resource options to be a ResourceOptions instance') if opts.version is None: opts.version = _utilities.get_version() if opts.id is None: if __props__ is not None: raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') __props__ = SubnetCidrReservationArgs.__new__(SubnetCidrReservationArgs) if cidr_block is None and not opts.urn: raise TypeError("Missing required property 'cidr_block'") __props__.__dict__["cidr_block"] = cidr_block __props__.__dict__["description"] = description if reservation_type is None and not opts.urn: raise TypeError("Missing required property 'reservation_type'") __props__.__dict__["reservation_type"] = reservation_type if subnet_id is None and not opts.urn: raise TypeError("Missing required property 'subnet_id'") __props__.__dict__["subnet_id"] = subnet_id __props__.__dict__["owner_id"] = None super(SubnetCidrReservation, __self__).__init__( 'aws:ec2/subnetCidrReservation:SubnetCidrReservation', resource_name, __props__, opts) @staticmethod def get(resource_name: str, id: pulumi.Input[str], opts: Optional[pulumi.ResourceOptions] = None, cidr_block: Optional[pulumi.Input[str]] = None, description: Optional[pulumi.Input[str]] = None, owner_id: Optional[pulumi.Input[str]] = None, reservation_type: Optional[pulumi.Input[str]] = None, subnet_id: Optional[pulumi.Input[str]] = None) -> 'SubnetCidrReservation': """ Get an existing SubnetCidrReservation resource's state with the given name, id, and optional extra properties used to qualify the lookup. :param str resource_name: The unique name of the resulting resource. :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. :param pulumi.ResourceOptions opts: Options for the resource. :param pulumi.Input[str] cidr_block: The CIDR block for the reservation. :param pulumi.Input[str] description: A brief description of the reservation. :param pulumi.Input[str] owner_id: ID of the AWS account that owns this CIDR reservation. :param pulumi.Input[str] reservation_type: The type of reservation to create. Valid values: `explicit`, `prefix` :param pulumi.Input[str] subnet_id: The ID of the subnet to create the reservation for. """ opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) __props__ = _SubnetCidrReservationState.__new__(_SubnetCidrReservationState) __props__.__dict__["cidr_block"] = cidr_block __props__.__dict__["description"] = description __props__.__dict__["owner_id"] = owner_id __props__.__dict__["reservation_type"] = reservation_type __props__.__dict__["subnet_id"] = subnet_id return SubnetCidrReservation(resource_name, opts=opts, __props__=__props__) @property @pulumi.getter(name="cidrBlock") def cidr_block(self) -> pulumi.Output[str]: """ The CIDR block for the reservation. """ return pulumi.get(self, "cidr_block") @property @pulumi.getter def description(self) -> pulumi.Output[Optional[str]]: """ A brief description of the reservation. """ return pulumi.get(self, "description") @property @pulumi.getter(name="ownerId") def owner_id(self) -> pulumi.Output[str]: """ ID of the AWS account that owns this CIDR reservation. """ return pulumi.get(self, "owner_id") @property @pulumi.getter(name="reservationType") def reservation_type(self) -> pulumi.Output[str]: """ The type of reservation to create. Valid values: `explicit`, `prefix` """ return pulumi.get(self, "reservation_type") @property @pulumi.getter(name="subnetId") def subnet_id(self) -> pulumi.Output[str]: """ The ID of the subnet to create the reservation for. """ return pulumi.get(self, "subnet_id")
2.203125
2
complier-for-retards.py
bossjaylen145/trojan
1
12788807
import os def complier(): print("If ur using this ur so dumb on god just read the install instructions!\n" "PLEASE HAVE THE requirements.txt FILE IN THE SAME DIRECTORY!!!!") os.system("pip install -r requirements.txt") def cleanup(): cmds = ["RD __pycache__ /Q /S", "RD build /Q /S", "DEL trojan.spec /Q"] for commands in cmds: os.system(commands) logo = input("Use custom icon (Y/N) ") args = "pyinstaller --onefile --windowed" if logo.lower() == "y": try: logo_name = input("Input name of logo (must be .ico) ") args += f" --icon={os.getcwd()}{logo_name} trojan.py" print(f"Using args: {args}") os.system(args) cleanup() except Exception as e: print(e) cleanup() os.system("pause") if logo.lower() == "n": try: os.system("pyinstaller --onefile --windowed trojan.py") print(f"Using args: {args}") cleanup() except Exception as e: print(e) cleanup() os.system("pause") complier()
2.984375
3
examples/LSTM_classification.py
xhpxiaohaipeng/xhp_flow_frame
2
12788808
<filename>examples/LSTM_classification.py import os from xhp_flow.nn.node import Placeholder,Linear,Sigmoid,ReLu,Leakrelu,Elu,Tanh,LSTM from xhp_flow.optimize.optimize import toplogical_sort,run_steps,forward,save_model,load_model,Auto_update_lr,Visual_gradient,Grad_Clipping_Disappearance,SUW,\ SGD,\ Momentum,\ Adagrad,\ RMSProp,\ AdaDelta,\ Adam,\ AdaMax,\ Nadam,\ NadaMax from xhp_flow.loss.loss import MSE,EntropyCrossLossWithSoftmax import matplotlib.pyplot as plt os.environ['CUDA_LAUNCH_BLOCKING'] = "1" def labeltoint(label): if label == 'left': label = 0 if label == 'keep': label = 1 if label == 'right': label = 2 return label import json import numpy as np with open('data1/train.json', 'r') as f: j = json.load(f) # print(j.keys()) X_train = j['states'] Y_train = j['labels'] for i in range(len(Y_train)): Y_train[i] = labeltoint(Y_train[i]) # print(Y_train) with open('data1/test.json', 'r') as f: j = json.load(f) X_test = j['states'] Y_test = j['labels'] for i in range(len(Y_test)): Y_test[i] = labeltoint(Y_test[i]) split_frac = 0.8 X_train, Y_train, X_test, Y_test = np.array(X_train).astype(np.float32), np.array(Y_train).astype(np.long), np.array( X_test).astype(np.float32), np.array(Y_test).astype(np.long) ## split data into training, validation, and test data (features and labels, x and y) val_x, test_x = X_test[:len(X_test) // 2], X_test[len(X_test) // 2:] val_y, test_y = Y_test[:len(Y_test) // 2], Y_test[len(Y_test) // 2:] import torch from torch.utils.data import TensorDataset, DataLoader # create Tensor datasets train_data = TensorDataset(torch.from_numpy((X_train)), torch.from_numpy(Y_train)) valid_data = TensorDataset(torch.from_numpy(val_x), torch.from_numpy(val_y)) test_data = TensorDataset(torch.from_numpy(test_x), torch.from_numpy(test_y)) # dataloaders batch_size = 64 # make sure to SHUFFLE your data train_loader = DataLoader(train_data, shuffle=True, batch_size=batch_size) valid_loader = DataLoader(valid_data, shuffle=True, batch_size=batch_size) test_loader = DataLoader(test_data, shuffle=True, batch_size=batch_size) x1, y = next(iter(train_loader)) input_x, y = x1.numpy(), y.numpy() class LSTM_classfy(): def __init__(self, input_size=1, hidden_size=16, output_size=3): self.x, self.y = Placeholder(name='x', is_trainable=False), Placeholder(name='y', is_trainable=False) self.wf, self.bf = Placeholder(name='wf'), Placeholder(name='bf') self.wi, self.bi = Placeholder(name='wi'), Placeholder(name='bi') self.wc, self.bc = Placeholder(name='wc'), Placeholder(name='bc') self.wo, self.bo = Placeholder(name='wo'), Placeholder(name='bo') #self.w0, self.b0 = Placeholder(name='w0'), Placeholder(name='b0') self.w1, self.b1 = Placeholder(name='w1'), Placeholder(name='b1') self.w2, self.b2 = Placeholder(name='w2'), Placeholder(name='b2') #self.linear0 = Linear(self.x, self.w0, self.b0, name='linear0') self.lstm = LSTM(self.x, self.wf, self.wi, self.wc, self.wo, self.bf, self.bi, self.bc, self.bo, input_size, hidden_size, name='LSTM') self.linear1 = Linear(self.lstm, self.w1, self.b1, name='linear1') #self.output = Tanh(self.linear1, name='Relu') self.y_pre = Linear(self.linear1, self.w2, self.b2, name='output_pre') self.cross_loss = EntropyCrossLossWithSoftmax(self.y_pre, self.y,0.01, name='Cross_Loss') # 初始化数据结构 self.feed_dict = { self.x: input_x, self.y: y, # self.w0: np.random.rand(4, input_size), #self.b0: np.zeros(input_size), self.wf: np.random.rand(input_size + hidden_size, hidden_size), self.bf: np.zeros(hidden_size), self.wi: np.random.rand(input_size + hidden_size, hidden_size), self.bi: np.zeros(hidden_size), self.wc: np.random.rand(input_size + hidden_size, hidden_size), self.bc: np.zeros(hidden_size), self.wo: np.random.rand(input_size + hidden_size, hidden_size), self.bo: np.zeros(hidden_size), self.w1: np.random.rand(hidden_size, hidden_size), self.b1: np.zeros(hidden_size), self.w2: np.random.rand(hidden_size, output_size), self.b2: np.zeros(output_size), } #graph_mlp_class = convert_feed_dict_graph(mlp_class.feed_dict) #print(graph_sort_class) def train(model,train_data,epoch = 4000,learning_rate = 0.0128): #开始训练 accuracies = [] losses = [] losses_valid = [] accuracies_valid = [] loss_min = np.inf graph_sort_class = toplogical_sort(model.feed_dict) # 拓扑排序 optim = Adam(graph_sort_class) update_lr = Auto_update_lr(lr=learning_rate,alpha=0.1, patiences=200, print_=True) for e in range(epoch): for X,Y in train_data: X,Y = X.unsqueeze(1).numpy(),Y.numpy() model.x.value = X model.y.value = Y run_steps(graph_sort_class) learning_rate = update_lr.lr optim.update(learning_rate=learning_rate) Visual_gradient(model) Grad_Clipping_Disappearance(model, 5) loss = model.cross_loss.value accuracy = model.cross_loss.accuracy losses.append(loss) accuracies.append(accuracy*100) for x,y in valid_loader: x,y = x.unsqueeze(1).numpy(),y.numpy() model.x.value = x model.y.value = y run_steps(graph_sort_class,train=False,valid=True) loss_valid = model.cross_loss.value accuracy_valid = model.cross_loss.accuracy losses_valid.append(loss_valid) accuracies_valid.append(accuracy_valid*100) update_lr.updata(np.mean(losses_valid)) print("epoch:{}/{},train loss:{:.8f},train accuracy:{:.6f}%,valid loss:{:.8f},valid accuracy:{:.6f}%". format(e,epoch,np.mean(losses),np.mean(accuracies),np.mean(losses_valid),np.mean(accuracies_valid))) if np.mean(losses_valid) < loss_min: print('loss is {:.6f}, is decreasing!! save moddel'.format(np.mean(losses_valid))) save_model("model/lstm_class.xhp",model) loss_min = np.mean(losses_valid) #save_model("lstm_class.xhp",model) plt.plot(losses) plt.savefig("image/lstm_class_loss.png") plt.show() lstm_class = LSTM_classfy(4,16,3) load_model('model/lstm_class.xhp',lstm_class) train(lstm_class,train_loader,50000,0.00128) def predict(x,model): graph = toplogical_sort(model.feed_dict) model.x.value = x run_steps(graph,train=False,valid=False) y = graph[-2].value result = np.argmax(y,axis=1) return result x1,y = next(iter(train_loader)) input_x,y = x1.numpy(),y.numpy() load_model('model/lstm_class.xhp',lstm_class) classs = predict(input_x[0][None,None,:],lstm_class) print(classs,y[0]) def evaluator(test_loader,model): graph = toplogical_sort(model.feed_dict) accuracies = [] losses = [] for x, y in test_loader: x, y = x.unsqueeze(1).numpy(), y.numpy() model.x.value = x model.y.value = y run_steps(graph, train=False, valid=True) loss_test = model.cross_loss.value accuracy_test = model.cross_loss.accuracy losses.append(loss_test) accuracies.append(accuracy_test) print("test loss:{},test accuracy:{}".format(np.mean(losses),np.mean(accuracies))) evaluator(test_loader,lstm_class)
2.640625
3
astro_fixer.py
boada/scripts
0
12788809
import subprocess import os def hms2decimal(RAString, delimiter): """Converts a delimited string of Hours:Minutes:Seconds format into decimal degrees. @type RAString: string @param RAString: coordinate string in H:M:S format @type delimiter: string @param delimiter: delimiter character in RAString @rtype: float @return: coordinate in decimal degrees """ # is it in HH:MM:SS format? if delimiter == "": RABits = str(RAString).split() else: RABits = str(RAString).split(delimiter) if len(RABits) > 1: RAHDecimal = float(RABits[0]) if len(RABits) > 1: RAHDecimal = RAHDecimal+(float(RABits[1])/60.0) if len(RABits) > 2: RAHDecimal = RAHDecimal+(float(RABits[2])/3600.0) RADeg = (RAHDecimal/24.0)*360.0 else: RADeg = float(RAString) return RADeg def dms2decimal(decString, delimiter): """Converts a delimited string of Degrees:Minutes:Seconds format into decimal degrees. @type decString: string @param decString: coordinate string in D:M:S format @type delimiter: string @param delimiter: delimiter character in decString @rtype: float @return: coordinate in decimal degrees """ # is it in DD:MM:SS format? if delimiter == "": decBits = str(decString).split() else: decBits = str(decString).split(delimiter) if len(decBits) > 1: decDeg = float(decBits[0]) if decBits[0].find("-") != -1: if len(decBits) > 1: decDeg = decDeg-(float(decBits[1])/60.0) if len(decBits) > 2: decDeg = decDeg-(float(decBits[2])/3600.0) else: if len(decBits) > 1: decDeg = decDeg+(float(decBits[1])/60.0) if len(decBits) > 2: decDeg = decDeg+(float(decBits[2])/3600.0) else: decDeg = float(decString) return decDeg def decimal2hms(RADeg, delimiter): """Converts decimal degrees to string in Hours:Minutes:Seconds format with user specified delimiter. @type RADeg: float @param RADeg: coordinate in decimal degrees @type delimiter: string @param delimiter: delimiter character in returned string @rtype: string @return: coordinate string in H:M:S format """ hours = (RADeg/360.0)*24 #if hours < 10 and hours >= 1: if 1 <= hours < 10: sHours = "0"+str(hours)[0] elif hours >= 10: sHours = str(hours)[:2] elif hours < 1: sHours = "00" if str(hours).find(".") == -1: mins = float(hours)*60.0 else: mins = float(str(hours)[str(hours).index("."):])*60.0 #if mins<10 and mins>=1: if 1 <= mins<10: sMins = "0"+str(mins)[:1] elif mins >= 10: sMins = str(mins)[:2] elif mins < 1: sMins = "00" secs = (hours-(float(sHours)+float(sMins)/60.0))*3600.0 #if secs < 10 and secs>0.001: if 0.001 < secs < 10: sSecs = "0"+str(secs)[:str(secs).find(".")+4] elif secs < 0.0001: sSecs = "00.001" else: sSecs = str(secs)[:str(secs).find(".")+4] if len(sSecs) < 5: sSecs = sSecs+"00" # So all to 3dp if float(sSecs) == 60.000: sSecs = "00.00" sMins = str(int(sMins)+1) if int(sMins) == 60: sMins = "00" sDeg = str(int(sDeg)+1) return sHours+delimiter+sMins+delimiter+sSecs def decimal2dms(decDeg, delimiter): """Converts decimal degrees to string in Degrees:Minutes:Seconds format with user specified delimiter. @type decDeg: float @param decDeg: coordinate in decimal degrees @type delimiter: string @param delimiter: delimiter character in returned string @rtype: string @return: coordinate string in D:M:S format """ # Positive if decDeg > 0: #if decDeg < 10 and decDeg>=1: if 1 <= decDeg < 10: sDeg = "0"+str(decDeg)[0] elif decDeg >= 10: sDeg = str(decDeg)[:2] elif decDeg < 1: sDeg = "00" if str(decDeg).find(".") == -1: mins = float(decDeg)*60.0 else: mins = float(str(decDeg)[str(decDeg).index("."):])*60 #if mins<10 and mins>=1: if 1 <= mins < 10: sMins = "0"+str(mins)[:1] elif mins >= 10: sMins = str(mins)[:2] elif mins < 1: sMins = "00" secs = (decDeg-(float(sDeg)+float(sMins)/60.0))*3600.0 #if secs<10 and secs>0: if 0 < secs < 10: sSecs = "0"+str(secs)[:str(secs).find(".")+3] elif secs < 0.001: sSecs = "00.00" else: sSecs = str(secs)[:str(secs).find(".")+3] if len(sSecs) < 5: sSecs = sSecs+"0" # So all to 2dp if float(sSecs) == 60.00: sSecs = "00.00" sMins = str(int(sMins)+1) if int(sMins) == 60: sMins = "00" sDeg = str(int(sDeg)+1) return "+"+sDeg+delimiter+sMins+delimiter+sSecs else: #if decDeg>-10 and decDeg<=-1: if -10 < decDeg <= -1: sDeg = "-0"+str(decDeg)[1] elif decDeg <= -10: sDeg = str(decDeg)[:3] elif decDeg > -1: sDeg = "-00" if str(decDeg).find(".") == -1: mins = float(decDeg)*-60.0 else: mins = float(str(decDeg)[str(decDeg).index("."):])*60 #if mins<10 and mins>=1: if 1 <= mins < 10: sMins = "0"+str(mins)[:1] elif mins >= 10: sMins = str(mins)[:2] elif mins < 1: sMins = "00" secs = (decDeg-(float(sDeg)-float(sMins)/60.0))*3600.0 #if secs>-10 and secs<0: # so don't get minus sign if -10 < secs < 0: sSecs = "0"+str(secs)[1:str(secs).find(".")+3] elif secs > -0.001: sSecs = "00.00" else: sSecs = str(secs)[1:str(secs).find(".")+3] if len(sSecs) < 5: sSecs = sSecs+"0" # So all to 2dp if float(sSecs) == 60.00: sSecs = "00.00" sMins = str(int(sMins)+1) if int(sMins) == 60: sMins = "00" sDeg = str(int(sDeg)-1) return sDeg+delimiter+sMins+delimiter+sSecs def shiftRADec(ra1, dec1, deltaRA, deltaDec): """Computes new right ascension and declination shifted from the original by some delta RA and delta DEC. Input position is decimal degrees. Shifts (deltaRA, deltaDec) are arcseconds, and output is decimal degrees. Based on an IDL routine of the same name. @param ra1: float @type ra1: R.A. in decimal degrees @param dec1: float @type dec1: dec. in decimal degrees @param deltaRA: float @type deltaRA: shift in R.A. in arcseconds @param deltaDec: float @type deltaDec: shift in dec. in arcseconds @rtype: float [newRA, newDec] @return: shifted R.A. and dec. """ d2r = math.pi/180. as2r = math.pi/648000. # Convert everything to radians #rara1 = ra1*d2r dcrad1 = dec1*d2r shiftRArad = deltaRA*as2r shiftDCrad = deltaDec*as2r # Shift! #deldec2 = 0.0 sindis = math.sin(shiftRArad / 2.0) sindelRA = sindis / math.cos(dcrad1) delra = 2.0*math.asin(sindelRA) / d2r # Make changes ra2 = ra1+delra dec2 = dec1 + deltaDec / 3600.0 return ra2, dec2 pixelsize = 0.523 tol = 0.5 print('Enter the name of the target: ') name = str(raw_input()) print('Enter the RA of target (HH:MM:SS): ') RA = str(raw_input()) print('Enter the DEC of target (DD:MM:SS): ') DEC = str(raw_input()) print('Now enter x-fiducial coordinate: ') xf = raw_input() print('Now enter y-fiducial coordinate: ') yf = raw_input() print('Here we go!') i =1 while True: print('Try %d' % (i)) command = './find_gen.csh '+RA+' '+DEC+' '+name process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE) process.wait() print('Enter NEW x-fiducial coordinate: ') xfnew = raw_input print('Enter NEW y-fiducial coordinate: ') yfnew = raw_input deltaxf = float(xf) - float(xfnew) deltayf = float(yf) - float(yfnew) deltaDEC = deltayf * pixelsize deltaRA = deltaxf * pixelsize ra = hms2decimal(RA, ':') dec = dms2decimal(DEC, ':') if abs(deltaxf) < tol and abs(deltayf) < tol: break if abs(deltaxf) > tol: deltaRA = -1 * deltaRA else: deltaRA = 0 if abs(deltayf) > tol: deltaDEC = -1 * deltaRA else: deltaDEC = 0 # New RA and DEC RA, DEC = shiftRADec(ra, dec, deltaRA, deltaDEC) # Convert back to Sexigesimal RA = decimal2hms(RA, ':') DEC = decimal2dms(DEC, ':') print deltaRA, deltaDEC print('New RA %s' %(RA)) print('New DEC %s' %(DEC)) i+=1 print('Now close the finder software') time.sleep(10)
3.34375
3
BlogProject/urls.py
JinitSan/Blog-App
0
12788810
<reponame>JinitSan/Blog-App """BlogProject URL Configuration The `urlpatterns` list routes URLs to views. For more information please see: https://docs.djangoproject.com/en/3.0/topics/http/urls/ Examples: Function views 1. Add an import: from my_app import views 2. Add a URL to urlpatterns: path('', views.home, name='home') Class-based views 1. Add an import: from other_app.views import Home 2. Add a URL to urlpatterns: path('', Home.as_view(), name='home') Including another URLconf 1. Import the include() function: from django.urls import include, path 2. Add a URL to urlpatterns: path('blog/', include('blog.urls')) """ from django.contrib import admin from django.contrib.auth import views as auth_views from django.urls import path, include from django.conf import settings from django.conf.urls.static import static from users import views as users_views # redirects from our main project to apps urlpatterns = [ # make the blog app the default/home path('', include('blog.urls')), # second approach to redirect directly to the view instead of # doing it via the urls.py of the app (as done above) # so the alias is named here itself path('register/', users_views.register, name='register'), path('profile/', users_views.profile, name='profile'), # use Django's built-in views, but they need templates # as they only handle the backend logic path('login/', auth_views.LoginView.as_view(template_name='users/login.html'), name='login'), path('logout/', auth_views.LogoutView.as_view(template_name='users/logout.html'), name='logout'), path('admin/', admin.site.urls), ] if settings.DEBUG: # tell Django to use specified url in case of using user uploaded media urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)
2.953125
3
basiccomfundamental/List2.py
KApilBD/python
0
12788811
<filename>basiccomfundamental/List2.py aList = [0,1,2,3,4,5] bList = aList aList[2] = 'hello' print(aList == bList) print(aList is bList) print(aList) print(bList) cList = [6,5,4,3,2] dList = [] for num in cList: dList.append(num) print(cList == dList) #validate the contain only print(cList is dList) #validate address cList[2] = 20 print(cList) print(dList)
3.828125
4
python/backup.py
R-Varun/Sentimeter
0
12788812
<reponame>R-Varun/Sentimeter<gh_stars>0 import sys import json import parse import contextsummary import SentimentAnalysis data = parse.parseInput(sys.argv[1]) #data = input.readBody() input = data[0] granularity = data[2] begin = int(granularity[0]) end = int(granularity[1]) stride = data[3] if begin is -1 or end is -1: begin = 0 end = len(input) elif begin < 0 or end > len(input): print(json.dumps({"ERROR":"invalid granularity"})) quit() end = min(end, len(input)) contextList = [] sentimentList = [] topicList = {} conversationSentiment = {} if stride < 1: stride = 1 if stride is None: stride = len(input) counter = 0 cur = begin all_topics = {} cumulative = [] # print("STRIDE:",stride) for i in range( (end - begin) // stride): for sentence in input[cur: cur + stride]: if "utterance" not in sentence: continue taggedSentences = contextsummary.posTag(sentence["utterance"]) speaker = sentence["speaker"] #context topic = contextsummary.sentenctExtract(taggedSentences) for top in topic: if top in topicList: topicList[top] += 1 # all_topics[top] += 1 else: topicList[top] = 1 # all_topics[top] = 1 if top in all_topics: all_topics[top] += 1 else: all_topics[top] = 1 # begin += stride cur += stride cumulative.append(sorted(topicList, key = lambda x : -1 * topicList[x])) topicList = {} """print(sortedTopics[:5]) for x in sortedTopics[:5]: print(topicList[x])""" print(json.dumps( {"timeline" : cumulative, "total" : sorted(all_topics, key = lambda x : -1 * all_topics[x]) }))
2.40625
2
multitest_transport/ui2/main.py
maksonlee/multitest_transport
0
12788813
# Copyright 2019 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # 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. """ATS UI flask server.""" import os import flask from multitest_transport.models import ndb_models from multitest_transport.util import env ROOT_PATH = os.path.dirname(__file__) STATIC_PATH = os.path.join(ROOT_PATH, 'static') APP = flask.Flask( __name__, root_path=ROOT_PATH, static_folder=None, template_folder=ROOT_PATH) @APP.route('/static/<path:path>') def Static(path): """Returns static files.""" return flask.send_from_directory(STATIC_PATH, path, conditional=False) @APP.route('/app.js') def App(): """Returns application script.""" script = 'dev_sources.concat.js' if env.IS_DEV_MODE else 'app.js' return flask.send_from_directory(ROOT_PATH, script, conditional=False) @APP.route('/', defaults={'_': ''}) @APP.route('/<path:_>') def Root(_): """Routes all other requests to index.html and angular.""" private_node_config = ndb_models.GetPrivateNodeConfig() analytics_tracking_id = '' if not env.IS_DEV_MODE and private_node_config.metrics_enabled: analytics_tracking_id = 'UA-140187490-1' return flask.render_template( 'index.html', analytics_tracking_id=analytics_tracking_id, env=env, private_node_config=private_node_config)
1.804688
2
flags-dest/train_with_globals.py
lambdaofgod/examples
9
12788814
learning_rate = 0.01 epochs = 10 print("Training for %i epochs with a learning rate of %f" % (epochs, learning_rate))
2.921875
3
app/migrations/0004_auto_20190110_1501.py
wusri66666/room_order
0
12788815
# -*- coding: utf-8 -*- # Generated by Django 1.11.7 on 2019-01-10 07:01 from __future__ import unicode_literals from django.db import migrations class Migration(migrations.Migration): dependencies = [ ('app', '0003_auto_20190110_1037'), ] operations = [ migrations.RenameModel( old_name='Meeting_room', new_name='MeetingRoom', ), migrations.RenameModel( old_name='Scheduled_record', new_name='ReserveRecord', ), ]
1.609375
2
fridge/Constituent/Constituent.py
ryanstwrt/FRIDGE
0
12788816
<filename>fridge/Constituent/Constituent.py import fridge.Material.Material as materialReader import fridge.utilities.mcnpCreatorFunctions as mcnpCF class Constituent(object): """Base class for creating an assembly constituent.""" def __init__(self, unit_info, void_percent=1.0): """Initializes the data for creating a constituent.""" self.universe = unit_info[0][0] self.cellNum = unit_info[0][1] self.surfaceNum = unit_info[0][2] self.materialXCLibrary = unit_info[0][4] self.position = unit_info[0][5] self.materialNum = unit_info[0][6] self.voidPercent = void_percent self.surfaceCard = '' self.cellCard = '' self.materialCard = '' self.material = None def get_material_card(self, material_name): """Creates the material for the given constituent and creates the material card.""" self.material = materialReader.Material() self.material.set_material(material_name) if self.voidPercent != 1.0: self.material.set_void(self.voidPercent) self.materialCard = mcnpCF.build_material_card(self.material, self.materialXCLibrary, self.materialNum) def make_component(self, unit_info): """Creates the component for the given constituent and creates the cell/surface cards.""" pass
2.8125
3
vsts/vsts/feed/v4_1/models/package_dependency.py
kenkuo/azure-devops-python-api
0
12788817
<reponame>kenkuo/azure-devops-python-api # -------------------------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. # -------------------------------------------------------------------------------------------- # Generated file, DO NOT EDIT # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------------------------- from msrest.serialization import Model class PackageDependency(Model): """PackageDependency. :param group: :type group: str :param package_name: :type package_name: str :param version_range: :type version_range: str """ _attribute_map = { 'group': {'key': 'group', 'type': 'str'}, 'package_name': {'key': 'packageName', 'type': 'str'}, 'version_range': {'key': 'versionRange', 'type': 'str'} } def __init__(self, group=None, package_name=None, version_range=None): super(PackageDependency, self).__init__() self.group = group self.package_name = package_name self.version_range = version_range
1.945313
2
cocrawler/fetcher.py
machawk1/cocrawler
0
12788818
''' async fetching of urls. Assumes robots checks have already been done. Supports server mocking; proxies are not yet implemented. Success returns response object and response bytes (which were already read in order to shake out all potential network-related exceptions.) Failure returns enough details for the caller to do something smart: 503, other 5xx, DNS fail, connect timeout, error between connect and full response, proxy failure. Plus an errorstring good enough for logging. ''' import time import traceback from collections import namedtuple import ssl import urllib import asyncio import logging import aiohttp from . import stats from . import config from . import content LOGGER = logging.getLogger(__name__) # these errors get printed deep in aiohttp but they also bubble up aiohttp_errors = { 'SSL handshake failed', 'SSL error errno:1 reason: CERTIFICATE_VERIFY_FAILED', 'SSL handshake failed on verifying the certificate', 'Fatal error on transport TCPTransport', 'Fatal error on SSL transport', 'SSL error errno:1 reason: UNKNOWN_PROTOCOL', 'Future exception was never retrieved', 'Unclosed connection', 'SSL error errno:1 reason: TLSV1_UNRECOGNIZED_NAME', 'SSL error errno:1 reason: SSLV3_ALERT_HANDSHAKE_FAILURE', 'SSL error errno:1 reason: TLSV1_ALERT_INTERNAL_ERROR', } class AsyncioSSLFilter(logging.Filter): def filter(self, record): if record.name == 'asyncio' and record.levelname == 'ERROR': msg = record.getMessage() for ae in aiohttp_errors: if msg.startswith(ae): return False return True def establish_filters(): f = AsyncioSSLFilter() logging.getLogger('asyncio').addFilter(f) # XXX should be a policy plugin # XXX cookie handling -- no way to have a cookie jar other than at session level # need to directly manipulate domain-level cookie jars to get cookies def apply_url_policies(url, crawler): headers = {} proxy = None mock_url = None mock_robots = None headers['User-Agent'] = crawler.ua test_host = config.read('Testing', 'TestHostmapAll') if test_host: headers['Host'] = url.urlsplit.netloc (scheme, netloc, path, query, fragment) = url.urlsplit netloc = test_host mock_url = urllib.parse.urlunsplit((scheme, netloc, path, query, fragment)) mock_robots = url.urlsplit.scheme + '://' + test_host + '/robots.txt' if crawler.prevent_compression: headers['Accept-Encoding'] = 'identity' else: headers['Accept-Encoding'] = content.get_accept_encoding() if crawler.upgrade_insecure_requests: headers['Upgrade-Insecure-Requests'] = '1' return headers, proxy, mock_url, mock_robots FetcherResponse = namedtuple('FetcherResponse', ['response', 'body_bytes', 'req_headers', 't_first_byte', 't_last_byte', 'is_truncated', 'last_exception']) async def fetch(url, session, headers=None, proxy=None, mock_url=None, allow_redirects=None, max_redirects=None, stats_prefix='', max_page_size=-1): if proxy: # pragma: no cover proxy = aiohttp.ProxyConnector(proxy=proxy) # XXX we need to preserve the existing connector config (see cocrawler.__init__ for conn_kwargs) # XXX we should rotate proxies every fetch in case some are borked # XXX use proxy history to decide not to use some raise ValueError('not yet implemented') last_exception = None is_truncated = False try: t0 = time.time() last_exception = None body_bytes = b'' blocks = [] left = max_page_size with stats.coroutine_state(stats_prefix+'fetcher fetching'): with stats.record_latency(stats_prefix+'fetcher fetching', url=url.url): response = await session.get(mock_url or url.url, allow_redirects=allow_redirects, max_redirects=max_redirects, headers=headers) # https://aiohttp.readthedocs.io/en/stable/tracing_reference.html # XXX should use tracing events to get t_first_byte t_first_byte = '{:.3f}'.format(time.time() - t0) while left > 0: block = await response.content.read(left) if not block: body_bytes = b''.join(blocks) break blocks.append(block) left -= len(block) else: body_bytes = b''.join(blocks) if not response.content.at_eof(): stats.stats_sum('fetch truncated length', 1) response.close() # this does interrupt the network transfer is_truncated = 'length' # testme WARC t_last_byte = '{:.3f}'.format(time.time() - t0) except asyncio.TimeoutError as e: stats.stats_sum('fetch timeout', 1) last_exception = 'TimeoutError' body_bytes = b''.join(blocks) if len(body_bytes): is_truncated = 'time' # testme WARC stats.stats_sum('fetch timeout body bytes found', 1) stats.stats_sum('fetch timeout body bytes found bytes', len(body_bytes)) # except (aiohttp.ClientError.ClientResponseError.TooManyRedirects) as e: # # XXX remove me when I stop using redirects for robots.txt fetching # raise except (aiohttp.ClientError) as e: # ClientError is a catchall for a bunch of things # e.g. DNS errors, '400' errors for http parser errors # ClientConnectorCertificateError for an SSL cert that doesn't match hostname # ClientConnectorError(None, None) caused by robots redir to DNS fail # ServerDisconnectedError(None,) caused by servers that return 0 bytes for robots.txt fetches # TooManyRedirects("0, message=''",) caused by too many robots.txt redirs stats.stats_sum('fetch ClientError', 1) detailed_name = str(type(e).__name__) last_exception = 'ClientError: ' + detailed_name + ': ' + str(e) body_bytes = b''.join(blocks) if len(body_bytes): is_truncated = 'disconnect' # testme WARC stats.stats_sum('fetch ClientError body bytes found', 1) stats.stats_sum('fetch ClientError body bytes found bytes', len(body_bytes)) except ssl.CertificateError as e: # unfortunately many ssl errors raise and have tracebacks printed deep in aiohttp # so this doesn't go off much stats.stats_sum('fetch SSL error', 1) last_exception = 'CertificateError: ' + str(e) #except (ValueError, AttributeError, RuntimeError) as e: # supposedly aiohttp 2.1 only fires these on programmer error, but here's what I've seen in the past: # ValueError Location: https:/// 'Host could not be detected' -- robots fetch # ValueError Location: http:// /URL should be absolute/ -- robots fetch # ValueError 'Can redirect only to http or https' -- robots fetch -- looked OK to curl! # AttributeError: ? # RuntimeError: ? except ValueError as e: # no A records found -- raised by my dns code stats.stats_sum('fetch other error - ValueError', 1) last_exception = 'ValueErorr: ' + str(e) except AttributeError as e: stats.stats_sum('fetch other error - AttributeError', 1) last_exception = 'AttributeError: ' + str(e) except RuntimeError as e: stats.stats_sum('fetch other error - RuntimeError', 1) last_exception = 'RuntimeError: ' + str(e) except asyncio.CancelledError: raise except Exception as e: last_exception = 'Exception: ' + str(e) stats.stats_sum('fetch surprising error', 1) LOGGER.info('Saw surprising exception in fetcher working on %s:\n%s', mock_url or url.url, last_exception) traceback.print_exc() if last_exception is not None: LOGGER.info('we failed working on %s, the last exception is %s', mock_url or url.url, last_exception) return FetcherResponse(None, None, None, None, None, False, last_exception) fr = FetcherResponse(response, body_bytes, response.request_info.headers, t_first_byte, t_last_byte, is_truncated, None) if response.status >= 500: LOGGER.debug('server returned http status %d', response.status) stats.stats_sum('fetch bytes', len(body_bytes) + len(response.raw_headers)) stats.stats_sum(stats_prefix+'fetch URLs', 1) stats.stats_sum(stats_prefix+'fetch http code=' + str(response.status), 1) # checks after fetch: # hsts header? # if ssl, check strict-transport-security header, remember max-age=foo part., other stuff like includeSubDomains # did we receive cookies? was the security bit set? return fr def upgrade_scheme(url): ''' Upgrade crawled scheme to https, if reasonable. This helps to reduce MITM attacks against the crawler. https://chromium.googlesource.com/chromium/src/net/+/master/http/transport_security_state_static.json Alternately, the return headers from a site might have strict-transport-security set ... a bit more dangerous as we'd have to respect the timeout to avoid permanently learning something that's broken TODO: use HTTPSEverwhere? would have to have a fallback if https failed, which it occasionally will ''' return url
2.453125
2
spatialpandas/tools/__init__.py
isabella232/spatialpandas
0
12788819
<gh_stars>0 from .sjoin import sjoin
1.0625
1
brax/envs/doublehumanoid.py
carolinewang01/brax
0
12788820
# Copyright 2021 The Brax Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # 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. """Trains a humanoid to run in the +x direction.""" from typing import Tuple, List import functools import dataclasses import jax import jax.numpy as jnp import numpy as np import brax # from brax.envs import multiagent_env from brax.envs import env from brax.physics import bodies from brax.physics.base import take from google.protobuf import text_format class DoubleHumanoid(env.Env): """Trains a humanoid to run in the +x direction.""" def __init__(self, **kwargs): # TODO: define a function to copy the system config automatically based on num_agents self.num_agents = 2 config = text_format.Parse(_SYSTEM_CONFIG, brax.Config()) super().__init__(config, **kwargs) # TODO: define these as properties in multiagent env self.agent_action_size = 17 self.agent_observation_size = 293 # body info self.body_parts = ["torso", "lwaist", "pelvis", "right_thigh", "right_shin", "left_thigh", "left_shin", "right_upper_arm", "right_lower_arm", "left_upper_arm", "left_lower_arm" ] self.world_parts = ["floor"] # actuator info self.agent_dof = 17 assert self.agent_dof * self.num_agents == self.sys.num_joint_dof self.torque_1d_act_idx = jnp.array([2, 6, 10, 13, 16]) self.torque_2d_act_idx = jnp.array([[0, 1], [11, 12], [14, 15]]) self.torque_3d_act_idx = jnp.array([[3, 4, 5], [7, 8, 9]]) # joint info self.agent_joints = 10 self.num_joints_1d = 5 self.num_joints_2d = 3 self.num_joints_3d = 2 # info to differentiate humanoids all_bodies = bodies.Body.from_config(config) # body object only used to get object mass and inertia all_bodies = take(all_bodies, all_bodies.idx[:-len(self.world_parts)]) # skip the world bodies self.num_body_parts = len(self.body_parts) for i in range(self.num_agents): # get system body idx from self.sys body_idxs = {f"{body_part}{i}": self.sys.body_idx[f"{body_part}{i}"] for body_part in self.body_parts} setattr(self, f"agent{i}_idxs", body_idxs) # get mass, inertia from Body object body = take(all_bodies, all_bodies.idx[i * self.num_body_parts: i * self.num_body_parts + self.num_body_parts ]) assert len(body.idx) == self.num_body_parts setattr(self, f"mass{i}", body.mass.reshape(-1, 1)) setattr(self, f"inertia{i}", body.inertia) self.mass = jnp.array([getattr(self, f"mass{i}") for i in range(self.num_agents)]) self.inertia = jnp.array([getattr(self, f"inertia{i}") for i in range(self.num_agents)]) self.floor_idx = self.sys.body_idx["floor"] # how far apart to initialize humanoids self.field_distance = 20 def update_parts_xyz(self, carry, part_idx): qp_pos, xyz_offset = carry qp_pos = jax.ops.index_update(qp_pos, jax.ops.index[part_idx], xyz_offset+qp_pos[jax.ops.index[part_idx]] ) return (qp_pos, xyz_offset), () def set_agent_xyz(self, carry, part_idxs): qp_pos, rng = carry rng, xyz_offset = self._random_target(rng) (qp_pos, xyz_offset), _ = jax.lax.scan( self.update_parts_xyz, (qp_pos, xyz_offset), part_idxs ) return (qp_pos, rng), () def reset(self, rng: jnp.ndarray) -> env.State: """Resets the environment to an initial state.""" qp = self.sys.default_qp() # move the humanoids to different positions pos = qp.pos agents_parts_idxs = jnp.array([list(getattr(self, f"agent{i}_idxs").values()) for i in range(self.num_agents)]) (pos, rng), _ = jax.lax.scan( self.set_agent_xyz, (pos, rng), agents_parts_idxs ) qp = dataclasses.replace(qp, pos=pos) info = self.sys.info(qp) qp, info = self.sys.step(qp, jax.random.uniform(rng, (self.action_size,)) * .5) # action size is for all agents all_obs = self._get_obs(qp, info, jnp.zeros((self.num_agents, self.agent_dof))) reward = jnp.zeros((self.num_agents,)) done = 0 steps = jnp.zeros(1) metrics = { 'reward_linvel': jnp.zeros((self.num_agents,)), 'reward_quadctrl': jnp.zeros((self.num_agents,)), 'reward_alive': jnp.zeros((self.num_agents,)), 'reward_impact': jnp.zeros((self.num_agents,)) } return env.State(rng, qp, info, all_obs, reward, done, steps, metrics) def step(self, state: env.State, action: jnp.ndarray) -> env.State: """Run one timestep of the environment's dynamics.""" rng = state.rng # note the minus sign. reverse torque improves performance over a range of # hparams. as to why: ¯\_(ツ)_/¯ qp, info = self.sys.step(state.qp, -action.flatten()) all_obs = self._get_obs(qp, info, action) # should this be - action? reward, lin_vel_cost, quad_ctrl_cost, alive_bonus, quad_impact_cost = self._compute_reward(state, action, qp) metrics = { 'reward_linvel': lin_vel_cost, 'reward_quadctrl': -quad_ctrl_cost, 'reward_alive': alive_bonus, 'reward_impact': -quad_impact_cost } steps = state.steps + self.action_repeat done = self._compute_done(qp, steps) return env.State(rng, qp, info, all_obs, reward, done, steps, metrics) def _get_obs(self, qp: brax.QP, info: brax.Info, action: jnp.ndarray): all_obs = [] # TODO: figure out how to jit self._get_agent_obs # (qp, info, action), all_obs = jax.lax.scan( # self._get_agent_obs, (qp, info, action), jnp.arange(self.num_agents)) for agent_idx in range(self.num_agents): (qp, info, action), obs = self._get_agent_obs((qp, info, action), agent_idx) all_obs.append(obs) all_obs = jnp.array(all_obs) # humanoid: (128, 299) # double humanoid: (128, 2, 293) # TODO: Add world features! (floor loc) return all_obs def _compute_reward(self, state: env.State, action: jnp.ndarray, qp: brax.QP): # TODO: how to ensure ordering of reshaping is correct?? pos_before = jnp.reshape(state.qp.pos[:-1], (self.num_agents, self.num_body_parts, 3)) # ignore floor at last index pos_after = jnp.reshape(qp.pos[:-1], (self.num_agents, self.num_body_parts, 3)) # ignore floor at last index com_before = jnp.sum(pos_before * self.mass, axis=1) / jnp.sum(self.mass, axis=1) com_after = jnp.sum(pos_after * self.mass, axis=1) / jnp.sum(self.mass, axis=1) lin_vel_cost = 1.25 * (com_after[:, 0] - com_before[:, 0]) / self.sys.config.dt reshaped_actions = jnp.reshape(action, (self.num_agents, self.agent_dof)) quad_ctrl_cost = .01 * jnp.sum(jnp.square(reshaped_actions), axis=1) # can ignore contact cost, see: https://github.com/openai/gym/issues/1541 quad_impact_cost = jnp.zeros(self.num_agents) alive_bonus = 5.0 * jnp.ones(self.num_agents) reward = lin_vel_cost - quad_ctrl_cost - quad_impact_cost + alive_bonus return reward, lin_vel_cost, quad_ctrl_cost, alive_bonus, quad_impact_cost def _compute_done(self, qp: brax.QP, steps: int, done_thres=0.75): """Return done if the proportion of agents that are done surpasses done_thres """ torsos_idxs = jnp.arange(self.num_agents) * self.num_body_parts torsos_zdim = take(qp.pos[:, 2], torsos_idxs) done_cond0 = jnp.where(steps >= self.episode_length, x=1.0, y=0.0) done_cond1 = jnp.where(torsos_zdim < 0.6, x=1.0, y=0.0) done_cond2 = jnp.where(torsos_zdim > 2.1, x=1.0, y=0.0) done_vec = done_cond0 + done_cond1 + done_cond2 done_vec = jnp.where(done_vec > 0.0, x=1.0, y=0.0) done_ratio = jnp.sum(done_vec) / self.num_agents done = jnp.where(done_ratio > done_thres, x=1.0, y=0.0) return done def _get_agent_obs(self, carry, agent_idx) -> jnp.ndarray: """Observe humanoid body position, velocities, and angles.""" qp, info, action = carry qpos, qvel = self._get_agent_qpos_qvel(agent_idx, qp) qfrc_actuator = self._get_agent_qfrc(agent_idx, action[agent_idx]) cfrc_ext = self._get_agent_cfrc_ext(agent_idx, info) cinert, cvel = self._get_agent_com_obs(agent_idx, qp) # obs = jnp.expand_dims(jnp.concatenate(qpos + qvel + cinert + cvel + qfrc_actuator + \ # cfrc_ext), axis=0) obs = jnp.concatenate(qpos + qvel + cinert + cvel + qfrc_actuator + \ cfrc_ext) return (qp, info, action), obs def _get_agent_qpos_qvel(self, agent_idx: int, qp: brax.QP) -> Tuple[List[jnp.ndarray], List[jnp.ndarray]]: """ Some pre-processing to pull joint angles and velocities """ # TODO: move outside this function joint_1d_angle, joint_1d_vel = self.sys.joint_revolute.angle_vel(qp) joint_2d_angle, joint_2d_vel = self.sys.joint_universal.angle_vel(qp) joint_3d_angle, joint_3d_vel = self.sys.joint_spherical.angle_vel(qp) idx_offset = agent_idx * self.num_joints_1d joint_1d_angle = take(joint_1d_angle, jnp.arange(idx_offset, idx_offset + self.num_joints_1d)) joint_1d_vel = take(joint_1d_vel, jnp.arange(idx_offset, idx_offset + self.num_joints_1d)) idx_offset = agent_idx * self.num_joints_2d joint_2d_angle = take(joint_2d_angle, jnp.arange(idx_offset, idx_offset + self.num_joints_2d)) joint_2d_vel = take(joint_2d_vel, jnp.arange(idx_offset, idx_offset + self.num_joints_2d)) idx_offset = agent_idx * self.num_joints_3d joint_3d_angle = take(joint_3d_angle, jnp.arange(idx_offset, idx_offset + self.num_joints_3d)) joint_3d_vel = take(joint_3d_vel, jnp.arange(idx_offset, idx_offset + self.num_joints_3d)) # qpos: # Z of the torso of agent idx (1,) # orientation of the torso as quaternion (4,) # joint angles, all dofs (8,) agent_torso_idx = agent_idx * self.num_body_parts qpos = [ qp.pos[agent_torso_idx, 2:], qp.rot[agent_torso_idx], *joint_1d_angle, *joint_2d_angle, *joint_3d_angle ] # qvel: # velocity of the torso (3,) # angular velocity of the torso (3,) # joint angle velocities, all dofs (8,) qvel = [ qp.vel[agent_torso_idx], qp.ang[agent_torso_idx], *joint_1d_vel, *joint_2d_vel, *joint_3d_vel ] return qpos, qvel def _get_agent_qfrc(self, agent_idx: int, agent_action: jnp.ndarray) -> List[jnp.ndarray]: # actuator forces idx_offset = agent_idx * self.num_joints_1d torque_1d = take(agent_action, self.torque_1d_act_idx) torque_1d *= take(self.sys.torque_1d.strength, jnp.arange(idx_offset, idx_offset + self.num_joints_1d)) idx_offset = agent_idx * self.num_joints_2d torque_2d = take(agent_action, self.torque_2d_act_idx) torque_2d = torque_2d.reshape(torque_2d.shape[:-2] + (-1,)) torque_2d *= jnp.repeat(take(self.sys.torque_2d.strength, jnp.arange(idx_offset, idx_offset + self.num_joints_2d)), 2) idx_offset = agent_idx * self.num_joints_3d torque_3d = take(agent_action, self.torque_3d_act_idx) torque_3d = torque_3d.reshape(torque_3d.shape[:-2] + (-1,)) torque_3d *= jnp.repeat(take(self.sys.torque_3d.strength, jnp.arange(idx_offset, idx_offset + self.num_joints_3d)), 3) qfrc_actuator = [torque_1d, torque_2d, torque_3d] return qfrc_actuator def _get_agent_cfrc_ext(self, agent_idx: int, info: brax.Info) -> List[jnp.ndarray]: agent_torso_idx = agent_idx * self.num_body_parts # external contact forces: # delta velocity (3,), delta ang (3,) * num bodies in the system cfrc_ext = [info.contact.vel[agent_torso_idx:agent_torso_idx + self.num_body_parts], info.contact.ang[agent_torso_idx:agent_torso_idx + self.num_body_parts] ] # flatten bottom dimension cfrc_ext = [x.reshape(x.shape[:-2] + (-1,)) for x in cfrc_ext] return cfrc_ext def _get_agent_com_obs(self, agent_idx: int, qp: brax.QP) -> Tuple[List[jnp.ndarray], List[jnp.ndarray]]: """Get center of mass observations for one agent""" agent_torso_idx = agent_idx * self.num_body_parts agent_mass = getattr(self, f"mass{agent_idx}") agent_inertia = getattr(self, f"inertia{agent_idx}") body_pos = qp.pos[agent_torso_idx:agent_torso_idx + self.num_body_parts] # ignore floor at last index body_vel = qp.vel[agent_torso_idx:agent_torso_idx + self.num_body_parts] # ignore floor at last index com_vec = jnp.sum(body_pos * agent_mass, axis=0) / jnp.sum(agent_mass) com_vel = body_vel * agent_mass / jnp.sum(agent_mass) def v_outer(a): return jnp.outer(a, a) def v_cross(a, b): return jnp.cross(a, b) v_outer = jax.vmap(v_outer, in_axes=[0]) v_cross = jax.vmap(v_cross, in_axes=[0, 0]) disp_vec = body_pos - com_vec # there are 11 bodies for each humanoid com_inert = agent_inertia + agent_mass.reshape( (11, 1, 1)) * ((jnp.linalg.norm(disp_vec, axis=1)**2.).reshape( (11, 1, 1)) * jnp.stack([jnp.eye(3)] * 11) - v_outer(disp_vec)) cinert = [com_inert.reshape(-1)] square_disp = (1e-7 + (jnp.linalg.norm(disp_vec, axis=1)**2.)).reshape( (11, 1)) com_angular_vel = (v_cross(disp_vec, body_vel) / square_disp) cvel = [com_vel.reshape(-1), com_angular_vel.reshape(-1)] return cinert, cvel def _random_target(self, rng: jnp.ndarray) -> Tuple[jnp.ndarray, jnp.ndarray]: """Returns a target location in a random circle on xz plane.""" rng, rng1, rng2 = jax.random.split(rng, 3) dist = self.field_distance * jax.random.uniform(rng1) ang = jnp.pi * 2. * jax.random.uniform(rng2) target_x = dist * jnp.cos(ang) target_y = dist * jnp.sin(ang) target_z = 0 target = jnp.array([target_x, target_y, target_z]).transpose() return rng, target _HUMANOID0_CONFIG =""" bodies { name: "torso0" colliders { position { } rotation { x: -90.0 } capsule { radius: 0.07 length: 0.28 } } colliders { position { z: 0.19 } capsule { radius: 0.09 length: 0.18 } } colliders { position { x: -0.01 z: -0.12 } rotation { x: -90.0 } capsule { radius: 0.06 length: 0.24 } } inertia { x: 1.0 y: 1.0 z: 1.0 } mass: 8.907463 } bodies { name: "lwaist0" colliders { position { } rotation { x: -90.0 } capsule { radius: 0.06 length: 0.24 } } inertia { x: 1.0 y: 1.0 z: 1.0 } mass: 2.2619467 } bodies { name: "pelvis0" colliders { position { x: -0.02 } rotation { x: -90.0 } capsule { radius: 0.09 length: 0.32 } } inertia { x: 1.0 y: 1.0 z: 1.0 } mass: 6.6161942 } bodies { name: "right_thigh0" colliders { position { y: 0.005 z: -0.17 } rotation { x: -178.31532 } capsule { radius: 0.06 length: 0.46014702 } } inertia { x: 1.0 y: 1.0 z: 1.0 } mass: 4.751751 } bodies { name: "right_shin0" colliders { position { z: -0.15 } rotation { x: -180.0 } capsule { radius: 0.049 length: 0.398 end: -1 } } colliders { position { z: -0.35 } capsule { radius: 0.075 length: 0.15 end: 1 } } inertia { x: 1.0 y: 1.0 z: 1.0 } mass: 4.5228419 } bodies { name: "left_thigh0" colliders { position { y: -0.005 z: -0.17 } rotation { x: 178.31532 } capsule { radius: 0.06 length: 0.46014702 } } inertia { x: 1.0 y: 1.0 z: 1.0 } mass: 4.751751 } bodies { name: "left_shin0" colliders { position { z: -0.15 } rotation { x: -180.0 } capsule { radius: 0.049 length: 0.398 end: -1 } } colliders { position { z: -0.35 } capsule { radius: 0.075 length: 0.15 end: 1 } } inertia { x: 1.0 y: 1.0 z: 1.0 } mass: 4.5228419 } bodies { name: "right_upper_arm0" colliders { position { x: 0.08 y: -0.08 z: -0.08 } rotation { x: 135.0 y: 35.26439 z: -75.0 } capsule { radius: 0.04 length: 0.35712814 } } inertia { x: 1.0 y: 1.0 z: 1.0 } mass: 1.6610805 } bodies { name: "right_lower_arm0" colliders { position { x: 0.09 y: 0.09 z: 0.09 } rotation { x: -45.0 y: 35.26439 z: 15.0 } capsule { radius: 0.031 length: 0.33912814 } } colliders { position { x: 0.18 y: 0.18 z: 0.18 } capsule { radius: 0.04 length: 0.08 } } inertia { x: 1.0 y: 1.0 z: 1.0 } mass: 1.2295402 } bodies { name: "left_upper_arm0" colliders { position { x: 0.08 y: 0.08 z: -0.08 } rotation { x: -135.0 y: 35.26439 z: 75.0 } capsule { radius: 0.04 length: 0.35712814 } } inertia { x: 1.0 y: 1.0 z: 1.0 } mass: 1.6610805 } bodies { name: "left_lower_arm0" colliders { position { x: 0.09 y: -0.09 z: 0.09 } rotation { x: 45.0 y: 35.26439 z: -15.0 } capsule { radius: 0.031 length: 0.33912814 } } colliders { position { x: 0.18 y: -0.18 z: 0.18 } capsule { radius: 0.04 length: 0.08 } } inertia { x: 1.0 y: 1.0 z: 1.0 } mass: 1.2295402 } joints { name: "abdomen_z0" stiffness: 15000.0 parent: "torso0" child: "lwaist0" parent_offset { x: -0.01 z: -0.195 } child_offset { z: 0.065 } rotation { y: -90.0 } angular_damping: 20.0 angle_limit { min: -45.0 max: 45.0 } angle_limit { min: -75.0 max: 30.0 } } joints { name: "abdomen_x0" stiffness: 15000.0 parent: "lwaist0" child: "pelvis0" parent_offset { z: -0.065 } child_offset { z: 0.1 } rotation { x: 90.0 } angular_damping: 20.0 angle_limit { min: -35.0 max: 35.0 } } joints { name: "right_hip_x0" stiffness: 8000.0 parent: "pelvis0" child: "right_thigh0" parent_offset { y: -0.1 z: -0.04 } child_offset { } rotation { } angular_damping: 20.0 limit_strength: 2000.0 angle_limit { min: -10.0 max: 10.0 } angle_limit { min: -10.0 max: 10.0 } angle_limit { min: -30.0 max: 70.0 } } joints { name: "right_knee0" stiffness: 15000.0 parent: "right_thigh0" child: "right_shin0" parent_offset { y: 0.01 z: -0.383 } child_offset { z: 0.02 } rotation { z: -90.0 } angular_damping: 20.0 angle_limit { min: -160.0 max: -2.0 } } joints { name: "left_hip_x0" stiffness: 8000.0 parent: "pelvis0" child: "left_thigh0" parent_offset { y: 0.1 z: -0.04 } child_offset { } angular_damping: 20.0 limit_strength: 2000.0 angle_limit { min: -10.0 max: 10.0 } angle_limit { min: -10.0 max: 10.0 } angle_limit { min: -30.0 max: 70.0 } } joints { name: "left_knee0" stiffness: 15000.0 parent: "left_thigh0" child: "left_shin0" parent_offset { y: -0.01 z: -0.383 } child_offset { z: 0.02 } rotation { z: -90.0 } angular_damping: 20.0 angle_limit { min: -160.0 max: -2.0 } } joints { name: "right_shoulder0" stiffness: 15000.0 parent: "torso0" child: "right_upper_arm0" parent_offset { y: -0.17 z: 0.06 } child_offset { } rotation { x: 135.0 y: 35.26439 } angular_damping: 20.0 angle_limit { min: -85.0 max: 60.0 } angle_limit { min: -85.0 max: 60.0 } } joints { name: "right_elbow0" stiffness: 15000.0 parent: "right_upper_arm0" child: "right_lower_arm0" parent_offset { x: 0.18 y: -0.18 z: -0.18 } child_offset { } rotation { x: 135.0 z: 90.0 } angular_damping: 20.0 angle_limit { min: -90.0 max: 50.0 } } joints { name: "left_shoulder0" stiffness: 15000.0 parent: "torso0" child: "left_upper_arm0" parent_offset { y: 0.17 z: 0.06 } child_offset { } rotation { x: 45.0 y: -35.26439 } angular_damping: 20.0 angle_limit { min: -60.0 max: 85.0 } angle_limit { min: -60.0 max: 85.0 } } joints { name: "left_elbow0" stiffness: 15000.0 parent: "left_upper_arm0" child: "left_lower_arm0" parent_offset { x: 0.18 y: 0.18 z: -0.18 } child_offset { } rotation { x: 45.0 z: -90.0 } angular_damping: 20.0 angle_limit { min: -90.0 max: 50.0 } } actuators { name: "abdomen_z0" joint: "abdomen_z0" strength: 300.0 torque { } } actuators { name: "abdomen_x0" joint: "abdomen_x0" strength: 300.0 torque { } } actuators { name: "right_hip_x0" joint: "right_hip_x0" strength: 300.0 torque { } } actuators { name: "right_knee0" joint: "right_knee0" strength: 300.0 torque { } } actuators { name: "left_hip_x0" joint: "left_hip_x0" strength: 300.0 torque { } } actuators { name: "left_knee0" joint: "left_knee0" strength: 300.0 torque { } } actuators { name: "right_shoulder0" joint: "right_shoulder0" strength: 75.0 torque { } } actuators { name: "right_elbow0" joint: "right_elbow0" strength: 75.0 torque { } } actuators { name: "left_shoulder0" joint: "left_shoulder0" strength: 75.0 torque { } } actuators { name: "left_elbow0" joint: "left_elbow0" strength: 75.0 torque { } } collide_include { first: "floor" second: "left_shin0" } collide_include { first: "floor" second: "right_shin0" } """ _HUMANOID1_CONFIG = """ bodies { name: "torso1" colliders { position { } rotation { x: -90.0 } capsule { radius: 0.07 length: 0.28 } } colliders { position { z: 0.19 } capsule { radius: 0.09 length: 0.18 } } colliders { position { x: -0.01 z: -0.12 } rotation { x: -90.0 } capsule { radius: 0.06 length: 0.24 } } inertia { x: 1.0 y: 1.0 z: 1.0 } mass: 8.907463 } bodies { name: "lwaist1" colliders { position { } rotation { x: -90.0 } capsule { radius: 0.06 length: 0.24 } } inertia { x: 1.0 y: 1.0 z: 1.0 } mass: 2.2619467 } bodies { name: "pelvis1" colliders { position { x: -0.02 } rotation { x: -90.0 } capsule { radius: 0.09 length: 0.32 } } inertia { x: 1.0 y: 1.0 z: 1.0 } mass: 6.6161942 } bodies { name: "right_thigh1" colliders { position { y: 0.005 z: -0.17 } rotation { x: -178.31532 } capsule { radius: 0.06 length: 0.46014702 } } inertia { x: 1.0 y: 1.0 z: 1.0 } mass: 4.751751 } bodies { name: "right_shin1" colliders { position { z: -0.15 } rotation { x: -180.0 } capsule { radius: 0.049 length: 0.398 end: -1 } } colliders { position { z: -0.35 } capsule { radius: 0.075 length: 0.15 end: 1 } } inertia { x: 1.0 y: 1.0 z: 1.0 } mass: 4.5228419 } bodies { name: "left_thigh1" colliders { position { y: -0.005 z: -0.17 } rotation { x: 178.31532 } capsule { radius: 0.06 length: 0.46014702 } } inertia { x: 1.0 y: 1.0 z: 1.0 } mass: 4.751751 } bodies { name: "left_shin1" colliders { position { z: -0.15 } rotation { x: -180.0 } capsule { radius: 0.049 length: 0.398 end: -1 } } colliders { position { z: -0.35 } capsule { radius: 0.075 length: 0.15 end: 1 } } inertia { x: 1.0 y: 1.0 z: 1.0 } mass: 4.5228419 } bodies { name: "right_upper_arm1" colliders { position { x: 0.08 y: -0.08 z: -0.08 } rotation { x: 135.0 y: 35.26439 z: -75.0 } capsule { radius: 0.04 length: 0.35712814 } } inertia { x: 1.0 y: 1.0 z: 1.0 } mass: 1.6610805 } bodies { name: "right_lower_arm1" colliders { position { x: 0.09 y: 0.09 z: 0.09 } rotation { x: -45.0 y: 35.26439 z: 15.0 } capsule { radius: 0.031 length: 0.33912814 } } colliders { position { x: 0.18 y: 0.18 z: 0.18 } capsule { radius: 0.04 length: 0.08 } } inertia { x: 1.0 y: 1.0 z: 1.0 } mass: 1.2295402 } bodies { name: "left_upper_arm1" colliders { position { x: 0.08 y: 0.08 z: -0.08 } rotation { x: -135.0 y: 35.26439 z: 75.0 } capsule { radius: 0.04 length: 0.35712814 } } inertia { x: 1.0 y: 1.0 z: 1.0 } mass: 1.6610805 } bodies { name: "left_lower_arm1" colliders { position { x: 0.09 y: -0.09 z: 0.09 } rotation { x: 45.0 y: 35.26439 z: -15.0 } capsule { radius: 0.031 length: 0.33912814 } } colliders { position { x: 0.18 y: -0.18 z: 0.18 } capsule { radius: 0.04 length: 0.08 } } inertia { x: 1.0 y: 1.0 z: 1.0 } mass: 1.2295402 } joints { name: "abdomen_z1" stiffness: 15000.0 parent: "torso1" child: "lwaist1" parent_offset { x: -0.01 z: -0.195 } child_offset { z: 0.065 } rotation { y: -90.0 } angular_damping: 20.0 angle_limit { min: -45.0 max: 45.0 } angle_limit { min: -75.0 max: 30.0 } } joints { name: "abdomen_x1" stiffness: 15000.0 parent: "lwaist1" child: "pelvis1" parent_offset { z: -0.065 } child_offset { z: 0.1 } rotation { x: 90.0 } angular_damping: 20.0 angle_limit { min: -35.0 max: 35.0 } } joints { name: "right_hip_x1" stiffness: 8000.0 parent: "pelvis1" child: "right_thigh1" parent_offset { y: -0.1 z: -0.04 } child_offset { } rotation { } angular_damping: 20.0 limit_strength: 2000.0 angle_limit { min: -10.0 max: 10.0 } angle_limit { min: -10.0 max: 10.0 } angle_limit { min: -30.0 max: 70.0 } } joints { name: "right_knee1" stiffness: 15000.0 parent: "right_thigh1" child: "right_shin1" parent_offset { y: 0.01 z: -0.383 } child_offset { z: 0.02 } rotation { z: -90.0 } angular_damping: 20.0 angle_limit { min: -160.0 max: -2.0 } } joints { name: "left_hip_x1" stiffness: 8000.0 parent: "pelvis1" child: "left_thigh1" parent_offset { y: 0.1 z: -0.04 } child_offset { } angular_damping: 20.0 limit_strength: 2000.0 angle_limit { min: -10.0 max: 10.0 } angle_limit { min: -10.0 max: 10.0 } angle_limit { min: -30.0 max: 70.0 } } joints { name: "left_knee1" stiffness: 15000.0 parent: "left_thigh1" child: "left_shin1" parent_offset { y: -0.01 z: -0.383 } child_offset { z: 0.02 } rotation { z: -90.0 } angular_damping: 20.0 angle_limit { min: -160.0 max: -2.0 } } joints { name: "right_shoulder1" stiffness: 15000.0 parent: "torso1" child: "right_upper_arm1" parent_offset { y: -0.17 z: 0.06 } child_offset { } rotation { x: 135.0 y: 35.26439 } angular_damping: 20.0 angle_limit { min: -85.0 max: 60.0 } angle_limit { min: -85.0 max: 60.0 } } joints { name: "right_elbow1" stiffness: 15000.0 parent: "right_upper_arm1" child: "right_lower_arm1" parent_offset { x: 0.18 y: -0.18 z: -0.18 } child_offset { } rotation { x: 135.0 z: 90.0 } angular_damping: 20.0 angle_limit { min: -90.0 max: 50.0 } } joints { name: "left_shoulder1" stiffness: 15000.0 parent: "torso1" child: "left_upper_arm1" parent_offset { y: 0.17 z: 0.06 } child_offset { } rotation { x: 45.0 y: -35.26439 } angular_damping: 20.0 angle_limit { min: -60.0 max: 85.0 } angle_limit { min: -60.0 max: 85.0 } } joints { name: "left_elbow1" stiffness: 15000.0 parent: "left_upper_arm1" child: "left_lower_arm1" parent_offset { x: 0.18 y: 0.18 z: -0.18 } child_offset { } rotation { x: 45.0 z: -90.0 } angular_damping: 20.0 angle_limit { min: -90.0 max: 50.0 } } actuators { name: "abdomen_z1" joint: "abdomen_z1" strength: 300.0 torque { } } actuators { name: "abdomen_x1" joint: "abdomen_x1" strength: 300.0 torque { } } actuators { name: "right_hip_x1" joint: "right_hip_x1" strength: 300.0 torque { } } actuators { name: "right_knee1" joint: "right_knee1" strength: 300.0 torque { } } actuators { name: "left_hip_x1" joint: "left_hip_x1" strength: 300.0 torque { } } actuators { name: "left_knee1" joint: "left_knee1" strength: 300.0 torque { } } actuators { name: "right_shoulder1" joint: "right_shoulder1" strength: 75.0 torque { } } actuators { name: "right_elbow1" joint: "right_elbow1" strength: 75.0 torque { } } actuators { name: "left_shoulder1" joint: "left_shoulder1" strength: 75.0 torque { } } actuators { name: "left_elbow1" joint: "left_elbow1" strength: 75.0 torque { } } collide_include { first: "floor" second: "left_shin1" } collide_include { first: "floor" second: "right_shin1" } """ _ENV_CONFIG = """ bodies { name: "floor" colliders { plane { } } inertia { x: 1.0 y: 1.0 z: 1.0 } mass: 1.0 frozen { all: true } } friction: 1.0 gravity { z: -9.81 } angular_damping: -0.05 baumgarte_erp: 0.1 dt: 0.015 substeps: 8 """ _SYSTEM_CONFIG = _HUMANOID0_CONFIG + _HUMANOID1_CONFIG + _ENV_CONFIG
2.390625
2
app_iza.py
Sharmaxz/instabot.py
2
12788821
<reponame>Sharmaxz/instabot.py #!/usr/bin/env python # -*- coding: utf-8 -*- import os import dotenv from src.location.extract_location import get_locations_id BASE_DIR = os.path.dirname(os.path.abspath(__file__)) dotenv.load_dotenv(os.path.join(BASE_DIR, '.env')) from src import InstaBot location_ids = get_locations_id('IZABELLA') if __name__ == '__main__': bot = InstaBot( login=os.environ.get('IZALOGIN', ''), password=<PASSWORD>.get('<PASSWORD>', ''), like_per_day=1400, comments_per_day=0, tag_list=[id['location_id'] for id in location_ids][::-2], user_blacklist={}, max_like_for_one_tag=50, follow_per_day=0, follow_time=1 * 60, unfollow_per_day=0, unfollow_break_min=15, unfollow_break_max=30, log_mod=0, proxy='', # List of list of words, each of which will be used to generate comment # For example: "This shot feels wow!" comment_list=[["this", "the", "your"], ["photo", "picture", "pic", "shot", "snapshot"], ["is", "looks", "feels", "is really"], ["great", "super", "good", "very good", "good", "wow", "WOW", "cool", "GREAT", "magnificent", "magical", "very cool", "stylish", "beautiful", "so beautiful", "so stylish", "so professional", "lovely", "so lovely", "very lovely", "glorious","so glorious", "very glorious", "adorable", "excellent", "amazing"], [".", "..", "...", "!", "!!", "!!!"]], # Use unwanted_username_list to block usernames containing a string ## Will do partial matches; i.e. 'mozart' will block 'legend_mozart' ### 'free_followers' will be blocked because it contains 'free' unwanted_username_list=[ 'second', 'stuff', 'art', 'project', 'love', 'life', 'food', 'blog', 'free', 'keren', 'photo', 'graphy', 'indo', 'travel', 'art', 'shop', 'store', 'sex', 'toko', 'jual', 'online', 'murah', 'jam', 'kaos', 'case', 'baju', 'fashion', 'corp', 'tas', 'butik', 'grosir', 'karpet', 'sosis', 'salon', 'skin', 'care', 'cloth', 'tech', 'rental', 'kamera', 'beauty', 'express', 'kredit', 'collection', 'impor', 'preloved', 'follow', 'follower', 'gain', '.id', '_id', 'bags' ], unfollow_whitelist=['example_user_1', 'example_user_2']) while True: mode = 0 if mode == 0: bot.auto_mod()
2.34375
2
exercises/exercise4/image-downloader/downloader.py
jackxxu/2020F-AC295
0
12788822
<gh_stars>0 import sys import os import requests import time import shutil from selenium import webdriver def download_google_images(search_term_list = ["tomato", "bell pepper"], num_images_requested = 10): print("download_google_images...") start_time = time.time() # Setup download folder downloads = "dataset" if os.path.exists(downloads): shutil.rmtree(downloads) os.mkdir(downloads) # Each scrolls provides 400 image approximately number_of_scrolls = int(num_images_requested / 400) + 1 # Firefox Options options = webdriver.FirefoxOptions() options.headless = True browser = webdriver.Firefox(options=options) for search_term in search_term_list: print("Searching for :", search_term) browser.get('https://www.google.com/search?q=' + search_term) # Go to Google Images images_links = browser.find_elements_by_xpath('//a[contains(@class, "q qs")]') for link in images_links: #print(link) print(link.get_attribute("href")) # Wait time.sleep(5) # Go to images images_link = images_links[0] images_link.click() for _ in range(number_of_scrolls): for __ in range(10): # multiple scrolls needed to show all 400 images browser.execute_script("window.scrollBy(0, 1000000)") time.sleep(2) # to load next 400 images time.sleep(5) # try to find show more results bottom try: # if found click to load more image browser.find_element_by_xpath("//input[@value='Show more results']").click() except Exception as e: # if not exit print("End of page") break # Image link store imgs_urls = set() # Find the thumbnail images thumbnails = browser.find_elements_by_xpath('//a[@class="wXeWr islib nfEiy mM5pbd"]') # loop over the thumbs to retrive the links for thumbnail in thumbnails: # check if reached the request number of links if len(imgs_urls) >= num_images_requested: break try: thumbnail.click() time.sleep(2) except Exception as error: print("Error clicking one thumbnail : ", error) # Find the image url url_elements = browser.find_elements_by_xpath('//img[@class="n3VNCb"]') # check for the correct url for url_element in url_elements: try: url = url_element.get_attribute('src') except e: print("Error getting url") if url.startswith('http') and not url.startswith('https://encrypted-tbn0.gstatic.com'): #print("Found image url:", url) imgs_urls.add(url) print('Number of image urls found:', len(imgs_urls)) # Wait 5 seconds time.sleep(5) # Save the images img_dir = os.path.join(downloads, search_term.lower().replace(" ","_")) if not os.path.exists(img_dir): os.makedirs(img_dir) count = 0 for url in imgs_urls: try: with requests.get(url, stream=True) as r: r.raise_for_status() file_path = os.path.join(img_dir, '{0}.jpg'.format(count)) with open(file_path, 'wb') as f: for chunk in r.iter_content(chunk_size=8192): f.write(chunk) count += 1 # sleep if count % 10 == 0: time.sleep(3) except Exception as e: print("Error in url:", url) print(e) continue # Quit the browser browser.quit() execution_time = (time.time() - start_time) / 60.0 print("Download execution time (mins)", execution_time)
3.203125
3
atalaia/explore.py
vallantin/atalaia
0
12788823
# TODOS #-------------------------------------- # imports import matplotlib.pyplot as plt from atalaia.atalaia import Atalaia import numpy as np import networkx as nx class Explore: """Explore is used for text exploratory tasks. """ def __init__(self, language:str): """ Parameters ---------- language : str The language of the corpus """ self.language = language self.atalaia = self.__start_atalaia() def __start_atalaia(self): """ Starts an instance of Atalaia""" return Atalaia(self.language) def describe(self, corpus:list): """ Gets the lengths of the sentences present in the corpus, based on the number of tokens. Returns the lengths, the shortest value and the longest value and the average sentence size.""" # tokenize sentences tokenized_sentences = [self.atalaia.tokenize(sentence) for sentence in corpus] # get the lengths lengths = [len(sentence) for sentence in tokenized_sentences] # get the percentiles a = np.array(lengths) percentiles = (np.percentile(a,0), np.percentile(a,25), np.percentile(a,50), np.percentile(a,75), np.percentile(a,100)) # get shortest, longest and average sentence size using the percentiles values shortest = percentiles[0] # 0% longest = percentiles[4] # 100% average = percentiles[2] # 50% return lengths, shortest, longest, average, percentiles def plot_sentences_size_histogram(self, corpus:list, bins = 30, xlabel = 'Number of tokens', ylabel = 'Frequency'): """ Plots the tokens distribution """ # get sentences sizes sentences_sizes, shortest, longest, average, percentiles = self.describe(corpus) # plot plt.hist(sentences_sizes, bins = bins) plt.xlabel(xlabel) plt.xlabel(ylabel) plt.show() # return sizes, shortest and longest values and average return sentences_sizes, shortest, longest, average, percentiles def plot_sentences_size_boxplot(self, corpus:list): # get sentences sizes sentences_sizes, shortest, longest, average, percentiles = self.describe(corpus) # plot boxplot plt.boxplot(sentences_sizes) plt.show() # return sizes, shortest and longest values and average return sentences_sizes, shortest, longest, average, percentiles def plot_representative_tokens(self, corpus:list, percentage=0.3): #create corpus corpus = self.atalaia.create_corpus(corpus) # let's lowercase everything first texts_lower = self.atalaia.lower_remove_white(corpus) # plot token_data = self.atalaia.representative_tokens(percentage, texts_lower, reverse=False) token_data = token_data.items() token_data = list(token_data)[:10] tokens, counts = zip(*token_data) # plot plt.figure(figsize=(20,10)) plt.bar(tokens, counts, color='b') plt.xlabel('Tokens'); plt.ylabel('Counts');
3.625
4
tests/test_io.py
gerritholl/sattools
0
12788824
"""Test I/O related functionality.""" import tempfile import os import pathlib def test_cache_dir(): """Test getting cache directory.""" from sattools.io import get_cache_dir with tempfile.TemporaryDirectory() as tmpdir: d = get_cache_dir(tmpdir, "tofu") assert str(d.parent) == tmpdir assert d.name == "tofu" try: _environ = os.environ.copy() os.environ.pop("XDG_CACHE_HOME", None) d = get_cache_dir(subdir="raspberry") assert d.parent.name == ".cache" assert d.name == "raspberry" finally: try: d.rmdir() except OSError: pass os.environ.clear() os.environ.update(_environ) try: _environ = os.environ.copy() pt = pathlib.Path(os.environ.get("TMPDIR", "/tmp/")) os.environ["XDG_CACHE_HOME"] = str(pt) d = get_cache_dir(subdir="banana") assert d.parent == pt assert d.name == "banana" finally: try: d.rmdir() except OSError: pass os.environ.clear() os.environ.update(_environ) def test_plotdir(tmp_path, monkeypatch): """Test getting plotting directory.""" from sattools.io import plotdir monkeypatch.delenv("PLOT_BASEDIR", raising=False) pd = plotdir(create=False) assert pd.parent.parent.parent == pathlib.Path( "/media/nas/x21308/plots_and_maps") pd = plotdir(create=False, basedir=tmp_path) assert pd.parent.parent.parent == tmp_path monkeypatch.setenv("PLOT_BASEDIR", str(tmp_path)) pd = plotdir(create=False) assert pd.parent.parent.parent == tmp_path assert not pd.exists() pd = plotdir(create=True) assert pd.exists() def test_datadir(tmp_path, monkeypatch): """Test getting NAS data directory.""" from sattools.io import nas_data_out monkeypatch.delenv("NAS_DATA", raising=False) pd = nas_data_out(create=False) assert pd == pathlib.Path("/media/nas/x21308/data_out") monkeypatch.setenv("NAS_DATA", str(tmp_path)) pd = nas_data_out(create=False) assert pd == tmp_path / "data_out" assert not pd.exists() pd = nas_data_out(create=True) assert pd.exists() pd = nas_data_out(tmp_path / "fionnay", subdir="datum", create=True) assert pd == tmp_path / "fionnay" / "datum" assert pd.exists()
2.40625
2
escalate/rest_api/tests/model_tests/organization/person.py
darkreactions/ESCALATE
11
12788825
<reponame>darkreactions/ESCALATE from ..model_tests_utils import ( status_codes, DELETE, PUT, POST, GET, ERROR, random_model_dict, check_status_code, compare_data ) from core.models import ( Organization, Person, Actor ) person_test_data = { 'person_test_0':{ 'org0': { "description": "Test", "full_name": "Test", "short_name": "Test", "address1": "Test", "address2": "Test", "city": "Test", "state_province": "TT", "zip": "21345", "country": "Test", "website_url": "www.test.com", "phone": "1231231", "parent": None }, 'org1': { "description": "Test12", "full_name": "Test12", "short_name": "Test12", "address1": "Test", "address2": "Test", "city": "Test", "state_province": "TT", "zip": "21345", "country": "Test", "website_url": "www.test.com", "phone": "1231231", "parent": None }, 'person': { "first_name": "Test", "last_name": "Test", "middle_name": "Test", "address1": "Test", "address2": "Test", "city": "Test", "state_province": "TT", "zip": "123124", "country": "Test", "phone": "123123123", "email": "<EMAIL>", "title": "Test", "suffix": "", }, 'person_update0': { "first_name":"updated_first_name", "last_name":"updated_last_name", "middle_name": "updated_middle_name", "address1": "updated_address1", "address2": "updated_address2", "city": "updated_city", "state_province": "bb", "zip": "111111", "country": "updated_country", "phone": "1111111111", "email": "<EMAIL>", "title": "updated_title", "suffix": "updated_suffix", "added_organization": ['org0__url','org1__url'] }, 'person_update1': { "first_name":"updated_first_name", "last_name":"updated_last_name", "middle_name": "updated_middle_name", "address1": "updated_address1", "address2": "updated_address2", "city": "updated_city", "state_province": "bb", "zip": "111111", "country": "updated_country", "phone": "1111111111", "email": "<EMAIL>", "title": "updated_title", "suffix": "updated_suffix", "added_organization": ['org0__url'] } } } person_tests = [ ##----TEST 0----## #creates an organization #creates a person #creates an actor with the person and organization as foreign keys #this will populate the added_organization field in person with #the corresponding organization in the actor table #deletes the actor #empties the added_organization field #gets the person #updates person #gets person #deletes person #gets person (should return error) [ { 'name': 'org0', 'method': POST, 'endpoint': 'organization-list', 'body': random_model_dict(Organization), 'args': [], 'query_params': [], 'is_valid_response': { 'function': check_status_code, 'args': [], 'kwargs': { 'status_code': POST } } }, { 'name': 'person0', 'method': POST, 'endpoint': 'person-list', 'body': (request_body := random_model_dict(Person)), 'args': [], 'query_params': [], 'is_valid_response': { 'function': compare_data, 'args': [], 'kwargs': { 'status_code': POST, 'request_body': request_body } } }, { 'name': 'actor0', 'method': POST, 'endpoint': 'actor-list', 'body': random_model_dict(Actor, organization='org0__url', person='person0__url'), 'args': [], 'query_params': [], 'is_valid_response': { 'function': check_status_code, 'args': [], 'kwargs': { 'status_code': POST } } }, { 'name': 'actor0_delete_0', 'method': DELETE, 'endpoint': 'actor-detail', 'body': {}, 'args': [ 'actor0__uuid' ], 'query_params': [], 'is_valid_response': { 'function': check_status_code, 'args': [], 'kwargs': { 'status_code': DELETE } } }, { 'name': 'person0_get_0', 'method': GET, 'endpoint': 'person-detail', 'body': {}, 'args': [ 'person0__uuid' ], 'query_params': [], 'is_valid_response': { 'function': check_status_code, 'args': [], 'kwargs': { 'status_code': GET } } }, { 'name': 'person0_update_0', 'method': PUT, 'endpoint': 'person-detail', 'body': (request_body := random_model_dict(Person)), 'args': [ 'person0__uuid' ], 'query_params': [], 'is_valid_response': { 'function': compare_data, 'args': [], 'kwargs': { 'status_code': PUT, 'request_body': request_body } } }, { 'name': 'person0_get_1', 'method': GET, 'endpoint': 'person-detail', 'body': {}, 'args': [ 'person0__uuid' ], 'query_params': [], 'is_valid_response': { 'function': check_status_code, 'args': [], 'kwargs': { 'status_code': GET } } }, { 'name': 'person0_delete_0', 'method': DELETE, 'endpoint': 'person-detail', 'body': {}, 'args': [ 'person0__uuid' ], 'query_params': [], 'is_valid_response': { 'function': check_status_code, 'args': [], 'kwargs': { 'status_code': DELETE } } }, { 'name': 'person0_get_3', 'method': GET, 'endpoint': 'person-detail', 'body': {}, 'args': [ 'person0__uuid' ], 'query_params': [], 'is_valid_response': { 'function': check_status_code, 'args': [], 'kwargs': { 'status_code': ERROR } } }, ], ]
2.09375
2
grr/server/grr_response_server/check_lib/__init__.py
khanhgithead/grr
4,238
12788826
<reponame>khanhgithead/grr #!/usr/bin/env python """This is the check capabilities used to post-process host data.""" # pylint: disable=g-import-not-at-top,unused-import from grr_response_server.check_lib import checks from grr_response_server.check_lib import hints from grr_response_server.check_lib import triggers
0.964844
1
Sandbox/gatherSV_zinfo.py
echaussidon/LSS
8
12788827
''' gather redshift info across all observations for a given target type; for now from a single tile ''' #test #standard python import sys import os import shutil import unittest from datetime import datetime import json import numpy as np import fitsio import glob import argparse from astropy.table import Table,join,unique,vstack from matplotlib import pyplot as plt parser = argparse.ArgumentParser() parser.add_argument("--type", help="tracer type to be selected") parser.add_argument("--tile", help="observed tile to use") #eventually remove this and just gather everything args = parser.parse_args() type = args.type tile = args.tile if type == 'LRG': tarbit = 0 #targeting bit if type == 'QSO': tarbit = 2 if type == 'ELG': tarbit = 1 print('gathering type,tile') print(type,tile) tp = 'SV1_DESI_TARGET' print('targeting bit, target program type; CHECK THEY ARE CORRECT!') print(tarbit,tp) #location of inputs coaddir = '/global/cfs/cdirs/desi/spectro/redux/blanc/tiles/'+tile subsets = [x[0][len(coaddir):].strip('/') for x in os.walk(coaddir)] #something must work better than this, but for now... #outputs svdir = '/project/projectdirs/desi/users/ajross/catalogs/SV/' version = 'test/' dirout = svdir+'redshift_comps/'+version outf = dirout +'/'+tile+'_'+type+'zinfo.fits' if not os.path.exists(svdir+'redshift_comps'): os.mkdir(svdir+'redshift_comps') print('made '+svdir+'redshift_comps random directory') if not os.path.exists(dirout): os.mkdir(dirout) print('made '+dirout) ss = 0 #use to switch from creating to concatenating for night in subsets: if len(night) > 0: print('going through subset '+night) specs = [] #find out which spectrograph have data for si in range(0,10): try: fl = coaddir+'/'+night+'/zbest-'+str(si)+'-'+str(tile)+'-'+night+'.fits' #print(fl) fitsio.read(fl) specs.append(si) except: print('no spectrograph '+str(si)+ ' on subset '+night) tspec = Table.read(coaddir+'/'+night+'/zbest-'+str(specs[0])+'-'+str(tile)+'-'+night+'.fits',hdu='ZBEST') tf = Table.read(coaddir+'/'+night+'/coadd-'+str(specs[0])+'-'+str(tile)+'-'+night+'.fits',hdu='FIBERMAP') for i in range(1,len(specs)): tn = Table.read(coaddir+'/'+night+'/zbest-'+str(specs[i])+'-'+str(tile)+'-'+night+'.fits',hdu='ZBEST') tnf = Table.read(coaddir+'/'+night+'/coadd-'+str(specs[i])+'-'+str(tile)+'-'+night+'.fits',hdu='FIBERMAP') tspec = vstack([tspec,tn]) tf = vstack([tf,tnf]) tspec = join(tspec,tf,keys=['TARGETID']) wtype = ((tspec[tp] & 2**tarbit) > 0) print(str(len(tspec))+' total entries '+str(len(tspec[wtype]))+' that are '+type) tspec = tspec[wtype] tspec['subset'] = night if ss == 0: tspect = tspec ss = 1 else: tspect = vstack([tspect,tspec]) print('there are now '+str(len(tspect)) +' entries with '+str(len(np.unique(tspect['TARGETID'])))+' unique target IDs') tspect.sort('TARGETID') tspect.write(outf,format='fits', overwrite=True)
2.453125
2
module03_research_data_in_python/greengraph/map.py
marquesafonso/rse-course
0
12788828
<gh_stars>0 import numpy as np from io import BytesIO import imageio as img import requests class Map: def __init__( self, lat, long, satellite=True, zoom=10, size=(400, 400), sensor=False ): base = "https://static-maps.yandex.ru/1.x/?" params = dict( z=zoom, size=str(size[0]) + "," + str(size[1]), ll=str(long) + "," + str(lat), l="sat" if satellite else "map", lang="en_US", ) self.image = requests.get( base, params=params ).content # Fetch our PNG image data content = BytesIO(self.image) self.pixels = img.imread(content) # Parse our PNG image as a numpy array def green(self, threshold): # Use NumPy to build an element-by-element logical array greener_than_red = self.pixels[:, :, 1] > threshold * self.pixels[:, :, 0] greener_than_blue = self.pixels[:, :, 1] > threshold * self.pixels[:, :, 2] return np.logical_and(greener_than_red, greener_than_blue) def count_green(self, threshold=1.1): return np.sum(self.green(threshold)) def show_green(self, threshold=1.1): green = self.green(threshold) out = green[:, :, np.newaxis] * np.array([0, 1, 0])[np.newaxis, np.newaxis, :] buffer = BytesIO() result = img.imwrite(buffer, out, format="png") return buffer.getvalue()
3.171875
3
utils.py
yiluzhu/gomoku
1
12788829
from constants import P2P_PIXELS, PIECE_RADIUS_PIXELS, BOARD_SIZE def index_to_pixel(x): """Given a point index, return the corresponding pixel. The Index can be either row or column""" return P2P_PIXELS + P2P_PIXELS * x def pixels_to_indices(pixel_x, pixel_y): """Given a point pixels, go through all points on the board to see which point is the intended selection. :return: the selected point indices. If not found, return None""" # TODO: optimize this method square_distance_threshold = PIECE_RADIUS_PIXELS ** 2 # max distance allowed between the clicked position and the selected point for i in range(BOARD_SIZE): for j in range(BOARD_SIZE): square_distance = (pixel_x - index_to_pixel(i)) ** 2 + (pixel_y - index_to_pixel(j)) ** 2 if square_distance <= square_distance_threshold: return i, j
3.609375
4
OpenCVVideoFunctions/video4.py
zopagaduanjr/Microprocessor_Project
0
12788830
import cv2 import numpy as np cap = cv2.VideoCapture('grace4.mp4') def make_360p(): cap.set(3, 480) cap.set(4, 360) def rescale_frame(frame): percent = 25; width = int(frame.shape[1] * percent/100) height = int(frame.shape[0] * percent/100) dim = (width, height) return cv2.resize(frame, dim, interpolation = cv2.INTER_AREA) subtractor = cv2.createBackgroundSubtractorMOG2() fps = cap.get(cv2.CAP_PROP_FPS) make_360p() while True: _, frame = cap.read() frame38 = rescale_frame(frame) frame38 = cv2.transpose(frame38,frame38) frame38 = cv2.flip(frame38, 1) mask = subtractor.apply(frame38) (contours,_) = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) for contour in contours: if cv2.contourArea(contour) < 190: continue (x,y,w,h) = cv2.boundingRect(contour) cv2.rectangle(frame38, (x,y),(x+w,y+h),(240,32,160),3) cv2.imshow("Zal", frame38) key = cv2.waitKey(30) if key == 27: break cap.release() cv2.destroyAllWindows()
2.75
3
bin/iamonds/hexiamonds-4x9.py
tiwo/puzzler
0
12788831
#!/usr/bin/env python # $Id$ """74 solutions""" import puzzler from puzzler.puzzles.hexiamonds import Hexiamonds4x9 puzzler.run(Hexiamonds4x9)
0.996094
1
run_novalid.py
zerebom/santander
0
12788832
<filename>run_novalid.py<gh_stars>0 from scripts.data_augumation import augmation from sklearn.model_selection import KFold, StratifiedKFold from models.lgbm import train_and_predict_novalid from logs.logger import log_best from utils import load_datasets, load_target from sklearn.model_selection import train_test_split import pandas as pd import datetime import logging from sklearn.model_selection import KFold import seaborn as sns import matplotlib.pyplot as plt import argparse import json import numpy as np np.random.seed(seed=42) # lgbm関係はmodel.pyからimportしている parser = argparse.ArgumentParser() parser.add_argument('--config', default='./configs/default.json') options = parser.parse_args() config = json.load(open(options.config)) now = datetime.datetime.now() logging.basicConfig( filename='./logs/log_{0:%Y%m%d%H%M%S}.log'.format(now), level=logging.DEBUG ) logging.debug('./logs/log_{0:%Y%m%d%H%M%S}.log'.format(now)) # このfeatsは特徴量ファイル名(カラム名ではないので、複数列でも可(base等)) feats = config['features'] lgbm_params = config['lgbm_params'] logging.debug(feats) target_name = config['target_name'] X_train_all, X_test, features = load_datasets(feats) y_train_all = load_target(target_name) logging.debug(X_train_all.shape) # lgbmの実行 y_pred, model = train_and_predict_novalid( X_train_all, y_train_all, X_test, lgbm_params ) # 結果の保存 ID_name = config['ID_name'] sub = pd.DataFrame(pd.read_csv('./data/input/test.csv')[ID_name]) sub[target_name] = y_pred sub.to_csv( './data/output/final_sub_{0:%Y%m%d%H%M%S}_.csv'.format(now), index=False )
2.40625
2
source/constructor.py
janzmazek/Wave-propagation
1
12788833
""" This module constructs network of streets. """ import numpy as np import json # Adobe flat UI colour scheme DARK_BLUE = "#2C3E50" MEDIUM_BLUE = "#2980B9" LIGHT_BLUE = "#3498DB" RED = "#E74C3C" WHITE = "#ECF0F1" # Colour parameters STROKE_COLOUR = DARK_BLUE STREET_COLOUR = DARK_BLUE JUNCTION_COLOUR = MEDIUM_BLUE JUNCTION_TEXT = DARK_BLUE RESULTS_COLOUR = RED RESULTS_TEXT = DARK_BLUE # Dimensions OFFSET = 50 STREET_WIDTH = 8 STROKE_WIDTH = 2 JUNCTION_WIDTH = 20 MAX_RADIUS = 25 INITIAL_DECIBELS = 120 # Max absorption MAX_ABSORPTION = 0.1 # Don't plot absorption coefficients (option) ABSORPTION = False class Constructor(object): """ This class of methods initialises a network object of specified dimensions, modifies the network using modifying methods, outputs the adjacency matrix of the network and outputs the visualisation in the svg format. """ def __init__(self): self.__horizontals = None self.__verticals = None self.__nodes = None self.__adjacency = None self.__modified_adjacency = None self.__positions = None self.__stage = 0 def set_grid(self, horizontals, verticals, length): """ This setter method sets stage 1 (setting and moving) of the construction. """ try: horizontals = int(horizontals) verticals = int(verticals) except ValueError: raise ValueError("Horizontals and verticals must be integers.") try: length = float(length) except ValueError: raise ValueError("Length must be a floating point number.") for quantity in [horizontals, verticals, length]: if quantity < 0: raise ValueError( "Horizontals, verticals and length must be positive numbers.") self.__horizontals = horizontals self.__verticals = verticals self.__nodes = horizontals*verticals self.__adjacency = self.__create_adjacency() self.__modified_adjacency = None self.__positions = self.__create_positions(length) self.__stage = 1 def unset_grid(self): """ This method is used to set the network to the stage 0 (instantiation) of the construction. """ self.__horizontals = None self.__verticals = None self.__nodes = None self.__adjacency = None self.__modified_adjacency = None self.__positions = None self.__stage = 0 def __create_adjacency(self): """ This private method returns initial adjacency matrix. """ adjacency = np.zeros((self.__nodes, self.__nodes), dtype=np.int) # Normal adjacency matrix for grid network for i in range(self.__nodes): for j in range(self.__nodes): if (j == i+1 and j%self.__verticals != 0) or \ (j == i-1 and i%self.__verticals != 0) or \ j == i+self.__verticals or \ j == i-self.__verticals: adjacency[i][j] = 1 return adjacency def __create_positions(self, length): """ This private method returns initial positions matrix. """ positions = np.zeros((self.__nodes, 2)) for i in range(self.__nodes): positions[i][0] = i%self.__verticals*length positions[i][1] = i//self.__verticals*length return positions def move_horizontal_line(self, i, length): """ This method moves the horizontal line i. """ assert self.__stage == 1 if i not in range(self.__horizontals): raise ValueError("No such horizontal line.") for node in range(self.__nodes): if node//self.__verticals == i: self.__positions[node][1] += length def move_vertical_line(self, j, length): """ This method moves the vertical line j. """ assert self.__stage == 1 if j not in range(self.__verticals): raise ValueError("No such vertical line.") for node in range(self.__nodes): if node%self.__verticals == j: self.__positions[node][0] += length def delete_connection(self, i, j): """ This method deletes the street (i, j). """ if self.__stage == 1: self.__stage = 2 # set stage to 1 so lines cannot be moved assert self.__stage == 2 if i not in range(self.__nodes) or j not in range(self.__nodes): raise ValueError("Nodes out of range.") if self.__adjacency[i][j] == 0: raise ValueError("Junctions are not neighbours.") self.__adjacency[i][j] = 0 self.__adjacency[j][i] = 0 to_delete = [] if sum(self.__adjacency[i]) == 2: connections = [] for k in range(self.__nodes): if self.__adjacency[i][k] == 1: connections.append(k) if (self.__positions[i][0] == self.__positions[connections[0]][0] and \ self.__positions[i][0] == self.__positions[connections[1]][0]) or \ (self.__positions[i][1] == self.__positions[connections[0]][1] and \ self.__positions[i][1] == self.__positions[connections[1]][1]): self.__adjacency[connections[0]][connections[1]] = 1 self.__adjacency[connections[1]][connections[0]] = 1 to_delete.append(i) elif sum(self.__adjacency[i]) == 0: to_delete.append(i) if sum(self.__adjacency[j]) == 2: connections = [] for k in range(self.__nodes): if self.__adjacency[j][k] == 1: connections.append(k) if (self.__positions[j][0] == self.__positions[connections[0]][0] and \ self.__positions[j][0] == self.__positions[connections[1]][0]) or \ (self.__positions[j][1] == self.__positions[connections[0]][1] and \ self.__positions[j][1] == self.__positions[connections[1]][1]): self.__adjacency[connections[0]][connections[1]] = 1 self.__adjacency[connections[1]][connections[0]] = 1 to_delete.append(j) elif sum(self.__adjacency[j]) == 0: to_delete.append(j) if len(to_delete) != 0: self.__adjacency = np.delete(self.__adjacency, to_delete, axis=0) self.__adjacency = np.delete(self.__adjacency, to_delete, axis=1) self.__positions = np.delete(self.__positions, to_delete, axis=0) self.__nodes = int(self.__nodes - len(to_delete)) def modify_adjacency(self, width, alpha, beta): """ This method creates new adjacency matrix with dictionaries of keys (alpha, beta, street width, street length, orientation) instead of 1s. """ if self.__stage == 1 or self.__stage == 2: self.__stage = 3 assert self.__stage == 3 try: width = float(width) alpha = float(alpha) beta = float(beta) except ValueError: raise ValueError("Width and absorption must be floating point numbers.") if width <= 0: raise ValueError("Width must be a positive number.") if alpha < 0 or alpha > 1 or beta < 0 or beta > 1: raise ValueError("Absorption must be a number between 0 and 1.") self.__modified_adjacency = self.__adjacency.tolist() # To python structure positions = self.__positions for i in range(self.__nodes): for j in range(i): if self.__adjacency[i][j] == 1: if positions[i][1] == positions[j][1]: length = abs(positions[i][0] - positions[j][0]).tolist() if positions[i][0] < positions[j][0]: orientation = 0 elif positions[i][0] > positions[j][0]: orientation = 2 else: raise ValueError("Points are at the same position.") elif positions[i][0] == positions[j][0]: length = abs(positions[i][1] - positions[j][1]).tolist() if positions[i][1] < positions[j][1]: orientation = 1 elif positions[i][1] > positions[j][1]: orientation = 3 else: raise ValueError("Points are at the same position.") else: raise ValueError("Points are not colinear.") self.__modified_adjacency[i][j] = { "alpha": alpha, "beta": beta, "width": width, "length": length, "orientation": orientation} self.__modified_adjacency[j][i] = { "alpha": alpha, "beta": beta, "width": width, "length": length, "orientation": (orientation+2)%4} def unmodify_adjacency(self): """ This method is used to set the stage to stage 2 (deleting) of the construction. """ self.__stage = 2 self.__modified_adjacency = None def change_width(self, i, j, width): """ This method changes the street width of street (i, j). """ assert self.__stage == 3 try: width = float(width) except ValueError: raise ValueError("Width must be a floating point number.") if width <= 0: raise ValueError("Width must be a positive number.") if i not in range(self.__nodes) or j not in range(self.__nodes): raise ValueError("Nodes out of range") if self.__modified_adjacency[i][j] == 0: raise ValueError("Junctions are not neighbours.") self.__modified_adjacency[i][j]["width"] = width self.__modified_adjacency[j][i]["width"] = width def change_alpha(self, i, j, alpha): """ This method changes the wall absorption of street (i, j). """ assert self.__stage == 3 try: alpha = float(alpha) except ValueError: raise ValueError("Absorption must be a floating point number.") if alpha < 0 or alpha > 1: raise ValueError("Absorption must be a number between 0 and 1") if i not in range(self.__nodes) or j not in range(self.__nodes): raise ValueError("Nodes out of range.") if self.__modified_adjacency[i][j] == 0: raise ValueError("Junctions are not neighbours.") self.__modified_adjacency[i][j]["alpha"] = alpha self.__modified_adjacency[j][i]["alpha"] = alpha def change_beta(self, i, j, beta): """ This method changes the air absorption of street (i, j). """ assert self.__stage == 3 try: beta = float(beta) except ValueError: raise ValueError("Absorption must be a floating point number.") if beta < 0 or beta > 1: raise ValueError("Absorption must be a number between 0 and 1") if i not in range(self.__nodes) or j not in range(self.__nodes): raise ValueError("Nodes out of range.") if self.__modified_adjacency[i][j] == 0: raise ValueError("Junctions are not neighbours.") self.__modified_adjacency[i][j]["beta"] = beta self.__modified_adjacency[j][i]["beta"] = beta def get_horizontals(self): """ This getter method returns the number of horizontal streets. """ return self.__horizontals def get_verticals(self): """ This getter method returns the number of vertical streets. """ return self.__verticals def get_adjacency(self): """ This getter method returns the normal adjacency matrix. """ return self.__adjacency def get_modified_adjacency(self): """ This getter method returns the modified adjacency matrix. """ return self.__modified_adjacency def get_positions(self): """ This getter method returns the positions matrix. """ return self.__positions def get_stage(self): """ This getter method returns current stage index. """ return self.__stage def import_network(self, invalues): """ This method is used to import existing network from the invalues dictionary. """ self.__horizontals = invalues["horizontals"] self.__verticals = invalues["verticals"] self.__nodes = invalues["nodes"] self.__adjacency = np.array(invalues["adjacency"]) self.__modified_adjacency = invalues["modified_adjacency"] self.__positions = np.array(invalues["positions"]) self.__stage = invalues["stage"] def export_network(self, filename): """ This method is used to export currently constructed network to json format to some file. """ data = { "horizontals": self.__horizontals, "verticals": self.__verticals, "nodes": self.__nodes, "adjacency": self.__adjacency.tolist(), "modified_adjacency": self.__modified_adjacency, "positions": self.__positions.tolist(), "stage": self.__stage } with open(filename, "w") as file: json.dump(data, file) def draw_network(self, filename, results=False): """ This method outputs file "output.html" with svg drawing of network and optinally plots the results. """ def get_hex_fill(coefficient, max_absorption): red = hex(int(coefficient/max_absorption*255)) red = red[-2:] if len(red)==4 else "0{0}".format(red[-1]) blue = hex(int((1-coefficient/max_absorption)*255)) blue = blue[-2:] if len(blue)==4 else "0{0}".format(blue[-1]) fill = "#{0}00{1}".format(red, blue) return fill def svg_header(width, height): return "<svg width='{0}' height='{1}'>\n".format(width, height) def svg_line(x1, y1, x2, y2, fill=STREET_COLOUR, width=STREET_WIDTH): return "<line x1='{0}' y1='{1}' x2='{2}' y2='{3}' \ style='stroke: {4}; stroke-width: {5}'/>\n".format(x1+OFFSET, y1+OFFSET, x2+OFFSET, y2+OFFSET, fill, width) def svg_square(x, y): return "<rect x='{0}' y='{1}' width='{2}' height='{2}' \ style='stroke: {3}; stroke-width: {4}; fill: {5}'/>\n".format(x-JUNCTION_WIDTH/2+OFFSET, y-JUNCTION_WIDTH/2+OFFSET, JUNCTION_WIDTH, STROKE_COLOUR, STROKE_WIDTH, JUNCTION_COLOUR ) def svg_circle(x, y, r, fill): return "<circle cx='{0}' cy='{1}' r='{2}' style='stroke: {3}; \ stroke-width: {4}; fill: {5}'/>\n".format(x+OFFSET, y+OFFSET, r, STROKE_COLOUR, STROKE_WIDTH, fill ) def svg_text(x, y, colour, size, text): move = (size-15)/4 # adjust text position return "<text text-anchor='middle' x='{0}' y='{1}' \ style='fill: {2}; font-size: {3}'>{4}</text>\n".format(x+OFFSET, y+OFFSET+JUNCTION_WIDTH/4 + move, colour, size, text ) positions = self.__positions if self.__stage == 3: adjacency = self.__modified_adjacency modified = True else: adjacency = self.__adjacency modified = False with open(filename, "w") as file: width = positions[self.__nodes-1][0]+2*OFFSET height = positions[self.__nodes-1][1]+2*OFFSET file.write(svg_header(width, height)) # Draw walls if modified (with absorption) if modified and ABSORPTION: for i in range(self.__nodes): for j in range(i): if adjacency[i][j] != 0: [xi, yi] = positions[i] [xj, yj] = positions[j] alpha = adjacency[i][j]["alpha"] alpha_fill = get_hex_fill(alpha, MAX_ABSORPTION) width = adjacency[i][j]["width"] translation = width/2 if xi == xj: file.write(svg_line(xi-translation, yi, xj-translation, yj, alpha_fill, width )) file.write(svg_line(xi+translation, yi, xj+translation, yj, alpha_fill, width )) elif yi == yj: file.write(svg_line(xi, yi-translation, xj, yj-translation, alpha_fill, width )) file.write(svg_line(xi, yi+translation, xj, yj+translation, alpha_fill, width )) # Draw streets (with absorption if modified) for i in range(self.__nodes): for j in range(i): if adjacency[i][j] != 0: [xi, yi] = positions[i] [xj, yj] = positions[j] if not modified or not ABSORPTION: file.write(svg_line(xi, yi, xj, yj)) else: beta = adjacency[i][j]["beta"] beta_fill = get_hex_fill(beta, MAX_ABSORPTION) width = adjacency[i][j]["width"] file.write(svg_line(xi, yi, xj, yj, beta_fill, width )) # Draw junctions (rectangles with numbers) counter = 0 for position in positions: file.write(svg_square(position[0], position[1])) file.write(svg_text(position[0], position[1], JUNCTION_TEXT, 15, counter)) counter += 1 # Draw results if results: (X, Y, Z) = results for i in range(len(Z)): decibels = 20*np.log10(Z[i]*10**(INITIAL_DECIBELS/20)) if decibels < 0: continue # Radius radius = (decibels/INITIAL_DECIBELS)*MAX_RADIUS file.write(svg_circle(X[i], Y[i], radius, RESULTS_COLOUR)) if decibels > 30: file.write(svg_text(X[i], Y[i], RESULTS_TEXT, radius, int(round(decibels)))) file.write("</svg>")
3.6875
4
chunonline/apps/organization/foms.py
andanlove/chunonline
1
12788834
# _*_ coding: utf-8 _*_ import re __author__ = "andan" __data__ = "2018/9/22 12:44" from django import forms from operation.models import UserAsk class UserAskForm(forms.ModelForm): class Meta: model = UserAsk fields = ['name', 'moblie', 'course_name'] def clean_moblie(self): moblie = self.cleaned_data['moblie'] REGEX_MOBILE ="^1[3567890]\d{9}$" p = re.compile(REGEX_MOBILE) if p.match(moblie): return moblie else: raise forms.ValidationError("手机号码非法",code="mobile_invaild")
2.53125
3
angr/engines/soot/expressions/phi.py
vwvw/angr
0
12788835
<reponame>vwvw/angr import logging from .base import SimSootExpr l = logging.getLogger('angr.engines.soot.expressions.phi') class SimSootExpr_Phi(SimSootExpr): def _execute(self): try: local = [self._translate_value(v) for v, idx in self.expr.values if idx == self.state.scratch.source.block_idx][0] value = self.state.memory.load(local, none_if_missing=True) self.expr = value except IndexError: # TODO is there a better way to do this? local_options = [self._translate_value(v) for v, idx in self.expr.values[::-1]] for local in local_options: value = self.state.memory.load(local, none_if_missing=True) if value is not None: self.expr = value return
2.03125
2
src/nextstep_plist/__init__.py
techdragon/python-nextstep-plist
1
12788836
<filename>src/nextstep_plist/__init__.py from nextstep_plist.decoder import PListDecoder __version__ = "0.1.0" __all__ = [ 'load', 'loads', 'PListDecoder', ] _default_decoder = PListDecoder() def load(fp): """Deserialize ``fp`` (a ``.read()``-supporting file-like object containing a NeXTSTEP property list document) to a Python object. """ return loads(fp.read()) def loads(s): """Deserialize ``s`` (a ``str`` or ``unicode`` instance containing a NeXTSTEP property list document) to a Python object. If ``s`` is a ``str`` instance and is encoded with an ASCII based encoding other than utf-8 (e.g. latin-1) then an appropriate ``encoding`` name must be specified. Encodings that are not ASCII based (such as UCS-2) are not allowed and should be decoded to ``unicode`` first. """ return _default_decoder.decode(s)
2.25
2
src/models/main.py
bh1995/mnist_cookiecutter
0
12788837
<filename>src/models/main.py # -*- coding: utf-8 -*- """ Created on Fri Jun 4 13:01:26 2021 @author: bjorn main script to call and run all functions from for mnist_cookiecutter """ # from google.colab import files import sys import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim import torchvision # sys.path sys.path.append( "./Machine Learning Operations 21/mnist_cookiecutter" ) # need to add path # load data from src.data.data1 import * ( train_loader, test_loader, ) = load_mnist() # this will download mnist data, or load it if already downloaded # load model device = torch.device("cpu") from model import * model = Net() model = model.to(device) # load trainer and return trained model from train import train_function # loss_function = F.nll_loss() optimizer = optim.SGD(model.parameters(), lr=0.0001, momentum=0.9) model, train_losses = train_function(model, train_loader, optimizer, n_epochs=30) # evaluate model on test set # not sure why, but test.py does not work, file must be named something else from test1 import test_function test_losses = test_function(model, test_loader) # after 50 epochs -> Test set: Avg. loss: 0.1075, Accuracy: 9667/10000 (97%) # after 30 epichs -> Test set: Avg. loss: 0.3469, Accuracy: 9082/10000 (91%) # save test loss values import pickle name = "C:/Users/bjorn/OneDrive/Dokument/University/DTU/Machine Learning Operations 21/mnist_cookiecutter/reports/test_losses_1.csv" open_file = open(name, "wb") pickle.dump(test_losses, open_file) open_file.close() # save trained model weights for later evaluation # 'C:/Users/bjorn/OneDrive/Dokument/University/DTU/Machine Learning Operations 21/mnist_cookiecutter/models/model_1.pth' save_model_path = "./models/model_2.pth" torch.save(model.state_dict(), save_model_path)
2.65625
3
ref/files/student.py
skrymets/python-core-and-advanced
0
12788838
class Student: def __init__(self,id,name,testscore): self.id = id self.name = name self.testscore = testscore def display(self): print(self.id,self.name,self.testscore)
3.21875
3
run/sb3_NeedlePick_tester.py
rokas-bendikas/SurRoL
0
12788839
<gh_stars>0 import gym import surrol import numpy as np from matplotlib import pyplot as plt import time from stable_baselines3 import DDPG,PPO,TD3, HerReplayBuffer, VecHerReplayBuffer from stable_baselines3.common.noise import NormalActionNoise from stable_baselines3.common.vec_env import DummyVecEnv, VecNormalize, SubprocVecEnv from stable_baselines3.common.monitor import Monitor from stable_baselines3.common.env_util import make_vec_env if __name__ == '__main__': ############################################ ############## PARAMETERS ################## ############################################ env_id = 'NeedlePickPointSpecific-v0' log_dir = "./logs/TD3/"+env_id+'/' seed = 1 env = make_vec_env(env_id,1,seed,monitor_dir=log_dir,env_kwargs={'render_mode':'human','seed':seed}) env = VecNormalize.load(log_dir+"TD3_HER_"+env_id+"_stats", env) # do not update them at test time env.training = False # reward normalization is not needed at test time env.norm_reward = False model = TD3.load(log_dir+'TD3_HER_'+env_id+'', env=env) for _ in range(30): obs = env.reset() done = [False] while not done[0] or not bool(info[0]["is_success"]): time.sleep(0.1) env.render() action, _ = model.predict(obs, deterministic=True) obs, reward, done, info = env.step(action)
1.976563
2
core/recc/core/mixin/context_permission.py
bogonets/answer
3
12788840
<filename>core/recc/core/mixin/context_permission.py # -*- coding: utf-8 -*- from typing import List, Optional, Any, Union from recc.core.mixin.context_base import ContextBase from recc.database.struct.permission import Permission from recc.packet.permission import RawPermission from recc.packet.cvt.permission import permission_to_raw from recc.session.session_ex import SessionEx class ContextPermission(ContextBase): async def create_permission( self, slug: str, name: Optional[str] = None, description: Optional[str] = None, features: Optional[List[str]] = None, extra: Optional[Any] = None, r_layout=False, w_layout=False, r_storage=False, w_storage=False, r_manager=False, w_manager=False, r_graph=False, w_graph=False, r_member=False, w_member=False, r_setting=False, w_setting=False, hidden=False, lock=False, ) -> int: return await self.database.insert_permission( slug=slug, name=name, description=description, features=features, extra=extra, r_layout=r_layout, w_layout=w_layout, r_storage=r_storage, w_storage=w_storage, r_manager=r_manager, w_manager=w_manager, r_graph=r_graph, w_graph=w_graph, r_member=r_member, w_member=w_member, r_setting=r_setting, w_setting=w_setting, hidden=hidden, lock=lock, ) @staticmethod def _is_permission_equals_for_update( permission: Permission, slug: Optional[str] = None, name: Optional[str] = None, description: Optional[str] = None, features: Optional[List[str]] = None, extra: Optional[Any] = None, r_layout: Optional[bool] = None, w_layout: Optional[bool] = None, r_storage: Optional[bool] = None, w_storage: Optional[bool] = None, r_manager: Optional[bool] = None, w_manager: Optional[bool] = None, r_graph: Optional[bool] = None, w_graph: Optional[bool] = None, r_member: Optional[bool] = None, w_member: Optional[bool] = None, r_setting: Optional[bool] = None, w_setting: Optional[bool] = None, hidden: Optional[bool] = None, ) -> bool: """When permission is 'locked', all attributes except `lock` must not be changed. """ if slug is not None: if permission.slug != slug: return False if name is not None: if permission.name != name: return False if description is not None: if permission.description != description: return False if features is not None: if permission.features != features: return False if extra is not None: if permission.extra != extra: return False if r_layout is not None: if permission.r_layout != r_layout: return False if w_layout is not None: if permission.w_layout != w_layout: return False if r_storage is not None: if permission.r_storage != r_storage: return False if w_storage is not None: if permission.w_storage != w_storage: return False if r_manager is not None: if permission.r_manager != r_manager: return False if w_manager is not None: if permission.w_manager != w_manager: return False if r_graph is not None: if permission.r_graph != r_graph: return False if w_graph is not None: if permission.w_graph != w_graph: return False if r_member is not None: if permission.r_member != r_member: return False if w_member is not None: if permission.w_member != w_member: return False if r_setting is not None: if permission.r_setting != r_setting: return False if w_setting is not None: if permission.w_setting != w_setting: return False if hidden is not None: if permission.hidden != hidden: return False return True async def update_permission( self, uid: int, slug: Optional[str] = None, name: Optional[str] = None, description: Optional[str] = None, features: Optional[List[str]] = None, extra: Optional[Any] = None, r_layout: Optional[bool] = None, w_layout: Optional[bool] = None, r_storage: Optional[bool] = None, w_storage: Optional[bool] = None, r_manager: Optional[bool] = None, w_manager: Optional[bool] = None, r_graph: Optional[bool] = None, w_graph: Optional[bool] = None, r_member: Optional[bool] = None, w_member: Optional[bool] = None, r_setting: Optional[bool] = None, w_setting: Optional[bool] = None, hidden: Optional[bool] = None, lock: Optional[bool] = None, force=False, ) -> None: if not force: permission = await self.database.select_permission_by_uid(uid) if permission.lock: permission_equals = self._is_permission_equals_for_update( permission, slug, name, description, features, extra, r_layout, w_layout, r_storage, w_storage, r_manager, w_manager, r_graph, w_graph, r_member, w_member, r_setting, w_setting, hidden, ) if not permission_equals: raise RuntimeError(f"Locked permission: {uid}") await self.database.update_permission_by_uid( uid=uid, slug=slug, name=name, description=description, features=features, extra=extra, r_layout=r_layout, w_layout=w_layout, r_storage=r_storage, w_storage=w_storage, r_manager=r_manager, w_manager=w_manager, r_graph=r_graph, w_graph=w_graph, r_member=r_member, w_member=w_member, r_setting=r_setting, w_setting=w_setting, hidden=hidden, lock=lock, ) async def delete_permission(self, uid: int, force=False) -> None: if not force: if await self.database.select_permission_lock_by_uid(uid): raise RuntimeError(f"Locked permission: {uid}") default_uids = self.database.get_default_permission_uids() if uid in default_uids: raise RuntimeError("Default permissions cannot be removed") await self.database.delete_permission_by_uid(uid) async def get_permission(self, uid: int) -> Permission: return await self.database.select_permission_by_uid(uid) async def get_permissions(self) -> List[Permission]: return await self.database.select_permissions() async def get_group_permission(self, user_uid: int, group_uid: int) -> Permission: return await self.database.select_permission_by_user_uid_and_group_uid( user_uid, group_uid ) async def get_project_permission( self, user_uid: int, project_uid: int ) -> Permission: return await self.database.select_permission_by_user_uid_and_project_uid( user_uid, project_uid ) async def get_best_permission( self, user_uid: int, group_uid: int, project_uid: int ) -> Permission: try: return await self.get_project_permission(user_uid, project_uid) except: # noqa return await self.get_group_permission(user_uid, group_uid) async def get_group_raw_permission( self, session: SessionEx, group: Union[str, int] ) -> RawPermission: try: if isinstance(group, int): group_uid = group elif isinstance(group, str): group_uid = await self.get_group_uid(group) else: group_uid = await self.get_group_uid(str(group)) permission = await self.get_group_permission(session.uid, group_uid) return permission_to_raw(permission, session.is_admin) except: # noqa if session.is_admin: return RawPermission.all_true() else: return RawPermission.all_false() async def get_project_raw_permission( self, session: SessionEx, group: Union[str, int], project: Union[str, int] ) -> RawPermission: try: if isinstance(group, int): group_uid = group elif isinstance(group, str): group_uid = await self.get_group_uid(group) else: group_uid = await self.get_group_uid(str(group)) if isinstance(project, int): project_uid = project elif isinstance(project, str): project_uid = await self.get_project_uid(group_uid, project) else: project_uid = await self.get_project_uid(group_uid, str(project)) permission = await self.get_best_permission( session.uid, group_uid, project_uid ) return permission_to_raw(permission, session.is_admin) except: # noqa if session.is_admin: return RawPermission.all_true() else: return RawPermission.all_false()
1.960938
2
tl_env/envs/double_goal.py
mhtb32/tl-env
1
12788841
<reponame>mhtb32/tl-env<filename>tl_env/envs/double_goal.py from typing import Dict, Tuple from highway_env.envs.common.abstract import Observation from highway_env.envs.common.action import Action from highway_env.road.objects import Landmark from tl_env.envs.single_goal import SingleGoalIDMEnv class DoubleGoalEnv(SingleGoalIDMEnv): """A continuous control environment with two goals and some adversary vehicles. The vehicle must reach the goals while avoiding other vehicles. """ def default_config(self) -> Dict: config = super().default_config() config.update( { "duration": 50, "goal2_position": [260, 4] } ) return config def step(self, action: Action) -> Tuple[Observation, float, bool, Dict]: obs, reward, terminal, info = super().step(action) goal_achievement = self._goal_achievement() # calculate mid-done flag mid_done = self.vehicle.crashed or goal_achievement['g1'] or self.steps >= 25 # update info and terminal with new automaton state info.update(dict(mid_done=mid_done)) terminal = self._is_terminal() return obs, reward, terminal, info def _create_road(self) -> None: super()._create_road() self.goal2 = Landmark(self.road, self.config["goal2_position"], heading=0) self.road.objects.append(self.goal2) def _goal_achievement(self) -> Dict: # noinspection PyProtectedMember return { 'g1': self.vehicle._is_colliding(self.goal), 'g2': self.vehicle._is_colliding(self.goal2) } def _is_terminal(self) -> bool: """Determines end of episode Determine end of episode when: - The vehicle crashes or, - Reaches the second goal or, - Episode duration passes an specific amount of time :return: a boolean indicating end of episode """ return self.vehicle.crashed or self._goal_achievement()['g2'] or self.steps >= self.config['duration'] def _reward(self, action: Action) -> float: # noinspection PyProtectedMember return super()._reward(action) + self.vehicle._is_colliding(self.goal2) * 1.0
2.8125
3
ecdc_status/upcoming_events/admin.py
ess-dmsc/ecdc-status
0
12788842
<reponame>ess-dmsc/ecdc-status<filename>ecdc_status/upcoming_events/admin.py from django.contrib import admin from django.utils import timezone from .models import EventIcon, Event from django.utils.translation import gettext_lazy as _ class FilterOld(admin.SimpleListFilter): title = _('future events') # Parameter for the filter that will be used in the URL query. parameter_name = 'show' def lookups(self, request, model_admin): """ Returns a list of tuples. The first element in each tuple is the coded value for the option that will appear in the URL query. The second element is the human-readable name for the option that will appear in the right sidebar. """ return ( ('false', _('Show old')), ) def queryset(self, request, queryset): """ Returns the filtered queryset based on the value provided in the query string and retrievable via `self.value()`. """ # Compare the requested value (either '80s' or '90s') # to decide how to filter the queryset. if self.value() == 'false': return queryset.filter() CurrentlyOngoing = queryset.exclude(EndDate__isnull = True).filter(EndDate__gte = timezone.now()).filter(StartDate__lt = timezone.now()) return queryset.filter(StartDate__gte=timezone.now()).union(CurrentlyOngoing) @admin.register(Event) class EventAdmin(admin.ModelAdmin): list_display = ('Title', 'StartDate', 'Icon', 'isOngoing') list_filter = (FilterOld, ) admin.site.register(EventIcon)
2.328125
2
run_participants.py
tbenne10/TopographicSurveyAnalysis
0
12788843
#!/usr/bin/env python3 # -*- coding: utf-8 -*- #This script scores results from each student #Drawn images are downloaded from a .csv file, converted from string base64 encoding, #and scored against machine learning models saved to disk import csv import os #import file import cv2 import re import base64 import numpy as np from keras.models import model_from_json from sklearn.metrics import cohen_kappa_score from tkinter import * import tkinter as tk from tkinter.filedialog import askopenfilename from tkinter.filedialog import askdirectory from tkinter import simpledialog import sys import os.path #Specify max size due to large size of Base64 images #**~MAC/LINUX~**# #csv.field_size_limit(sys.maxsize) #**~WINDOWS 64 BIT~**# csv.field_size_limit(2**30) #Specify which questions are drawn images. Their associated value is the #size of the image used in data preprocessing for the machine learning model. drawn_images ={ "Q1": 64, "Q2": 128, "Q3": 64, "Q4": 64, "Q7": 128, "Q8": 128, "Q9": 128, "Q17": 128, "Q18": 64 } #init variables filename = "" filedir = "" modeldir = "" prefix = "" ##Retrieve the CSV file to read image data def getCSVfile(): global filename global filedir filename = askopenfilename() filedir = os.path.abspath(os.path.join(filename, os.pardir)) filedir += "/" print(filedir) #Select the directory containing H5 and JSON model files. def getModelDir(): global modeldir modeldir = askdirectory() modeldir += "/" #Select a prefix to read only specific records starting with the prefix. def getPrefix(): global prefix prefix = simpledialog.askstring("input string", "Enter an ID prefix:") #Run program and create two response CSV files. def Start(): #for indexing drawn_images_list = list(drawn_images) #Load models: models = [] print("Loading models... This may take a moment") for key in drawn_images: json_file_path = modeldir + key + ".json" weight_file_path = modeldir + key + ".h5" json_file = open(json_file_path, 'r') loaded_model_json = json_file.read() json_file.close() loaded_model = model_from_json(loaded_model_json) loaded_model.load_weights(weight_file_path) loaded_model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) models.append(loaded_model) print(f"Loaded model {key}...") print("Done loading models") #Function to process each individual image #Returns a prediction score of 1 or 0. def process_image(Qnum, uri, partid): print(f"Processing image: {Qnum}") #Ensure value exists if(uri == None): return 0 #Grab value to resize image size = drawn_images[Qnum] #create image file as temporary path = modeldir + "temp.png" img = open(path, "wb") img.write(base64.b64decode(uri)) img = cv2.imread(path, 0) #Test resizing image. If the URI is corrupted, return 'C'. try: img = cv2.resize(img, (size, size)) except: return 'c' img_reshape = np.array(img).reshape(-1,size,size,1) #Run image against model print("Acc: ") print (models[drawn_images_list.index(Qnum)].predict(img_reshape)) pred = models[drawn_images_list.index(Qnum)].predict_classes(img_reshape)[0] #This flips the class as the prediction score is on the opposite entry. pred = ("1", "0")[pred == 0] pred_array = models[drawn_images_list.index(Qnum)].predict(img_reshape) #Remove the image to make room for another os.remove(modeldir + "temp.png") eps = .15 #Min. acceptable criterion if(1-np.amax(pred_array) > eps): return 'f' return pred #Open two files, one for response scores and the other for written #question responses. Each file name is appended with a prefix if #a prefix is give. data = open(filename, 'r') responses = open(filedir + 'responses_pref' + prefix + '.csv', 'w') Wresponses = open(filedir + 'Wresponses_pref' + prefix + '.csv', 'w') read_data = csv.reader(data, delimiter=',') write_responses = csv.writer(responses, delimiter=',', quotechar='"', quoting=csv.QUOTE_ALL) write_Wresponses = csv.writer(Wresponses, delimiter=',', quotechar='"', quoting=csv.QUOTE_ALL) line_count = 0 for row in read_data: if row[0].startswith(prefix, 0, len(prefix)): print(row[0]) if line_count == 0: line_count += 1 write_responses.writerow(['Number','Participant', 'Q1_drawn', 'Q2_drawn', 'Q3_drawn', 'Q4_drawn', 'Q7_drawn', 'Q8_drawn', 'Q9_drawn', 'Q17_drawn', 'Q18_drawn', 'Q5_response', 'Q5_correct_response', 'Q5_accuracy','Q6_response', 'Q6_correct_response', 'Q6_accuracy','Q10_1_response', 'Q10_1_correct_response','Q10_1_accuracy', 'Q10_2_response', 'Q10_2_correct_response', 'Q10_2_accuracy', 'Q11_response', 'Q11_correct_response', 'Q11_accuracy', 'Q12_response', 'Q12_correct_response','Q12_accuracy', 'Q13_response', 'Q13_correct_response', 'Q13_accuracy', 'Q14_1_response', 'Q14_1_correct_response', 'Q14_1_accuracy', 'Q14_2_response', 'Q14_2_correct_response','Q14_2_accuracy', 'Q15_AB_response', 'Q15_AB_correct_response','Q15_AB_accuracy', 'Q15_AD_response', 'Q15_AD_correct_response','Q15_AD_accuracy', 'Q15_BC_response', 'Q15_BC_correct_response','Q15_BC_accuracy', 'Q15_CD_response', 'Q15_CD_correct_response','Q15_CD_accuracy','Q15_BD_response', 'Q15_BD_correct_response','Q15_BD_accuracy', 'Total', 'Date Submitted']) write_Wresponses.writerow(['Number','Participant','Q2_written', 'Q7_written', 'Q8_written', 'Q9_written', 'Q14_2_written', 'Q17_written', 'Q18_written', 'Date Submitted']) else: #Resp used for responses, respW for written reponses resp = [] respW = [] count = 0 ##logic here #append number and name resp.append(line_count) resp.append(row[0]) respW.append(line_count) respW.append(row[0]) #append drawn images for x in drawn_images: y = row[drawn_images_list.index(x) + 2].split(',') if(len(y) > 1): resp.append(process_image(x, y[1], row[0])) else: resp.append("N/A") #print(row[drawn_images_list.index(x) + 2]) ##Q5 resp.append(row[23]) resp.append("A") resp.append(("0", "1")[row[23] == "A"]) #Q6 resp.append(row[24]) resp.append("A") resp.append(("0", "1")[row[24] == "A"]) #Q10_1 resp.append(row[15]) resp.append("Josh") resp.append(("0", "1")["josh" in row[15].lower()]) #Q10_2 resp.append(row[18]) resp.append("josh") resp.append(("0", "1")["josh" in row[18].lower()]) #Q11 resp.append(row[25]) resp.append("B") resp.append(("0", "1")[row[25] == "B"]) #Q12 resp.append(row[26]) resp.append("B") resp.append(("0", "1")[row[26] == "B"]) #Q13 resp.append(row[17]) resp.append("40") resp.append(("0", "1")["40" in row[19]]) #Q14_1 resp.append(row[18]) resp.append("Josh") resp.append(("0", "1")["josh" in row[18].lower()]) #Q15 ##Refer to re library for digit extraction resp.append(row[20]) resp.append("7040-7080") val = re.findall("\d+", row[20]) if(len(val) > 0): resp.append(("0", "1")[int(val[0]) >= 7040 and int(val[0]) <= 7080]) else: resp.append("0") #Q16: resp.append(row[27]) resp.append("yes") resp.append(("0", "1")[row[27] == "yes"]) resp.append(row[28]) resp.append("yes") resp.append(("0", "1")[row[28] == "yes"]) resp.append(row[29]) resp.append("yes") resp.append(("0", "1")[row[29] == "yes"]) resp.append(row[30]) resp.append("no") resp.append(("0", "1")[row[30] == "no"]) resp.append(row[31]) resp.append("yes") resp.append(("0", "1")[row[31] == "yes"]) ##WRITE ALL THE WRITTEN RESPONSES HERE respW.append(row[11]) respW.append(row[12]) respW.append(row[13]) respW.append(row[14]) respW.append(row[16]) respW.append(row[19]) respW.append(row[21]) respW.append(row[22]) #Total sum = 0 for x in resp: if x == "1": sum += 1 resp.append(sum) #Dates resp.append(row[32]) respW.append(row[32]) #Write rows write_responses.writerow(resp) write_Wresponses.writerow(respW) line_count += 1 print(f"Finished, {line_count} rows read: ") data.close() responses.close() ##Run GUI root = tk.Tk() root.wm_title("Run Participant Data") selectCsv = tk.Button(root, text='Select CSV file', width=25, command=getCSVfile) selectCsv.pack() selectDirectory = tk.Button(root, text='Select model directory', width=25, command=getModelDir) selectDirectory.pack() selectPrefix = tk.Button(root, text='Select an ID prefix', width=25, command=getPrefix) selectPrefix.pack() startButton = tk.Button(root, text='Start', width=25, command=Start) startButton.pack() root.mainloop()
3.5
4
journalClub/polls/views.py
chabanr/journalClub
0
12788844
<filename>journalClub/polls/views.py from django.shortcuts import render, get_object_or_404 from django.http import HttpResponse, HttpResponseRedirect from django.template import loader from django.http import Http404 from django.urls import reverse from .models import Question # Create your views here. # # def index(request): # return HttpResponse("Hello World! You're at the polls index") # Old detail function (stub) # def detail(request, question_id): # return HttpResponse("You are looking at question {:d}".format(question_id)) def detail(request, question_id): """ These two pieces are equivalent """ # try: # question = Question.objects.get(pk=question_id) # except Question.DoesNotExist: # raise Http404("Question does not exist!") question = get_object_or_404(Question, pk=question_id) return render(request, 'polls/detail.html', {'question': question}) def results(request, question_id): question = get_object_or_404(Question, pk=question_id) return render(request, 'polls/results.html', {'question': question}) def vote(request, question_id): question = get_object_or_404(Question, pk=question_id) try: selected_choice = question.choice_set.get(pk=request.POST['choice']) except KeyError as e: # redisplay the question voting form return render(request, 'polls/detail.html', { 'question': question, 'error_message': 'You need to make a choice', }) else: selected_choice.votes += 1 selected_choice.save() # Always return an HttpResponseRedirect after successfully dealing # with POST data This prevents data from being posted twice if a # user hit the Back button return HttpResponseRedirect(reverse('polls:results', args=(question.id,))) # older listing of the questions # def index(request): # latest_question_list = Question.objects.order_by('-pub_date')[:5] # output = ', '.join([q.question_text for q in latest_question_list]) # return HttpResponse(output) def index(request): latest_question_list = Question.objects.order_by('-pub_date')[:5] template = loader.get_template('polls/index.html') # This context dictionary maps template variable names to python objects context = { 'latest_question_list':latest_question_list, } # the following two return statements are equivalent return render(request, 'polls/index.html', context) #return HttpResponse(template.render(context, request))
2.609375
3
mandarin/parser.py
joegasewicz/amber
2
12788845
from typing import Tuple, Union, Dict, Optional, Any import re from mandarin.core import ELEMENTS class NodeHasNoValueError(Exception): pass class Parser: def __init__(self): pass @staticmethod def remove_white_space(value: str) -> str: cleaned_val = value.lstrip() # TODO handle escaped strings if cleaned_val[0] == "'": cleaned_val = cleaned_val.split("'")[1] else: cleaned_val = cleaned_val.split('"')[1] return cleaned_val @staticmethod def aggregate_into_tuple(*, elem_name: str, content: Any, attr_str: str): if not content and attr_str: return ("<%s %s>" % (elem_name, attr_str)), "</%s>" % elem_name elif content and attr_str: return ("<%s %s>" % (elem_name, attr_str)), Parser.remove_white_space(content), "</%s>" % elem_name elif content and not attr_str: return "<%s>" % elem_name, content, "</%s>" % elem_name else: return "<%s>" % elem_name, "</%s>" % elem_name def parse(self, node: "Node") -> Union[Tuple[str, str, str], Tuple[str, str], str]: el = node.elem_name attr_str = "" if node.elem_name: if node.attr: for k, v in node.attr.items(): if not attr_str: # If this is the first attr then don't add white space attr_str += f"{k}='{v}'" else: attr_str += f" {k}='{v}'" return Parser.aggregate_into_tuple(elem_name=el, content=node.value, attr_str=attr_str) elif node.value: return Parser.remove_white_space(node.value) else: raise NodeHasNoValueError("Node did not have any values to parse.") def add_attrs_to_elem(self): pass def parse_elem(self, element: str) -> Tuple[str, Optional[Dict[str, str]]]: elem = re.split("\(|\)", element) if len(elem) == 1: return elem, None attr_dict = {} attr_str = elem[1] attrs = attr_str.split(" ") for attr in attrs: attr_name, attr_val = attr.split("=") attr_dict[attr_name] = attr_val.strip('""') return elem[0], attr_dict
3.015625
3
tests/test_foo.py
AlexDev-py/vkquick
1
12788846
def test_run(): import vkquick assert True
1.085938
1
api/letter_templates/tests/tests_view.py
django-doctor/lite-api
3
12788847
<gh_stars>1-10 from api.letter_templates.helpers import format_user_text from rest_framework import status from rest_framework.reverse import reverse from api.cases.enums import AdviceType, CaseTypeReferenceEnum from api.cases.enums import CaseTypeSubTypeEnum, CaseTypeEnum from api.staticdata.decisions.models import Decision from parameterized import parameterized from test_helpers.clients import DataTestClient class LetterTemplatesListTests(DataTestClient): def setUp(self): super().setUp() self.letter_template = self.create_letter_template( name="SIEL", case_types=[CaseTypeEnum.GOODS.id, CaseTypeEnum.EUA.id] ) def test_get_letter_templates_success(self): url = reverse("letter_templates:letter_templates") response = self.client.get(url, **self.gov_headers) response_data = response.json()["results"][0] self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(response_data["id"], str(self.letter_template.id)) self.assertEqual(response_data["name"], self.letter_template.name) self.assertEqual(response_data["layout"]["name"], self.letter_template.layout.name) case_types = [item["reference"]["key"] for item in response_data["case_types"]] self.assertIn(CaseTypeReferenceEnum.GQY, case_types) self.assertIn(CaseTypeReferenceEnum.EUA, case_types) def test_filter_letter_templates_success(self): url = reverse("letter_templates:letter_templates") + "?name=" + self.letter_template.name response = self.client.get(url, **self.gov_headers) response_data = response.json()["results"] self.assertTrue(self.letter_template.name in [template["name"] for template in response_data]) self.assertTrue(str(self.letter_template.id) in [template["id"] for template in response_data]) def test_get_letter_templates_for_case_success(self): url = reverse("letter_templates:letter_templates") self.letter_template.case_types.set([CaseTypeEnum.SIEL.id]) case = self.create_standard_application_case(self.organisation) response = self.client.get(url + "?case=" + str(case.id), **self.gov_headers) response_data = response.json()["results"][0] self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(response_data["id"], str(self.letter_template.id)) self.assertEqual(response_data["name"], self.letter_template.name) self.assertEqual(response_data["layout"]["name"], self.letter_template.layout.name) self.assertEqual(CaseTypeReferenceEnum.SIEL, response_data["case_types"][0]["reference"]["key"]) def test_get_letter_templates_for_decision_success(self): decision = AdviceType.APPROVE url = reverse("letter_templates:letter_templates") self.letter_template.decisions.set([Decision.objects.get(name=decision)]) self.letter_template.case_types.set([CaseTypeEnum.SIEL.id]) case = self.create_standard_application_case(self.organisation) response = self.client.get(url + "?case=" + str(case.id) + "&decision=" + decision, **self.gov_headers) response_data = response.json()["results"][0] self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(response_data["id"], str(self.letter_template.id)) self.assertEqual(response_data["name"], self.letter_template.name) self.assertEqual(response_data["layout"]["name"], self.letter_template.layout.name) def test_get_letter_templates_for_case_doesnt_show_templates_with_decisions_success(self): self.letter_template.case_types.set([CaseTypeEnum.SIEL.id]) self.letter_template_with_decisions = self.create_letter_template( name="SIEL_2", case_types=[CaseTypeEnum.SIEL.id], decisions=[Decision.objects.get(name="approve")] ) case = self.create_standard_application_case(self.organisation) response = self.client.get( reverse("letter_templates:letter_templates") + "?case=" + str(case.id), **self.gov_headers ) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(len(response.json()["results"]), 1) self.assertEqual((response.json()["results"][0]["id"]), str(self.letter_template.id)) def test_get_letter_template_success(self): url = reverse("letter_templates:letter_template", kwargs={"pk": str(self.letter_template.id)}) response = self.client.get(url, **self.gov_headers) response_data = response.json() self.assertEqual(response.status_code, status.HTTP_200_OK) template = response_data["template"] self.assertEqual(template["id"], str(self.letter_template.id)) self.assertEqual(template["name"], self.letter_template.name) self.assertEqual(template["layout"]["id"], str(self.letter_template.layout.id)) self.assertEqual(template["letter_paragraphs"], [str(self.letter_template.letter_paragraphs.first().id)]) self.assertIn(CaseTypeSubTypeEnum.GOODS, str(template["case_types"])) self.assertIn(CaseTypeSubTypeEnum.EUA, str(template["case_types"])) self.assertIsNotNone(template.get("created_at")) self.assertIsNotNone(template.get("updated_at")) def test_get_letter_template_with_preview_success(self): url = reverse("letter_templates:letter_template", kwargs={"pk": str(self.letter_template.id)}) url += "?generate_preview=True" response = self.client.get(url, **self.gov_headers) response_data = response.json() self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertTrue("preview" in response_data) preview = response_data["preview"] for tag in ["<style>", "</style>"]: self.assertTrue(tag in preview) self.assertTrue(self.letter_template.letter_paragraphs.first().text in preview) def test_get_letter_template_with_text_success(self): url = reverse("letter_templates:letter_template", kwargs={"pk": str(self.letter_template.id)}) url += "?text=True" response = self.client.get(url, **self.gov_headers) response_data = response.json() self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertTrue("text" in response_data) self.assertTrue(self.letter_template.letter_paragraphs.first().text in response_data["text"]) @parameterized.expand( [ ("**bold text**", "<p><strong>bold text</strong></p>"), ("_italic text_", "<p><em>italic text</em></p>"), ("<u>underlined text</u>", "<p><u>underlined text</u></p>"), ("<u>**bold** _italic_</u>", "<p><u><strong>bold</strong> <em>italic</em></u></p>"), ( "# Heading1\r\n**{{organisation.name}}** {{address}} <u>NOTE:</u>", "<h1>Heading1</h1>\n<p><strong>{{organisation.name}}</strong> {{address}} <u>NOTE:</u></p>", ), ("<script>malicious code</script>", "<p>&lt;script&gt;malicious code&lt;/script&gt;</p>"), ] ) def test_format_user_text_in_preview(self, raw_text, formatted): self.assertEqual(format_user_text(raw_text), formatted)
2.3125
2
8723 Patyki.py
jangThang/Baekjoon-problem
0
12788848
<reponame>jangThang/Baekjoon-problem # 입력 a, b, c = map(int, input().split()) # 판별 후 출력 if a == b == c: # 정삼각형 유무 print(2) # 직각 삼각형 유무 elif a**2 == b**2 + c**2 or b**2 == a**2 + c**2 or c**2 == a**2 + b**2: print(1) # 모두 불가능 else: print(0)
3.234375
3
core/train.py
kianakiaei/TSGL-EEGNet
0
12788849
<reponame>kianakiaei/TSGL-EEGNet # coding:utf-8 import os import gc import sys import math import copy import time import logging import itertools import numpy as np from numpy.core.numeric import cross import tensorflow as tf import matplotlib.pyplot as plt from tensorflow.python.keras.api._v2.keras import backend as K from core.models import EEGNet, TSGLEEGNet, ShallowConvNet, DeepConvNet, MB3DCNN, EEGAttentionNet from core.splits import StratifiedKFold from core.callbacks import MyModelCheckpoint, EarlyStopping from core.utils import standardization, computeKappa _console = sys.stdout def create_EEGAttentionNet(nClasses, Samples, Chans=22, Colors=1, F=9, D=4, kernLength=64, optimizer=tf.keras.optimizers.Adam, lrate=1e-3, loss='sparse_categorical_crossentropy', metrics=['accuracy'], summary=True): model = EEGAttentionNet(nClasses, Chans=Chans, Colors=Colors, Samples=Samples, kernLength=kernLength, F1=F, D=D) model.compile(optimizer=optimizer(lrate), loss=loss, metrics=metrics) if summary: model.summary() # export graph of the model # tf.keras.utils.plot_model(model, 'EEGNet.png', show_shapes=True) return model def create_MB3DCNN(nClasses, H, W, Samples, optimizer=tf.keras.optimizers.Adam, lrate=1e-3, loss='sparse_categorical_crossentropy', metrics=['accuracy'], summary=True): model = MB3DCNN(nClasses, H=H, W=W, Samples=Samples) model.compile(optimizer=optimizer(lrate), loss=loss, metrics=metrics) if summary: model.summary() # export graph of the model # tf.keras.utils.plot_model(model, 'MB3DCNN.png', show_shapes=True) return model def create_EEGNet(nClasses, Samples, Chans=22, F=9, D=4, Ns=4, kernLength=64, FSLength=16, dropoutRate=0.5, optimizer=tf.keras.optimizers.Adam, lrate=1e-3, loss='sparse_categorical_crossentropy', metrics=['accuracy'], summary=True): model = EEGNet(nClasses, Chans=Chans, Samples=Samples, kernLength=kernLength, FSLength=FSLength, dropoutRate=dropoutRate, F1=F, D=D, F2=nClasses * 2 * Ns) model.compile(optimizer=optimizer(lrate), loss=loss, metrics=metrics) if summary: model.summary() # export graph of the model # tf.keras.utils.plot_model(model, 'EEGNet.png', show_shapes=True) return model def create_TSGLEEGNet(nClasses, Samples, Chans=22, Colors=1, F=9, D=4, Ns=4, kernLength=64, FSLength=16, dropoutRate=0.5, l1=1e-4, l21=1e-4, tl1=1e-5, optimizer=tf.keras.optimizers.Adam, lrate=1e-3, loss='sparse_categorical_crossentropy', metrics=['accuracy'], summary=True): model = TSGLEEGNet(nClasses, Chans=Chans, Samples=Samples, Colors=Colors, kernLength=kernLength, FSLength=FSLength, dropoutRate=dropoutRate, F1=F, D=D, F2=nClasses * 2 * Ns, l1=l1, l21=l21, tl1=tl1) model.compile(optimizer=optimizer(lrate), loss=loss, metrics=metrics) if summary: model.summary() # export graph of the model # tf.keras.utils.plot_model(model, 'rawEEGConvNet.png', show_shapes=True) return model class crossValidate(object): ''' Class for K-fold Cross Validation. This framework can collect `model`, `loss`, `acc` and `history` from each fold, and save them into files. Data spliting methods from sklearn.model_selection are supported. you can pass the classes as `splitMethod`. This class has implemented a magic method `__call__()` wrapping `call()`, for which it can be used like a function. Parameters ---------- ```txt built_fn : function, Create Training model which need to cross-validate. Please using string `create_` at the begining of function name, like `create_modelname`. dataGent : class, Generate data for @built_fn, shapes (n_trails, ...). It should discriminate data and label. More details see core.generators. splitMethod : class, Support split methods from module sklearn.model_selection. kFold : int, Number of K-fold. shuffle : bool, Optional Whether to shuffle each class's samples before splitting into batches, default = False. random_state : int, RandomState instance or None, optional, default = None. If int, random_state is the seed used by the random number generator; If RandomState instance, random_state is the random number generator; If None, the random number generator is the RandomState instance used by np.random. Used when shuffle == True. subs : list, list of subjects' number, like `range(1, 10)`. cropping : bool, Switch of cropped training. Default = False. winLength : int, cropping window length, default = 2*srate. cpt : float, cropping sencond, optional, only available when `winLength` is not specified. step : int, cropping step, default = 4. standardizing : bool, Switch of standardizing data. Default = True. batch_size : int, Batch size. epochs : int, Training epochs. patience : int, Early stopping patience. verbose : int, One of 0, 1 and 2. *a, *args : tuple, Parameters used by @dataGent and @built_fn respectively **kw, **kwargs : dict, Parameters used by @dataGent and @built_fn respectively, **kw should include parameters called `beg`, `end` and `srate`. ``` Returns ------- ```txt avg_acc : list, Average accuracy for each subject with K-fold Cross Validation, and total average accuracy is at the last of the list avg_kappa : list, Average kappa for each subject with K-fold Cross Validation, and total average kappa is at the last of the list ``` Example ------- ```python from core.splits import StratifiedKFold def create_model(Samples, *args, summary=True, **kwargs): ... return keras_model class dataGenerator: def __init__(self, *a, beg=0, end=4, srate=250, **kw): ... def __call__(self, filepath, label=False): if label: ... return label else: ... return data ... ... avg_acc = crossValidate( create_model, dataGenerator, beg=0, end=4, srate=250, splitMethod=StratifiedKFold, kFold=10, subs=range(1, 10), *a, **kw)(*args, **kwargs) ``` Note ---- More details to see the codes. ''' def __init__(self, built_fn, dataGent, splitMethod=StratifiedKFold, traindata_filepath=None, testdata_filepath=None, datadir=None, beg=0., end=4., srate=250, kFold=10, shuffle=False, random_state=None, subs: list = range(1, 10), cropping=False, winLength=None, cpt=None, step=25, standardizing=True, batch_size=10, epochs=300, patience=100, verbose=2, preserve_initfile=False, reinit=True, *args, **kwargs): self.built_fn = built_fn self.dataGent = dataGent(beg=beg, end=end, srate=srate, *args, **kwargs) self.beg = beg self.end = end self.srate = srate self.splitMethod = splitMethod self.traindata_filepath = traindata_filepath self.testdata_filepath = testdata_filepath self.datadir = datadir self.kFold = kFold self.shuffle = shuffle self.random_state = random_state self.subs = subs self.cropping = cropping self.winLength = winLength self.cpt = cpt self.step = step self.standardizing = standardizing self.batch_size = batch_size self.epochs = epochs self.patience = patience self.verbose = verbose self.preserve_initfile = preserve_initfile self.reinit = reinit self.args = args self.kwargs = kwargs self.Samples = math.ceil(self.end * self.srate - self.beg * self.srate) self._check_params() if self.datadir: for root, dirs, files in os.walk(self.datadir): if files: self.dn = files[0][0] break else: self.dn = '' self.modelstr = built_fn.__name__[7:] if self.splitMethod.__name__ == 'AllTrain': self.validation_name = 'Average Validation' else: self.validation_name = 'Cross Validation' self._new_fold = True self._last_batch = False self._readed = False self.X1 = None self.Y1 = None self.X2 = None self.Y2 = None if not os.path.exists('model'): os.makedirs('model') if not os.path.exists('result'): os.makedirs('result') # cropped training if self.winLength: if not isinstance(self.winLength, int): raise TypeError('`winLength` must be passed as int.') if self.winLength > (self.end - self.beg) * self.srate: raise ValueError( '`winLength` must less than or equal (`end` - ' '`beg`) * `srate`.') if self.cpt and not self.winLength: if (isinstance(self.cpt, float) or isinstance(self.cpt, int)): if self.cpt <= self.end - self.beg: self.winLength = self.cpt * self.srate else: raise ValueError( '`cpt` must less than or equal `end` - `beg`.') else: raise TypeError('`cpt` must be passed as int or float.') if not self.winLength: self.winLength = 2 * self.srate if self.step: if not isinstance(self.step, int): raise TypeError('`step` must be passed as int.') else: self.step = 4 def call(self, *args, **kwargs): initfile = os.path.join('.', 'CV_initweight.h5') tm = time.localtime() dirname = ( 'CV_{0:d}_{1:0>2d}_{2:0>2d}_{3:0>2d}_{4:0>2d}_{5:0>2d}_{6:s}'. format(tm.tm_year, tm.tm_mon, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec, self.modelstr)) if not os.path.exists(os.path.join('model', dirname)): os.mkdir(os.path.join('model', dirname)) if not os.path.exists(os.path.join('result', dirname)): os.mkdir(os.path.join('result', dirname)) if self.cropping: gent = self._gent_cropped_data self.Samples -= self.winLength else: gent = self._gent_data if not self.reinit: model = self.built_fn(*args, **kwargs, Samples=self.Samples) model.save_weights(initfile) earlystopping = EarlyStopping(monitor='val_loss', min_delta=0, patience=self.patience, verbose=0, mode='auto') filename = '' for key in kwargs.keys(): if key in ['l1', 'l21', 'tl1']: filename += '{0:s}({1:.8f})_'.format(key, kwargs[key]) else: filename += '{0:s}({1:0>2d})_'.format(key, kwargs[key]) avg_acci = [] avg_kappai = [] win_subs_list = [] for i in self.subs: accik = [] kappaik = [] k = 0 # count kFolds # cropped training t = 0 # record model's saving time c = 0 # count windows win = 0 # selected windows win_list = [] # selected windows list for data in gent(subject=i): if self._new_fold: # new fold for cropped training self._new_fold = False t = 0 c = 0 if self.reinit: model = self.built_fn(*args, **kwargs, Samples=self.Samples) k += 1 filepath = os.path.join( 'result', dirname, filename + '{:s}.txt'.format(self.modelstr)) with open(filepath, 'w+') as f: sys.stdout = f print(('{0:s} {1:d}-fold ' + self.validation_name + ' Accuracy').format(self.modelstr, self.kFold)) print('Subject {:0>2d} fold {:0>2d} in processing'. format(i, k)) sys.stdout = _console f.seek(0, 0) for line in f.readlines(): print(line) f.close() filepath = os.path.join( 'model', dirname, filename + self.dn + '0{0:d}T_{1:s}({2:d}).h5'.format(i, self.modelstr, k)) checkpointer = MyModelCheckpoint(filepath=filepath, verbose=1, save_best_only=True, statistic_best=True, p=0.05) history = {} else: c += 1 # TODO: fit(), evaluate() with tf.data.Dataset, then `self._new_fold` # and `self._last_batch` will be DEPRECATED. history = dict( list(history.items()) + list( model.fit(x=data['x_train'], y=data['y_train'], batch_size=self.batch_size, epochs=self.epochs, callbacks=[checkpointer, earlystopping], verbose=self.verbose, validation_data=[ data['x_val'], data['y_val'] ]).history.items())) if self.cropping: if not t == os.path.getmtime(checkpointer._filepath): t = os.path.getmtime(checkpointer._filepath) win = c # tf.keras.models.Model.fit() # tf.keras.models.Model.evaluate() # tf.data.Dataset.from_generator() # load the best model for cropped training or evaluating its accuracy model.load_weights(filepath) if self._last_batch: # the last batch for cropped training self._last_batch = False if self.cropping: win_list.append(win) x_test = data['x_test'][:, :, win * self.step:win * self.step + self.Samples, :] pd = model.predict(x_test, verbose=0) pred = np.argmax(pd, axis=1) acc = np.mean( np.squeeze(pred) == np.squeeze(data['y_test'])) kappa = computeKappa(pred, data['y_test']) print( 'win: {:0>2d}\nacc: {:.2%}\nkappa: {:.4f}'.format( win, acc, kappa)) else: loss, acc = model.evaluate(data['x_test'], data['y_test'], batch_size=self.batch_size, verbose=self.verbose) _pred = model.predict(data['x_test'], batch_size=self.batch_size, verbose=self.verbose) pred = np.argmax(_pred, axis=1) kappa = computeKappa(pred, data['y_test']) # save the train history filepath = filepath[:-3] + '.npy' np.save(filepath, history) # reset model's weights to train a new one next fold if os.path.exists(initfile) and not self.reinit: model.reset_states() model.load_weights(initfile) if self.reinit: K.clear_session() gc.collect() accik.append(acc) kappaik.append(kappa) avg_acci.append(np.average(np.array(accik))) avg_kappai.append(np.average(np.array(kappaik))) win_subs_list.append(win_list) print(win_list) self._readed = False del model avg_acc = np.average(np.array(avg_acci)) avg_kappa = np.average(np.array(avg_kappai)) filepath = os.path.join( 'result', 'CV_{0:d}_{1:0>2d}_{2:0>2d}_{3:0>2d}_{4:0>2d}_{5:0>2d}_' \ '{6:s}.txt'.format(tm.tm_year, tm.tm_mon, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec, self.modelstr)) with open(filepath, 'w+') as f: sys.stdout = f print(('{0:s} {1:d}-fold ' + self.validation_name + ' Accuracy (kappa)').format(self.modelstr, self.kFold)) for i in range(len(self.subs)): print('Subject {0:0>2d}: {1:.2%} ({2:.4f})'.format( self.subs[i], avg_acci[i], avg_kappai[i]), end='') if self.cropping: print(', Window:{:0>2d}'.format(win_subs_list[i][np.argmax( np.bincount(win_subs_list[i]))])) else: print() print('Average : {0:.2%} ({1:.4f})'.format(avg_acc, avg_kappa)) sys.stdout = _console f.seek(0, 0) for line in f.readlines(): print(line) f.close() if os.path.exists(initfile) and not self.preserve_initfile: os.remove(initfile) avg_acci.append(avg_acc) avg_kappai.append(avg_kappa) return avg_acci, avg_kappai def __call__(self, *args, **kwargs): '''Wraps `call()`.''' return self.call(*args, **kwargs) def getConfig(self): config = { 'built_fn': self.built_fn, 'dataGent': self.dataGent, 'splitMethod': self.splitMethod, 'traindata_filepath': self.traindata_filepath, 'testdata_filepath': self.testdata_filepath, 'datadir': self.datadir, 'beg': self.beg, 'end': self.end, 'srate': self.srate, 'kFold': self.kFold, 'shuffle': self.shuffle, 'random_state': self.random_state, 'subs': self.subs, 'cropping': self.cropping, 'winLength': self.winLength, 'step': self.step, 'standardizing': self.standardizing, 'batch_size': self.batch_size, 'epochs': self.epochs, 'patience': self.patience, 'verbose': self.verbose, 'preserve_initfile': self.preserve_initfile, 'reinit': self.reinit, 'args': self.args, 'kwargs': self.kwargs } return config def setConfig(self, built_fn, dataGent, splitMethod=StratifiedKFold, traindata_filepath=None, testdata_filepath=None, datadir=None, beg=0., end=4., srate=250, kFold=10, shuffle=False, random_state=None, subs: list = range(1, 10), cropping=False, winLength=None, cpt=None, step=25, standardizing=True, batch_size=10, epochs=300, patience=100, verbose=2, preserve_initfile=False, reinit=True, *args, **kwargs): self.built_fn = built_fn self.dataGent = dataGent(beg=beg, end=end, srate=srate, *args, **kwargs) self.beg = beg self.end = end self.srate = srate self.splitMethod = splitMethod self.traindata_filepath = traindata_filepath self.testdata_filepath = testdata_filepath self.datadir = datadir self.kFold = kFold self.shuffle = shuffle self.random_state = random_state self.subs = subs self.cropping = cropping self.winLength = winLength self.cpt = cpt self.step = step self.standardizing = standardizing self.batch_size = batch_size self.epochs = epochs self.patience = patience self.verbose = verbose self.preserve_initfile = preserve_initfile self.reinit = reinit self.args = args self.kwargs = kwargs self.Samples = math.ceil(self.end * self.srate - self.beg * self.srate) self._check_params() if self.datadir: for root, dirs, files in os.walk(self.datadir): if files: self.dn = files[0][0] break self.modelstr = built_fn.__name__[7:] if self.splitMethod.__name__ == 'AllTrain': self.validation_name = 'Average Validation' else: self.validation_name = 'Cross Validation' self._new_fold = True self._last_batch = False self._readed = False self.X1 = None self.Y1 = None self.X2 = None self.Y2 = None if not os.path.exists('model'): os.makedirs('model') if not os.path.exists('result'): os.makedirs('result') # cropped training if self.winLength: if not isinstance(self.winLength, int): raise TypeError('`winLength` must be passed as int.') if self.winLength > (self.end - self.beg) * self.srate: raise ValueError( '`winLength` must less than or equal (`end` - ' '`beg`) * `srate`.') if self.cpt and not self.winLength: if (isinstance(self.cpt, float) or isinstance(self.cpt, int)): if self.cpt <= self.end - self.beg: self.winLength = self.cpt * self.srate else: raise ValueError( '`cpt` must less than or equal `end` - `beg`.') else: raise TypeError('`cpt` must be passed as int or float.') if not self.winLength: self.winLength = 2 * self.srate if self.step: if not isinstance(self.step, int): raise TypeError('`step` must be passed as int.') else: self.step = 4 @staticmethod def _standardize(data: dict, trialaxis=0): '''Standardizing (z-score) on each trial, supports np.nan numbers''' # suppose every trials are independent to each other meta = ['x_train', 'x_test', 'x_val'] # to prevent different objects be the same one data = copy.deepcopy(data) for s in meta: if s in data and not data[s] is None: _len = len(data[s].shape) if _len > 1: axis = list(range(_len)) axis.pop(trialaxis) axis = tuple(axis) else: axis = -1 # z-score on trials data[s] = standardization(data[s], axis=axis) return data def _read_data(self, subject, mode): ''' Read data from dataGent. Parameters ---------- ```txt subject : int, Identifier of subject. mode : str, One of 'train' and 'test'. ``` Yields ------ ```txt data : tuple, (x, y). ``` ''' meta = ['train', 'test'] if not isinstance(mode, str): raise TypeError('`mode` must be passed as string.') if not mode in meta: raise ValueError('`mode` must be one of \'train\' and \'test\'.') if mode == 'test': if not self.testdata_filepath: self.testdata_filepath = os.path.join( self.datadir, 'Test', self.dn + '0' + str(subject) + 'E.mat') yield self.dataGent(self.testdata_filepath) self.testdata_filepath = None else: yield self.dataGent(self.testdata_filepath) else: if not self.traindata_filepath: self.traindata_filepath = os.path.join( self.datadir, 'Train', self.dn + '0' + str(subject) + 'T.mat') yield self.dataGent(self.traindata_filepath) self.traindata_filepath = None else: yield self.dataGent(self.traindata_filepath) def _gent_data(self, subject): ''' Generate (data, label) from dataGent. Parameters ---------- ```txt subject : int, Identifier of subject. ``` Yields ------ ```txt data : dict, Includes train, val and test data. ``` ''' data = { 'x_train': None, 'y_train': None, 'x_val': None, 'y_val': None, 'x_test': None, 'y_test': None } if not self._readed: # for once for (self.X1, self.Y1) in self._read_data(subject=subject, mode='test'): pass for (self.X2, self.Y2) in self._read_data(subject=subject, mode='train'): self._readed = True data['x_test'] = self.X1 data['y_test'] = self.Y1 # for multiple times for (x1, y1), (x2, y2) in self._spilt(self.X2, self.Y2): data['x_train'] = x1 data['y_train'] = y1 data['x_val'] = x2 data['y_val'] = y2 if self.standardizing: data = self._standardize(data) if data['x_val'] is None: data['x_val'] = data['x_test'] data['y_val'] = data['y_test'] self._new_fold = True self._last_batch = True yield data def _gent_cropped_data(self, subject): ''' Generate cropped (data, label) from dataGent. Not including test data. Parameters ---------- ```txt subject : int, Identifier of subject. ``` Yields ------ ```txt data : dict, Includes train, val and test data. ``` ''' temp = { 'x_train': None, 'y_train': None, 'x_val': None, 'y_val': None, 'x_test': None, 'y_test': None } L = range(0, self.Samples + 1, self.step) L = len(L) print('len(L): {0:d}'.format(L)) if not self._readed: # for once for (self.X1, self.Y1) in self._read_data(subject=subject, mode='test'): pass for (self.X2, self.Y2) in self._read_data(subject=subject, mode='train'): self._readed = True temp['x_test'] = self.X1 temp['y_test'] = self.Y1 for (x1, y1), (x2, y2) in self._spilt(self.X2, self.Y2): temp['x_train'] = x1 temp['y_train'] = y1 temp['x_val'] = x2 temp['y_val'] = y2 if temp['x_val'] is None: if self.standardizing: data = self._standardize(temp) temp['x_val'] = data['x_test'] temp['y_val'] = data['y_test'] temp['x_test'] = data['x_test'] temp['y_test'] = data['y_test'] else: data['x_train'] = x1 data['x_val'] = temp['x_val'] else: if self.standardizing: data = self._standardize(temp) temp['x_test'] = data['x_test'] temp['y_test'] = data['y_test'] else: data['x_train'] = x1 data['x_val'] = x2 i = 0 for (temp['x_train'], temp['x_val']) in self._cropping_data( (data['x_train'], data['x_val'])): i += 1 if i == 1: self._new_fold = True if i == L: self._last_batch = True yield temp def _cropping_data(self, datas: tuple): L = range(0, self.Samples + 1, self.step) for i in L: temp = () for data in datas: temp += (data[:, :, i:i + self.winLength, :], ) yield temp def _spilt(self, X, y, groups=None): """ Generate indices to split data into training and test set. Parameters ---------- X : array-like, shape (n_samples, n_features) Training data, where n_samples is the number of samples and n_features is the number of features. y : array-like, shape (n_samples,) The target variable for supervised learning problems. groups : array-like, with shape (n_samples,), optional Group labels for the samples used while splitting the dataset into train/test set. Action depends on the split method you choose. Yields ------ train : ndarray The training set indices for that split. val : ndarray The validating set indices for that split. """ sm = self.splitMethod(n_splits=self.kFold, shuffle=self.shuffle, random_state=self.random_state) for train_index, val_index in sm.split(X, y, groups): # (x_train, y_train), (x_val, y_val) if not train_index.any(): raise ValueError('Training data shouldn\'t be empty.') elif not val_index.any(): yield (X[train_index], y[train_index]), (None, None) else: yield (X[train_index], y[train_index]), (X[val_index], y[val_index]) def _check_params(self): ''' Cross Validate check parameters out. ''' # TODO: check parameters out. pass class gridSearch(crossValidate): ''' Class for K-fold Cross Validation Grid Search. Grid Search method. May better to be a subclass of `crossValidate`. This framework can collect `model`, `loss`, `acc` and `history` from each fold, and save them into files. Data spliting methods from sklearn.model_selection are supported. you can pass the classes as `splitMethod`. It can't use multiple GPUs to speed up now. To grid search on a large parameter matrix, you should use `Greedy Algorithm`. This class has implemented a magic method `__call__()` wrapping `call()`, for which it can be used like a function. Parameters ---------- ```txt built_fn : function, Create Training model which need to cross-validate. Please using string `create_` at the begining of function name, like `create_modelname`. parameters : dict, Parameters need to grid-search. Keys are the parameters' name, and every parameter values are vectors which should be passed as a list. dataGent : class, Generate data for @built_fn, shapes (n_trails, ...). It should discriminate data and label. More details see core.generators. splitMethod : class, Support split methods from module sklearn.model_selection. kFold : int, Number of K-fold. shuffle : bool, Optional Whether to shuffle each class's samples before splitting into batches, default = False. random_state : int, RandomState instance or None, optional, default = None. If int, random_state is the seed used by the random number generator; If RandomState instance, random_state is the random number generator; If None, the random number generator is the RandomState instance used by np.random. Used when shuffle == True. subs : list, list of subjects' number, like `range(1, 10)`. cropping : bool, Switch of cropped training. Default = False. winLength : int, cropping window length, default = 2*srate. step : int, cropping step, default = 1. standardizing : bool, Switch of standardizing data. Default = True. batch_size : int, Batch size. epochs : int, Training epochs. patience : int, Early stopping patience. verbose : int, One of 0, 1 and 2. *a, *args : tuple, Parameters used by @dataGent and @built_fn respectively **kw, **kwargs : dict, Parameters used by @dataGent and @built_fn respectively, **kw should include parameters called `beg`, `end` and `srate`. ``` Returns ------- ```txt avg_acc : list, Average accuracy for each subject with K-fold Cross Validation, and total average accuracy is at the last of the list avg_kappa : list, Average kappa for each subject with K-fold Cross Validation, and total average kappa is at the last of the list ``` Example ------- ```python from core.splits import StratifiedKFold def create_model(Samples, *args, summary=True, **kwargs): ... return keras_model class dataGenerator: def __init__(self, *a, beg=0, end=4, srate=250, **kw): ... def __call__(self, filepath, label=False): if label: ... return label else: ... return data ... ... parameters = {'para1':[...], 'para2':[...], ...} avg_acc = gridSearch( create_model, parameters, dataGenerator, beg=0, end=4, srate=250, splitMethod=StratifiedKFold, kFold=10, subs=range(1, 10), *a, **kw)(*args, **kwargs) ``` Note ---- More details to see the codes. ''' def __init__(self, built_fn, parameters: dict, dataGent, splitMethod=StratifiedKFold, traindata_filepath=None, testdata_filepath=None, datadir=None, beg=0, end=4, srate=250, kFold=10, shuffle=False, random_state=None, subs=range(1, 10), cropping=False, winLength=None, cpt=None, step=25, standardizing=True, batch_size=10, epochs=300, patience=100, verbose=2, preserve_initfile=False, reinit=False, *args, **kwargs): super().__init__(built_fn=built_fn, dataGent=dataGent, splitMethod=splitMethod, traindata_filepath=traindata_filepath, testdata_filepath=testdata_filepath, datadir=datadir, beg=beg, end=end, srate=srate, kFold=kFold, shuffle=shuffle, random_state=random_state, subs=subs, cropping=cropping, winLength=winLength, cpt=cpt, step=step, standardizing=standardizing, batch_size=batch_size, epochs=epochs, patience=patience, verbose=verbose, preserve_initfile=preserve_initfile, reinit=reinit, *args, **kwargs) _subs_targeted = False _subs_targeted_parameters = [] for parameter in parameters: if not parameter in self.built_fn.__code__.co_varnames: raise ValueError('`parameters` has unsupported parameter in' ' `built_fn`.') if not isinstance(parameters[parameter], list) and not isinstance( parameters[parameter], dict): parameters[parameter] = list(parameters[parameter]) if isinstance(parameters[parameter], dict): subs = list(self.subs) for subject in parameters[parameter]: if not int(subject) in self.subs: raise ValueError('`parameters` has unsolved subject' ' numbers.') if not isinstance(parameters[parameter][subject], list): parameters[parameter][subject] = list( parameters[parameter][subject]) subs.remove(int(subject)) if subs: raise ValueError('`parameters` doesn\'t include all the' ' subject numbers.') _subs_targeted = True _subs_targeted_parameters.append(parameter) temp = [] if _subs_targeted: for subject in range(1, max(self.subs) + 1): items = [] for parameter in parameters: if subject in self.subs: if parameter in _subs_targeted_parameters: items += list({ parameter: parameters[parameter][str(subject)] }.items()) else: items += list({parameter: parameters[parameter]}.items()) temp.append(dict(items)) else: for subject in range(1, max(self.subs) + 1): if subject in self.subs: temp.append(parameters) else: temp.append([]) self.parameters = temp def call(self, *args, **kwargs): ''' parameters should be lists to different subjects, then pass one subject's parameter to cv. ''' initfile = os.path.join('.', 'GSCV_initweight.h5') tm = time.localtime() dirname = ( 'GS_{0:d}_{1:0>2d}_{2:0>2d}_{3:0>2d}_{4:0>2d}_{5:0>2d}_{6:s}'. format(tm.tm_year, tm.tm_mon, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec, self.modelstr)) if not os.path.exists(os.path.join('model', dirname)): os.mkdir(os.path.join('model', dirname)) if not os.path.exists(os.path.join('result', dirname)): os.mkdir(os.path.join('result', dirname)) if self.cropping: gent = self._gent_cropped_data self.Samples -= self.winLength else: gent = self._gent_data earlystopping = EarlyStopping(monitor='val_loss', min_delta=0, patience=self.patience, verbose=0, mode='auto') def cv(*args, **kwargs): '''one subject, one parameter''' if not self.reinit: if not os.path.exists(initfile): model = self.built_fn(*args, **kwargs, Samples=self.Samples) model.save_weights(initfile) else: model = self.built_fn(*args, **kwargs, Samples=self.Samples) model.load_weights(initfile) filename = '' for key in kwargs.keys(): if key in ['l1', 'l21', 'tl1']: filename += '{0:s}({1:.8f})_'.format(key, kwargs[key]) else: filename += '{0:s}({1:0>2d})_'.format(key, kwargs[key]) acck = [] kappak = [] k = 0 # count kFolds # cropped training t = 0 # record model's saving time c = 0 # count windows win = 0 # selected windows win_list = [] # selected windows list for data in gent(subject=self.subs): if self._new_fold: # new fold for cropped training self._new_fold = False t = 0 c = 0 if self.reinit: model = self.built_fn(*args, **kwargs, Samples=self.Samples) k += 1 filepath = os.path.join( 'model', dirname, filename + self.dn + '0{0:d}T_{1:s}({2:d}).h5'.format( self.subs, self.modelstr, k)) checkpointer = MyModelCheckpoint(filepath=filepath, verbose=1, save_best_only=True, statistic_best=True, p=0.05) history = {} # TODO: fit(), evaluate() with tf.data.Dataset, then `self._new_fold` # and `self._last_batch` will be DEPRECATED. history = dict( list(history.items()) + list( model.fit(x=data['x_train'], y=data['y_train'], batch_size=self.batch_size, epochs=self.epochs, callbacks=[checkpointer, earlystopping], verbose=self.verbose, validation_data=[ data['x_val'], data['y_val'] ]).history.items())) if self.cropping: if not t == os.path.getmtime(checkpointer._filepath): t = os.path.getmtime(checkpointer._filepath) win = c # load the best model for cropped training or evaluating its accuracy model.load_weights(filepath) if self._last_batch: # the last batch for cropped training self._last_batch = False if self.cropping: win_list.append(win) x_test = data['x_test'][:, :, win * self.step:win * self.step + self.Samples, :] pd = model.predict(x_test, verbose=0) pred = np.argmax(pd, axis=1) acc = np.mean( np.squeeze(pred) == np.squeeze(data['y_test'])) kappa = computeKappa(pred, data['y_test']) else: loss, acc = model.evaluate(data['x_test'], data['y_test'], batch_size=self.batch_size, verbose=self.verbose) _pred = model.predict(data['x_test'], batch_size=self.batch_size, verbose=self.verbose) pred = np.argmax(_pred, axis=1) kappa = computeKappa(pred, data['y_test']) # save the train history npy_filepath = filepath[:-3] + '.npy' np.save(npy_filepath, history) # reset model's weights to train a new one next fold if os.path.exists(initfile) and not self.reinit: model.reset_states() model.load_weights(initfile) if self.reinit: K.clear_session() gc.collect() acck.append(acc) kappak.append(kappa) data.clear() del data K.clear_session() del model gc.collect() avg_acc = np.average(np.array(acck)) avg_kappa = np.average(np.array(kappak)) win = win_list[np.argmax(np.bincount(win_list))] filepath = os.path.join( 'result', dirname, filename + self.dn + '0{0:d}T_{1:s}.txt'.format(self.subs, self.modelstr)) with open(filepath, 'w+') as f: sys.stdout = f print(('{0:s} {1:d}-fold ' + self.validation_name + ' Accuracy').format(self.modelstr, self.kFold)) print('Subject {0:0>2d}'.format(self.subs)) for i in range(len(acck)): print('Fold {0:0>2d}: {1:.2%} ({2:.4f})'.format( i + 1, acck[i], kappak[i])) if self.cropping: print('Window:{:0>2d}'.format(win)) print('Average : {0:.2%} ({1:.4f})'.format( avg_acc, avg_kappa)) sys.stdout = _console f.seek(0, 0) for line in f.readlines(): print(line) f.close() return avg_acc, avg_kappa parameters = [] max_avg_acc = [] max_acc_kappa = [] indices = [] subs = copy.copy(self.subs) filepath = os.path.join( 'result', 'GS_{0:d}_{1:0>2d}_{2:0>2d}_{3:0>2d}_{4:0>2d}_{5:0>2d}_' \ '{6:s}.txt'.format(tm.tm_year, tm.tm_mon, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec, self.modelstr)) for subject in subs: parameters.append(self._combination(subject=subject)) count = 0 with open(filepath, 'w+') as f: sys.stdout = f print('Subject: {0:0>2d}/{1:0>2d}'.format(subject, len(subs))) print( 'Grid Search progress: {0:0>4d}/{1:0>4d}' \ '\nThe No.{2:0>4d} is in processing' .format(count, len(parameters[-1]), count + 1)) sys.stdout = _console f.seek(0, 0) for line in f.readlines(): print(line) f.close() avg_acc = [] avg_kappa = [] for parameter in parameters[-1]: self.subs = subject param = dict(parameter + list(kwargs.items())) acc, kappa = cv(*args, **param) avg_acc.append(acc) avg_kappa.append(kappa) count += 1 with open(filepath, 'w+') as f: sys.stdout = f print('Subject: {0:0>2d}/{1:0>2d}'.format( subject, len(subs))) if count < len(parameters[-1]): print( 'Grid Search progress: {0:0>4d}/{1:0>4d}' \ '\nThe No.{2:0>4d} is in processing' .format(count, len(parameters[-1]), count + 1)) else: print('Grid Search progress: {0:0>4d}/{1:0>4d}'.format( count, len(parameters[-1]))) sys.stdout = _console f.seek(0, 0) for line in f.readlines(): print(line) f.close() self._readed = False max_avg_acc.append(np.max(avg_acc)) indices.append(np.argmax(avg_acc)) max_acc_kappa.append(avg_kappa[indices[-1]]) self.subs = subs if os.path.exists(initfile) and not self.preserve_initfile: os.remove(initfile) with open(filepath, 'w+') as f: sys.stdout = f print(('{0:s} {1:d}-fold ' + self.validation_name + 'Grid Search Accuracy (kappa)').format( self.modelstr, self.kFold)) for i in range(len(self.subs)): print('Subject {0:0>2d}: {1:.2%} ({2:.4f})'.format( self.subs[i], max_avg_acc[i], max_acc_kappa[i])) print('Parameters', end='') for n in range(len(parameters[i][indices[i]])): if n == 0: print(': {0:s} = {1:.8f}'.format( parameters[i][indices[i]][n][0], parameters[i][indices[i]][n][1]), end='') else: print(', {0:s} = {1:.8f}'.format( parameters[i][indices[i]][n][0], parameters[i][indices[i]][n][1]), end='') print() print('Average : {:.2%} ({:.4f})'.format( np.average(max_avg_acc), np.average(max_acc_kappa))) sys.stdout = _console f.seek(0, 0) for line in f.readlines(): print(line) f.close() avg_acc = max_avg_acc avg_kappa = max_acc_kappa avg_acc.append(np.average(max_avg_acc)) avg_kappa.append(np.average(max_acc_kappa)) return avg_acc, avg_kappa def _combination(self, subject): '''Solve the combaination of parameters given to Grid Search''' parameters = [] parameter = [] keys = list(self.parameters[subject - 1].keys()) values = list(itertools.product(*self.parameters[subject - 1].values())) for v in values: for i in range(len(v)): parameter.append((keys[i], v[i])) parameters.append(parameter) parameter = [] return parameters def getConfig(self): config = {'parameters': self.parameters} base_config = super(crossValidate, self).getConfig() return dict(list(base_config.items()) + list(config.items())) def getSuperConfig(self): return super(crossValidate, self).getConfig() def setConfig(self, built_fn, parameters: dict, dataGent, splitMethod=StratifiedKFold, traindata_filepath=None, testdata_filepath=None, datadir=None, beg=0, end=4, srate=250, kFold=10, shuffle=False, random_state=None, subs=range(1, 10), cropping=False, winLength=None, cpt=None, step=25, standardizing=True, batch_size=10, epochs=300, patience=100, verbose=2, preserve_initfile=False, reinit=False, *args, **kwargs): super().setConfig(built_fn=built_fn, dataGent=dataGent, splitMethod=splitMethod, traindata_filepath=traindata_filepath, testdata_filepath=testdata_filepath, datadir=datadir, beg=beg, end=end, srate=srate, kFold=kFold, shuffle=shuffle, random_state=random_state, subs=subs, cropping=cropping, winLength=winLength, cpt=cpt, step=step, standardizing=standardizing, batch_size=batch_size, epochs=epochs, patience=patience, verbose=verbose, preserve_initfile=preserve_initfile, reinit=reinit, *args, **kwargs) _subs_targeted = False _subs_targeted_parameters = [] for parameter in parameters: if not parameter in self.built_fn.__code__.co_varnames: raise ValueError('`parameters` has unsupported parameter in' ' `built_fn`.') if not isinstance(parameters[parameter], list) and not isinstance( parameters[parameter], dict): parameters[parameter] = list(parameters[parameter]) if isinstance(parameters[parameter], dict): subs = list(self.subs) for subject in parameters[parameter]: if not int(subject) in self.subs: raise ValueError('`parameters` has unsolved subject' ' numbers.') if not isinstance(parameters[parameter][subject], list): parameters[parameter][subject] = list( parameters[parameter][subject]) subs.remove(int(subject)) if subs: raise ValueError('`parameters` doesn\'t include all the' ' subject numbers.') _subs_targeted = True _subs_targeted_parameters.append(parameter) temp = [] if _subs_targeted: for subject in range(1, max(self.subs) + 1): items = [] for parameter in parameters: if subject in self.subs: if parameter in _subs_targeted_parameters: items += list({ parameter: parameters[parameter][str(subject)] }.items()) else: items += list({parameter: parameters[parameter]}.items()) temp.append(dict(items)) else: for subject in range(1, max(self.subs) + 1): if subject in self.subs: temp.append(parameters) else: temp.append([]) self.parameters = temp
1.976563
2
anomaly_tuning/__init__.py
albertcthomas/anomaly_tuning
40
12788850
<filename>anomaly_tuning/__init__.py from .tuning import anomaly_tuning # noqa from . import estimators # noqa
1.132813
1